¿Qué características de OpenQASM admite Braket? - Amazon Braket
Tipos de datos de OpenQASM admitidosDeclaraciones de OpenQASM admitidasPragmas de Braket OpenQASMCompatibilidad con características avanzadas para OpenQASM en el simulador localOperaciones y gramática compatibles con OpenPulse

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

¿Qué características de OpenQASM admite Braket?

En la siguiente sección se enumeran los tipos de datos, las declaraciones y las instrucciones pragmáticas de OpenQASM 3.0 compatibles con Braket.

Tipos de datos de OpenQASM admitidos

Amazon Braket admite lo siguientes tipos de datos de OpenQASM.

  • Los números enteros no negativos se utilizan para los índices de qubits (virtuales y físicos):

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

    • h $0;

  • Se pueden usar números o constantes de punto flotante para los ángulos de rotación de la puerta:

    • rx(-0.314) $0;

    • rx(pi/4) $0;

nota

pi es una constante integrada en OpenQASM y no se puede utilizar como nombre de parámetro.

  • Se admiten matrices de números complejos (con la notación im de OpenQASM para la parte imaginaria) en los pragmas de tipo resultado para definir observables hermitianos generales y en los pragmas unitarios:

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

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

Declaraciones de OpenQASM admitidas

Amazon Braket admite las siguientes declaraciones de OpenQASM.

  • Header: OPENQASM 3;

  • Declaraciones de bit clásicas:

    • bit b1; (de forma equivalente, creg b1;)

    • bit[10] b2; (de forma equivalente, creg b2[10];)

  • Declaraciones de Qubit:

    • qubit b1; (de forma equivalente, qreg b1;)

    • qubit[10] b2; (de forma equivalente, qreg b2[10];)

  • Indexación en matrices: q[0]

  • Entrada: input float alpha;

  • especificación física qubits: $0

  • Puertas y operaciones admitidas en un dispositivo:

    • h $0;

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

nota

Las puertas admitidas en un dispositivo se encuentran en las propiedades del dispositivo para las acciones de OpenQASM; no se necesitan definiciones de puerta para utilizar esas puertas.

  • Declaraciones de cuadro verbatim Actualmente, no admitimos la notación de duración de cuadro. Las puertas nativas y los qubits físicos son obligatorios en los cuadros verbatim.

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

  • Medición y asignación de mediciones en qubits o en un registro completo de qubit.

    • measure $0;

    • measure q;

    • measure q[0];

    • b = measure q;

    • measure q → b;

  • Las instrucciones de barrera proporcionan un control explícito sobre la compilación y ejecución de los circuitos al impedir que las puertas se reordenen y optimicen más allá de los límites de las barreras. También imponen un orden temporal estricto durante la ejecución, lo que garantiza que todas las operaciones ante una barrera se completen antes de que comiencen las siguientes.

    • barrier;

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

    • barrier $3, $6;

Pragmas de Braket OpenQASM

Amazon Braket admite las siguientes instrucciones de pragma OpenQASM.

  • Pragmas de ruido

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

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

    • #pragma braket noise pauli_channel

  • Pragmas verbatim

    • #pragma braket verbatim

  • Pragmas de tipo de resultado

    • Tipos de resultados invariantes de base:

      • Vector de estado: #pragma braket result state_vector

      • Matriz de densidad: #pragma braket result density_matrix

    • Pragmas de cómputo de gradiente:

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

    • Tipos de resultados de base Z:

      • Amplitud: #pragma braket result amplitude "01"

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

    • Tipos de resultados rotados de base

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

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

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

nota

OpenQASM 3.0 es compatible con OpenQASM 2.0, por lo que los programas escritos con la versión 2.0 pueden ejecutarse en Braket. Sin embargo, las características de OpenQASM 3.0 compatibles con Braket presentan algunas pequeñas diferencias de sintaxis, como qreg frente a creg y qubit frente a bit. También hay diferencias en la sintaxis de medición y es necesario admitirlas con su sintaxis correcta.

Compatibilidad con características avanzadas para OpenQASM en el simulador local

El LocalSimulator admite características avanzadas de OpenQASM que no se ofrecen como parte de las QPU de Braket ni de los simuladores bajo demanda. La siguiente lista de características solo se admite en el LocalSimulator:

  • Modificadores de puertas

  • Puertas integradas de OpenQASM

  • Variables clásicas

  • Operaciones clásicas

  • Puertas personalizadas

  • Control clásico

  • Archivos QASM

  • Subrutinas

Para ver ejemplos de cada característica avanzada, consulte este cuaderno de ejemplo. Para ver la especificación completa de OpenQASM, consulte el sitio web de OpenQASM.

Operaciones y gramática compatibles con OpenPulse

Tipos OpenPulse de datos compatibles

Bloques de cal:

cal {
    ...
}

Bloques de defcal:

// 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 {
...
}

Marcos:

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};

Ejemplo de calibración de puerta 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;

Ejemplo de pulso arbitrario: 

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);
}