Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Quelles sont les fonctionnalités d'OpenQASM prises en charge par Braket ?
La section suivante répertorie les types de données, les instructions et les instructions pragma d'OpenQASM 3.0 pris en charge par Braket.
**Topics**
+ [Types de données OpenQASM pris en charge](#braket-openqasm-supported-features-datatypes)
+ [Déclarations OpenQASM prises en charge](#braket-openqasm-supported-features-statements)
+ [Pragmas OpenQASM de Braket](#braket-openqasm-supported-features-pragmas)
+ [Support des fonctionnalités avancées pour OpenQASM sur le simulateur local](#braket-openqasm-supported-features-advanced-feature-local-simulator)
+ [Opérations et grammaire prises en charge avec OpenPulse](#braket-openpulse-supported-operations-grammar)
## Types de données OpenQASM pris en charge
Les types de données OpenQASM 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 à OpenQASM et ne peut pas être utilisée comme nom de paramètre.
+ Les tableaux de nombres complexes (avec la `im` notation OpenQASM pour les parties imaginaires) 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]`
## Déclarations OpenQASM prises en charge
Les instructions OpenQASM 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 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 périphérique se trouvent dans les propriétés de l'appareil pour les actions OpenQASM ; 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. Les portes natives et physiques qubits sont obligatoires dans les boîtes de saisie des verbatims.
```
#pragma braket verbatim
box{
rx(0.314) $0;
}
```
+ Mesure et attribution de mesures sur qubits ou sur un qubit registre complet.
+ `measure $0;`
+ `measure q;`
+ `measure q[0];`
+ `b = measure q;`
+ `measure q → b;`
+ Les instructions Barrier fournissent un contrôle explicite sur la compilation et l'exécution des circuits en empêchant la réorganisation des portes et les optimisations au-delà des limites des barrières. Ils appliquent également un ordre temporel strict lors de l'exécution, garantissant ainsi toutes les opérations avant la fin d'une barrière avant le début des opérations suivantes.
+ `barrier;`
+ `barrier q[0], q[1];`
+ `barrier $3, $6;`
## Pragmas OpenQASM de Braket
Les instructions pragma OpenQASM 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**
OpenQASM 3.0 est rétrocompatible avec OpenQASM 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'OpenQASM 3.0 prises en charge par Braket présentent quelques différences syntaxiques mineures, telles que `qreg` vs et vs. `creg` `qubit` `bit` 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 OpenQASM sur le simulateur local
Il `LocalSimulator` prend en charge les fonctionnalités avancées d'OpenQASM qui ne sont pas proposées dans le cadre des QPU de Braket ou des simulateurs à la demande. La liste de fonctionnalités suivante n'est prise en charge que dans `LocalSimulator` :
+ Modificateurs de portail
+ Portails intégrés OpenQASM
+ Variables classiques
+ Opérations classiques
+ Portails personnalisés
+ Contrôle classique
+ fichiers QASM
+ Sous-programmes
Pour des exemples de chaque fonctionnalité avancée, consultez cet [exemple de bloc-notes](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb). [Pour la spécification complète d'OpenQASM, consultez le site Web d'OpenQASM.](https://openqasm.com/language/index.html)
## 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);
}
```