Quelles sont les QASM fonctionnalités ouvertes prises en charge par Braket ?

La section suivante répertorie les types de données Open QASM 3.0, les instructions et les instructions pragma pris en charge par Braket.

Types de QASM données ouvertes pris en charge

Les types de QASM données ouvertes suivants sont pris en charge par Amazon Braket.

• Des entiers non négatifs sont utilisés pour les indices de qubits (virtuels et physiques) :

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

  • h $0;

• Des nombres à virgule flottante ou des constantes peuvent être utilisés pour les angles de rotation des portes :

  • rx(-0.314) $0;

  • rx(pi/4) $0;

Note

pi est une constante intégrée à Open QASM et ne peut pas être utilisée comme nom de paramètre.

• Les tableaux de nombres complexes (avec la QASM im notation ouverte pour la partie imaginaire) sont autorisés dans les pragmas de type résultat pour définir les observables hermitiens généraux et dans les pragmas unitaires :

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

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

QASMDéclarations ouvertes soutenues

Les QASM déclarations Open suivantes sont prises en charge par Amazon Braket.

• Header: OPENQASM 3;

• Déclarations binaires classiques :

  • bit b1;(de manière équivalente,creg b1;)

  • bit[10] b2;(de manière équivalente,creg b2[10];)

• Déclarations Qubit :

  • qubit b1;(de manière équivalente,qreg b1;)

  • qubit[10] b2;(de manière équivalente,qreg b2[10];)

• Indexation au sein de tableaux : q[0]

• Entrée : input float alpha;

• spécification de la physique qubits: $0

• Portails et opérations pris en charge sur un appareil :

  • h $0;

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

Note

Les portes prises en charge par un appareil se trouvent dans les propriétés de l'appareil pour les QASM actions ouvertes ; aucune définition de porte n'est nécessaire pour utiliser ces portes.

• Relevés verbatim box. Actuellement, nous ne prenons pas en charge la notation de la durée des boîtes. Portails natifs et physiques qubits sont obligatoires dans les boîtes verbatim.

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

• Mesure et assignation de mesure sur qubits ou un tout qubit s'inscrire.

  • measure $0;

  • measure q;

  • measure q[0];

  • b = measure q;

  • measure q → b;

Note

pi est une constante intégrée à Open QASM et ne peut pas être utilisée comme nom de paramètre.

Pragmas Braket Open QASM

Les instructions Open QASM Pragma suivantes sont prises en charge par Amazon Braket.

• Pragmas relatifs au bruit

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

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

  • #pragma braket noise pauli_channel

• Pragmas textuels

  • #pragma braket verbatim

• Type de résultat : pragmas

  • Types de résultats invariants de base :

    • Vecteur d'état : #pragma braket result state_vector

    • Matrice de densité : #pragma braket result density_matrix

  • Pragmas de calcul du gradient :

    • Dégradé adjoint : #pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all

  • Types de résultats de base Z :

    • Amplitude : #pragma braket result amplitude "01"

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

  • Types de résultats basés sur une rotation

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

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

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

Note

Open QASM 3.0 est rétrocompatible avec Open QASM 2.0, de sorte que les programmes écrits à l'aide de la version 2.0 peuvent s'exécuter sur Braket. Cependant, les fonctionnalités d'Open QASM 3.0 prises en charge par Braket présentent quelques différences syntaxiques mineures, telles que qreg vs creg et qubit vsbit. Il existe également des différences dans la syntaxe des mesures, et celles-ci doivent être prises en charge par leur syntaxe correcte.

Support des fonctionnalités avancées pour Open QASM on the Local Simulator

Il LocalSimulator prend en charge les QASM fonctionnalités ouvertes avancées qui ne sont pas proposées dans le cadre des simulateurs QPU de Braket ou à la demande. La liste de fonctionnalités suivante n'est prise en charge que dans LocalSimulator :

• Modificateurs de portail

• Portes QASM intégrées ouvertes

• Variables classiques

• Opérations classiques

• Portails personnalisés

• Contrôle classique

• QASMfichiers

• Sous-programmes

Pour des exemples de chaque fonctionnalité avancée, consultez cet exemple de bloc-notes. Pour la QASM spécification Open complète, consultez le QASMsite Web Open.

Opérations et grammaire prises en charge avec OpenPulse

Types de OpenPulse données pris en charge

Blocs d'appels :

cal {
    ...
}

Blocs de décalcomanie :

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

Cadres :

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

Formes d'onde :

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

Exemple d'étalonnage de portail personnalisé :

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;

Exemple d'impulsion arbitraire :

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