Quais recursos do OpenQASM o Braket suporta? - Amazon Braket
Tipos de dados do OpenQASM com suporteDeclarações do OpenQASM compatíveisPragmas Braket OpenQASMSuporte de recursos avançados para o OpenQASM no simulador localOperações e gramática suportadas com OpenPulse

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Quais recursos do OpenQASM o Braket suporta?

A seção a seguir lista os tipos de dados, declarações e instruções pragmáticas do OpenQASM 3.0 suportados pelo Braket.

Tipos de dados do OpenQASM com suporte

Os seguintes tipos de dados são compatíveis com o Amazon Braket:

  • Números inteiros não negativos são usados para índices de qubit (virtuais e físicos):

    • cnot q[0], q[1];

    • h $0;

  • Números ou constantes de ponto flutuante podem ser usados para ângulos de rotação da porta:

    • rx(-0.314) $0;

    • rx(pi/4) $0;

nota

pi é uma constante embutida no OpenQasm e não pode ser usada como nome de parâmetro.

  • Matrizes de números complexos (com a notação im OpenQASM para parte imaginária) são permitidas em pragmas de tipo de resultado para definir observáveis hermitianos gerais e em pragmas unitários:

    • #pragma braket unitary [[0, -1im], [1im, 0]] q[0]

    • #pragma braket result expectation hermitian([[0, -1im], [1im, 0]]) q[0]

Declarações do OpenQASM compatíveis

As seguintes declarações do OpenQASM são apoiadas pelo Amazon Braket.

  • Header: OPENQASM 3;

  • Declarações de bits clássicas:

    • bit b1; (equivalentemente, creg b1;)

    • bit[10] b2; (equivalentemente, creg b2[10];)

  • Declarações de qubit:

    • qubit b1; (equivalentemente, qreg b1;)

    • qubit[10] b2; (equivalentemente, qreg b2[10];)

  • Indexação em matrizes: q[0]

  • Entrada: input float alpha;

  • especificação do qubits físico: $0

  • Portas e operações compatíveis em um dispositivo:

    • h $0;

    • iswap q[0], q[1];

nota

As portas compatíveis de um dispositivo podem ser encontradas nas propriedades do dispositivo para ações do OpenQASM; nenhuma definição de porta é necessária para usar essas portas.

  • Declarações textuais. Atualmente, não oferecemos suporte à notação de duração da caixa. Portas qubits nativas e físicas são obrigatórias em caixas textuais.

#pragma braket verbatim
box{
    rx(0.314) $0;
}

  • Medição e atribuição de medições em qubits ou em um registro qubit completo.

    • measure $0;

    • measure q;

    • measure q[0];

    • b = measure q;

    • measure q → b;

  • As declarações de barreira fornecem controle explícito sobre a compilação e execução do circuito, impedindo a reordenação e as otimizações das portas além dos limites das barreiras. Eles também impõem uma ordem temporal estrita durante a execução, garantindo que todas as operações antes de uma barreira sejam concluídas antes do início das operações subsequentes.

    • barrier;

    • barrier q[0], q[1];

    • barrier $3, $6;

Pragmas Braket OpenQASM

As seguintes instruções do pragma OpenQASM são compatíveis pelo Amazon Braket.

  • Pragmas de ruído

    • #pragma braket noise bit_flip(0.2) q[0]

    • #pragma braket noise phase_flip(0.1) q[0]

    • #pragma braket noise pauli_channel

  • Pragmas literais

    • #pragma braket verbatim

  • Pragmas de tipos de resultados

    • Tipos de resultados invariantes básicos:

      • Vetor de estado: #pragma braket result state_vector

      • Matriz de densidade: #pragma braket result density_matrix

    • Pragmas de computação de gradiente:

      • Gradiente adjunto: #pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all

    • Tipos de resultados básicos Z:

      • Amplitude #pragma braket result amplitude "01"

      • Probabilidade #pragma braket result probability q[0], q[1]

    • Tipos de resultados rotacionados de base

      • Expectativa: #pragma braket result expectation x(q[0]) @ y([q1])

      • Variância: #pragma braket result variance hermitian([[0, -1im], [1im, 0]]) $0

      • Amostra: #pragma braket result sample h($1)

nota

O OpenQASM 3.0 é compatível com versões anteriores do OpenQASM 2.0, portanto, programas escritos usando 2.0 podem ser executados no Braket. No entanto, os recursos do OpenQASM 3.0 suportados pelo Braket têm algumas pequenas diferenças de sintaxe, como qreg vs creg e qubit vs bit. Também há diferenças na sintaxe de medição, e elas precisam ser compatíveis com a sintaxe correta.

Suporte de recursos avançados para o OpenQASM no simulador local

LocalSimulator suporta recursos avançados do OpenQASM que não são oferecidos como parte dos QPUs ou simuladores sob demanda da Braket. A lista de recursos a seguir só é compatível no LocalSimulator:

  • Modificadores de porta

  • Portas embutidas OpenQASM

  • Variáveis clássicas

  • Operações clássicas

  • Portas personalizadas

  • Controle do Classic

  • Arquivos ASM

  • Sub-rotinas

Para ver exemplos de cada recurso avançado, consulte este exemplo de caderno. Para obter a especificação completa do OpenQASM, consulte o site do OpenQASM.

Operações e gramática suportadas com OpenPulse

Tipos OpenPulse de dados compatíveis

Blocos de chamadas:

cal {
    ...
}

Blocos decalques:

// 1 qubit
defcal x $0 {
...
}

// 1 qubit w. input parameters as constants
defcal my_rx(pi) $0 {
...
}

// 1 qubit w. input parameters as free parameters
defcal my_rz(angle theta) $0 {
...
}

// 2 qubit (above gate args are also valid)
defcal cz $1, $0 {
...
}

Quadros:

frame my_frame = newframe(port_0, 4.5e9, 0.0);

Formas de onda:

// prebuilt
waveform my_waveform_1 = constant(1e-6, 1.0);

//arbitrary
waveform my_waveform_2 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1};

Exemplo de calibração de porta personalizada: 

cal {
    waveform wf1 = constant(1e-6, 0.25);
}

defcal my_x $0 {
   play(wf1, q0_rf_frame);
}

defcal my_cz $1, $0 {
    barrier q0_q1_cz_frame, q0_rf_frame;
    play(q0_q1_cz_frame, wf1);
    delay[300ns] q0_rf_frame
    shift_phase(q0_rf_frame, 4.366186381749424);
    delay[300ns] q0_rf_frame;
    shift_phase(q0_rf_frame.phase, 5.916747563126659);
    barrier q0_q1_cz_frame, q0_rf_frame;
    shift_phase(q0_q1_cz_frame, 2.183093190874712);
}

bit[2] ro;
my_x $0;
my_cz $1,$0;
c[0] = measure $0;

Exemplo de pulso arbitrário: 

bit[2] ro;
cal {
    waveform wf1 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1};
    barrier q0_drive, q0_q1_cross_resonance;
    play(q0_q1_cross_resonance, wf1);
    delay[300ns] q0_drive;
    shift_phase(q0_drive, 4.366186381749424);
    delay[300dt] q0_drive;
   barrier q0_drive, q0_q1_cross_resonance;
   play(q0_q1_cross_resonance, wf1);
    ro[0] = capture_v0(r0_measure);
    ro[1] = capture_v0(r1_measure);
}