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. # Exécutez vos circuits avec OpenQASM 3.0 AmazonBraket prend désormais en charge [OpenQASM 3.0](https://openqasm.com/) pour les dispositifs quantiques et les simulateurs basés sur des portes. Ce guide de l'utilisateur fournit des informations sur le sous-ensemble d'OpenQASM 3.0 pris en charge par Braket. [Les clients de Braket ont désormais le choix de soumettre des circuits Braket avec le [SDK](braket-constructing-circuit.md) ou de fournir directement des chaînes OpenQASM 3.0 à tous les appareils basés sur un portail avec l'[API Amazon Braket et le SDK Amazon Braket](https://docs.aws.amazon.com/braket/latest/APIReference/Welcome.html) Python.](https://github.com/aws/amazon-braket-sdk-python) Les rubriques de ce guide vous présentent divers exemples illustrant comment effectuer les tâches quantiques suivantes. + [Créez et soumettez des tâches quantiques OpenQASM sur différents appareils Braket](braket-openqasm-create-submit-task.md) + [Accédez aux opérations prises en charge et aux types de résultats](braket-openqasm-device-support.md#braket-openqasm-supported-operations-results-result-types) + [Simulez le bruit avec OpenQASM](braket-openqasm-noise-simulation.md) + [Utiliser la compilation textuelle avec OpenQASM](braket-openqasm-verbatim-compilation.md) + [Résoudre les problèmes liés à OpenQASM](https://docs.aws.amazon.com/braket/latest/developerguide/braket-troubleshooting-openqasm.html) Ce guide fournit également une introduction à certaines fonctionnalités spécifiques au matériel qui peuvent être implémentées avec OpenQASM 3.0 sur Braket et des liens vers d'autres ressources. **Topics** + [Qu'est-ce qu'OpenQASM 3.0 ?](#braket-openqasm-what-is) + [Quand utiliser OpenQASM 3.0](#braket-openqasm-when-to-use) + [Comment fonctionne OpenQASM 3.0](#braket-openqasm-how-it-works) + [Conditions préalables](#braket-openqasm-prerequisites) + [Quelles sont les fonctionnalités d'OpenQASM prises en charge par Braket ?](braket-openqasm-supported-features.md) + [Créez et soumettez un exemple de tâche quantique OpenQASM 3.0](braket-openqasm-create-submit-task.md) + [Support d'OpenQASM sur différents appareils Braket](braket-openqasm-device-support.md) + [Simulez le bruit avec OpenQASM 3.0](braket-openqasm-noise-simulation.md) + [Qubitrecâblage avec OpenQASM 3.0](braket-openqasm-rewire-qubits.md) + [Compilation Verbatim avec OpenQASM 3.0](braket-openqasm-verbatim-compilation.md) + [La console Braket](#braket-openqasm-braket-console) + [Ressources supplémentaires](#braket-openqasm-more-resources) + [Calculer des dégradés avec OpenQASM 3.0](braket-openqasm-computing-gradients.md) + [Mesurer des qubits spécifiques avec OpenQASM 3.0](braket-openqasm-measure-qubits.md) ## Qu'est-ce qu'OpenQASM 3.0 ? L'Open Quantum Assembly Language (OpenQASM) est une [représentation intermédiaire](https://en.wikipedia.org/wiki/Intermediate_representation) pour les instructions quantiques. OpenQASM est un framework open source largement utilisé pour la spécification de programmes quantiques pour les appareils basés sur des portes. Avec OpenQASM, les utilisateurs peuvent programmer les portes quantiques et les opérations de mesure qui constituent les éléments de base du calcul quantique. La version précédente d'OpenQASM (2.0) était utilisée par un certain nombre de bibliothèques de programmation quantique pour décrire des programmes de base. La nouvelle version d'OpenQASM (3.0) étend la version précédente pour inclure davantage de fonctionnalités, telles que le contrôle du niveau des impulsions, le chronométrage des portes et le flux de contrôle classique pour combler le fossé entre l'interface utilisateur final et le langage de description du matériel. Les détails et les spécifications de la version 3.0 actuelle sont disponibles sur la spécification GitHub [OpenQASM 3.x Live](https://github.com/openqasm/openqasm). Le futur développement d'OpenQASM est régi par le [comité de pilotage technique](https://aws.amazon.com/blogs/quantum-computing/aws-joins-the-openqasm-3-0-technical-steering-committee/) d'OpenQASM 3.0, dont AWS il est membre aux côtés d'IBM, Microsoft et de l'université d'Innsbruck. ## Quand utiliser OpenQASM 3.0 OpenQASM fournit un cadre expressif permettant de spécifier des programmes quantiques par le biais de contrôles de bas niveau qui ne sont pas spécifiques à une architecture, ce qui le rend parfaitement adapté en tant que représentation sur plusieurs appareils basés sur des portes. La prise en charge d'OpenQASM par Braket favorise son adoption en tant qu'approche cohérente du développement d'algorithmes quantiques basés sur des portes, réduisant ainsi le besoin pour les utilisateurs d'apprendre et de gérer des bibliothèques dans plusieurs frameworks. Si vous avez des bibliothèques de programmes existantes dans OpenQASM 3.0, vous pouvez les adapter pour les utiliser avec Braket plutôt que de réécrire complètement ces circuits. Les chercheurs et les développeurs devraient également bénéficier d'un nombre croissant de bibliothèques tierces disponibles prenant en charge le développement d'algorithmes dans OpenQASM. ## Comment fonctionne OpenQASM 3.0 Support d'OpenQASM 3.0 par Braket assure la parité des fonctionnalités avec la représentation intermédiaire actuelle. Cela signifie que tout ce que vous pouvez faire aujourd'hui sur des appareils matériels et des simulateurs à la demande avec Braket, vous pouvez le faire avec OpenQASM en utilisant Braket. API Vous pouvez exécuter des programmes OpenQASM 3.0 en fournissant directement des chaînes OpenQASM à tous les périphériques basés sur un portail, de la même manière que les circuits sont actuellement fournis aux périphériques sur Braket. Les utilisateurs de Braket peuvent également intégrer des bibliothèques tierces compatibles avec OpenQASM 3.0. Le reste de ce guide explique comment développer des représentations OpenQASM à utiliser avec Braket. ## Conditions préalables [Pour utiliser OpenQASM 3.0 sur Amazon Braket, vous devez disposer de la version v1.8.0 des schémas Python Amazon Braket et de la version v1.17.0 ou supérieure du SDK [Amazon Braket Python](https://github.com/aws/amazon-braket-schemas-python).](https://github.com/aws/amazon-braket-sdk-python) Si vous utilisez Amazon Braket pour la première fois, vous devez activer Amazon Braket. Pour obtenir des instructions, consultez [Activer Amazon Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-enable-overview.html). # 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); } ``` # Créez et soumettez un exemple de tâche quantique OpenQASM 3.0 Vous pouvez utiliser le SDK Amazon Braket Python, Boto3 ou le pour envoyer des tâches quantiques OpenQASM 3.0 AWS CLI à un appareil Amazon Braket. **Topics** + [Exemple de programme OpenQASM 3.0](#braket-openqasm-example-program) + [Utilisez le SDK Python pour créer des tâches quantiques OpenQASM 3.0](#braket-openqasm-create-tasks-with-python-sdk) + [Utilisez Boto3 pour créer des tâches quantiques OpenQASM 3.0](#braket-openqasm-create-tasks-with-boto3) + [Utilisez le AWS CLI pour créer des tâches OpenQASM 3.0](#braket-openqasm-create-tasks-with-aws-cli) ## Exemple de programme OpenQASM 3.0 [Pour créer une tâche OpenQASM 3.0, vous pouvez commencer par un programme OpenQASM 3.0 de base (ghz.qasm) qui prépare un état GHZ comme indiqué dans l'exemple suivant.](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; qubit[3] q; bit[3] c; h q[0]; cnot q[0], q[1]; cnot q[1], q[2]; c = measure q; ``` ## Utilisez le SDK Python pour créer des tâches quantiques OpenQASM 3.0 Vous pouvez utiliser le [SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python) pour envoyer ce programme à un appareil Amazon Braket à l'aide du code suivant. Assurez-vous de remplacer l'exemple d'emplacement du compartiment Amazon S3 « amzn-s3-demo-bucket » par le nom de votre propre compartiment Amazon S3. ``` with open("ghz.qasm", "r") as ghz: ghz_qasm_string = ghz.read() # Import the device module from braket.aws import AwsDevice # Choose the Rigetti device device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") from braket.ir.openqasm import Program program = Program(source=ghz_qasm_string) my_task = device.run(program) # Specify an optional s3 bucket location and number of shots s3_location = ("amzn-s3-demo-bucket", "openqasm-tasks") my_task = device.run( program, s3_location, shots=100, ) ``` ## Utilisez Boto3 pour créer des tâches quantiques OpenQASM 3.0 Vous pouvez également utiliser le [SDK AWS Python pour Braket (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/braket.html) pour créer les tâches quantiques à l'aide de chaînes OpenQASM 3.0, comme indiqué dans l'exemple suivant. [L'extrait de code suivant fait référence à ghz.qasm qui prépare un état GHZ comme indiqué ci-dessus.](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) ``` import boto3 import json my_bucket = "amzn-s3-demo-bucket" s3_prefix = "openqasm-tasks" with open("ghz.qasm") as f: source = f.read() action = { "braketSchemaHeader": { "name": "braket.ir.openqasm.program", "version": "1" }, "source": source } device_parameters = {} device_arn = "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" shots = 100 braket_client = boto3.client('braket', region_name='us-west-1') rsp = braket_client.create_quantum_task( action=json.dumps( action ), deviceParameters=json.dumps( device_parameters ), deviceArn=device_arn, shots=shots, outputS3Bucket=my_bucket, outputS3KeyPrefix=s3_prefix, ) ``` ## Utilisez le AWS CLI pour créer des tâches OpenQASM 3.0 La [AWS Command Line Interface (CLI)](https://aws.amazon.com/cli/) peut également être utilisée pour soumettre des programmes OpenQASM 3.0, comme indiqué dans l'exemple suivant. ``` aws braket create-quantum-task \ --region "us-west-1" \ --device-arn "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" \ --shots 100 \ --output-s3-bucket "amzn-s3-demo-bucket" \ --output-s3-key-prefix "openqasm-tasks" \ --action '{ "braketSchemaHeader": { "name": "braket.ir.openqasm.program", "version": "1" }, "source": $(cat ghz.qasm) }' ``` # Support d'OpenQASM sur différents appareils Braket Pour les appareils compatibles avec OpenQASM 3.0, le `action` champ prend en charge une nouvelle action par le biais de la `GetDevice` réponse, comme indiqué dans l'exemple suivant pour les Rigetti périphériques et. IonQ ``` //OpenQASM as available with the Rigetti device capabilities { "braketSchemaHeader": { "name": "braket.device_schema.rigetti.rigetti_device_capabilities", "version": "1" }, "service": {...}, "action": { "braket.ir.jaqcd.program": {...}, "braket.ir.openqasm.program": { "actionType": "braket.ir.openqasm.program", "version": [ "1" ], …. } } } //OpenQASM as available with the IonQ device capabilities { "braketSchemaHeader": { "name": "braket.device_schema.ionq.ionq_device_capabilities", "version": "1" }, "service": {...}, "action": { "braket.ir.jaqcd.program": {...}, "braket.ir.openqasm.program": { "actionType": "braket.ir.openqasm.program", "version": [ "1" ], …. } } } ``` Pour les appareils qui prennent en charge le contrôle du pouls, `pulse` le champ est affiché dans la `GetDevice` réponse. L'exemple suivant montre ce `pulse` champ pour le Rigetti périphérique. ``` // Rigetti { "pulse": { "braketSchemaHeader": { "name": "braket.device_schema.pulse.pulse_device_action_properties", "version": "1" }, "supportedQhpTemplateWaveforms": { "constant": { "functionName": "constant", "arguments": [ { "name": "length", "type": "float", "optional": false }, { "name": "iq", "type": "complex", "optional": false } ] }, ... }, "ports": { "q0_ff": { "portId": "q0_ff", "direction": "tx", "portType": "ff", "dt": 1e-9, "centerFrequencies": [ 375000000 ] }, ... }, "supportedFunctions": { "shift_phase": { "functionName": "shift_phase", "arguments": [ { "name": "frame", "type": "frame", "optional": false }, { "name": "phase", "type": "float", "optional": false } ] }, ... }, "frames": { "q0_q1_cphase_frame": { "frameId": "q0_q1_cphase_frame", "portId": "q0_ff", "frequency": 462475694.24460185, "centerFrequency": 375000000, "phase": 0, "associatedGate": "cphase", "qubitMappings": [ 0, 1 ] }, ... }, "supportsLocalPulseElements": false, "supportsDynamicFrames": false, "supportsNonNativeGatesWithPulses": false, "validationParameters": { "MAX_SCALE": 4, "MAX_AMPLITUDE": 1, "PERMITTED_FREQUENCY_DIFFERENCE": 400000000 } } } ``` Les champs précédents détaillent les éléments suivants : **Ports :** Décrit les ports de périphériques externes (`extern`) prédéfinis déclarés sur le QPU en plus des propriétés associées au port donné. Tous les ports répertoriés dans cette structure sont prédéclarés en tant qu'identifiants valides dans le `OpenQASM 3.0` programme soumis par l'utilisateur. Les propriétés supplémentaires d'un port sont les suivantes : + Identifiant du port (PortID) + Le nom de port déclaré comme identifiant dans OpenQASM 3.0. + Direction (direction) + La direction du port. Les ports d'entraînement transmettent des impulsions (direction « tx »), tandis que les ports de mesure reçoivent des impulsions (direction « rx »). + Type de port (PortType) + Type d'action dont ce port est responsable (par exemple, drive, capture ou ff - fast-flux). + Dt (dt) + Durée en secondes qui représente un seul pas de temps d'échantillonnage sur le port donné. + Mappages de qubits (QubitMappings) + Les qubits associés au port donné. + Fréquences centrales (CenterFrequencies) + Liste des fréquences centrales associées pour toutes les trames prédéclarées ou définies par l'utilisateur sur le port. Pour plus d'informations, reportez-vous à la section Cadres. + Propriétés spécifiques à QHP () qhpSpecificProperties + Une carte facultative détaillant les propriétés existantes concernant le port spécifique au QHP. **Cadres :** Décrit les cadres externes préfabriqués déclarés sur le QPU ainsi que les propriétés associées aux cadres. Toutes les trames répertoriées dans cette structure sont prédéclarées comme des identifiants valides dans le `OpenQASM 3.0` programme soumis par l'utilisateur. Les propriétés supplémentaires d'un cadre sont les suivantes : + ID du cadre (FrameID) + Le nom du cadre déclaré comme identifiant dans OpenQASM 3.0. + Identifiant du port (ID du port) + Le port matériel associé à la trame. + Fréquence (fréquence) + Fréquence initiale par défaut de la trame. + Fréquence centrale (CenterFrequency) + Le centre de la bande passante de fréquence de la trame. Généralement, les trames ne peuvent être ajustées qu'à une certaine bande passante autour de la fréquence centrale. Par conséquent, les ajustements de fréquence doivent rester dans un delta donné par rapport à la fréquence centrale. Vous pouvez trouver la valeur de bande passante dans les paramètres de validation. + Phase (phase) + Phase initiale par défaut de la trame. + Porte associée (porte associée) + Les portes associées à la trame donnée. + Mappages de qubits (QubitMappings) + Les qubits associés à la trame donnée. + Propriétés spécifiques à QHP () qhpSpecificProperties + Une carte optionnelle détaillant les propriétés existantes concernant le cadre spécifique au QHP. **SupportsDynamicFrames:** Décrit si un cadre peut être déclaré `cal` ou bloqué par `defcal` le biais de la OpenPulse `newframe` fonction. Si cette valeur est fausse, seules les images répertoriées dans la structure des cadres peuvent être utilisées dans le programme. **SupportedFunctions:** Décrit les OpenPulse fonctions prises en charge par le périphérique en plus des arguments, des types d'arguments et des types de retour associés aux fonctions données. Pour voir des exemples d'utilisation des OpenPulse fonctions, reportez-vous à la [OpenPulsespécification](https://openqasm.com/language/openpulse.html). À l'heure actuelle, Braket prend en charge : + shift\$1phase + Déplace la phase d'une image d'une valeur spécifiée + set\$1phase + Définit la phase du cadre à la valeur spécifiée + phases d'échange + Échange les phases entre deux images. + shift\$1frequency + Déplace la fréquence d'une image d'une valeur spécifiée + set\$1frequency + Définit la fréquence de l'image à la valeur spécifiée + jouer + Planifie une forme d'onde + capture\$1v0 + Renvoie la valeur d'une image de capture dans un registre de bits **SupportedQhpTemplateWaveforms:** Décrit les fonctions de forme d'onde prédéfinies disponibles sur le périphérique ainsi que les arguments et les types associés. Par défaut, Braket Pulse propose des routines de forme d'onde prédéfinies sur tous les appareils, à savoir : ***Constante*** ![\[Équation mathématique montrant une fonction constante avec les paramètres t, tau et iq où le résultat est toujours égal à iq.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/ConstantFunction.png) `τ`est la longueur de la forme d'onde et `iq` est un nombre complexe. ``` def constant(length, iq) ``` ***Gaussien*** ![\[Équation mathématique montrant la fonction gaussienne avec les paramètres t, tau, sigma, A=1 et Zae=0.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/GaussianFunction.png) `τ`est la longueur de la forme d'onde, `σ` la largeur de la gaussienne et l'amplitude`A`. Si elle est réglée `ZaE` sur`True`, la valeur gaussienne est décalée et redimensionnée de telle sorte qu'elle soit égale à zéro au début et à la fin de la forme d'onde, et qu'elle atteigne son maximum. `A` ``` def gaussian(length, sigma, amplitude=1, zero_at_edges=False) ``` ***DRAG Gaussien*** ![\[Équation mathématique pour la distribution gaussienne DRAG avec les paramètres t, tau, sigma, beta, A=1 et zAE=0.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/DRAGGaussianFunction.png) `τ`est la longueur de la forme d'onde, `σ` est la largeur de la gaussienne, `β` est un paramètre libre et `A` est l'amplitude. Si cette valeur est `ZaE` définie sur`True`, la valeur gaussienne de suppression des dérivées par porte adiabatique (DRAG) est décalée et redimensionnée de telle sorte qu'elle soit égale à zéro au début et à la fin de la forme d'onde, et que la partie réelle atteigne son maximum. `A` Pour plus d'informations sur la forme d'onde DRAG, consultez l'article [Simple Pulses for Elimination of Leak in Weakly Nonlinear](https://doi.org/10.1103/PhysRevLett.103.110501) Qubits. ``` def drag_gaussian(length, sigma, beta, amplitude=1, zero_at_edges=False) ``` ***Place Erf*** ![\[Équation mathématique pour la distribution du carré d'Erf avec les paramètres t, longueur, largeur, sigma, A=1 et zAE=0.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/ErfSquareFunction.PNG) Où `L` est la longueur, `W` est la largeur de la forme d'onde, `σ` définit la vitesse à laquelle les arêtes montent et descendent`t22=(L+W)/2`, `t1​=(L−W)/2` et quelle `A` est l'amplitude. Si elle est réglée `ZaE` sur`True`, la valeur gaussienne est décalée et redimensionnée de telle sorte qu'elle soit égale à zéro au début et à la fin de la forme d'onde, et qu'elle atteigne son maximum. `A` L'équation suivante est la version redimensionnée de la forme d'onde. ![\[Équation mathématique pour la distribution du carré d'Erf redimensionnée avec les paramètres Zae=1.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/RescaledErfSquareFunction.PNG) Où `a=erf(W/2σ)` et`b=erf(-t1​/σ)/2+erf(t2​/σ)/2`. ``` def erf_square(length, width, sigma, amplitude=1, zero_at_edges=False) ``` **SupportsLocalPulseElements:** Décrit si les éléments d'impulsion, tels que les ports, les trames et les formes d'onde, peuvent être définis localement par `defcal` blocs. Si la valeur est`false`, les éléments doivent être définis par `cal` blocs. **SupportsNonNativeGatesWithPulses:** Décrit si nous pouvons ou ne pouvons pas utiliser des portes non natives en combinaison avec des programmes d'impulsions. Par exemple, vous ne pouvez pas utiliser une porte non native comme une `H` porte dans un programme sans d'abord définir la porte `defcal` pour le qubit utilisé. Vous pouvez trouver la liste des `nativeGateSet` clés de porte natives sous les fonctionnalités de l'appareil. **ValidationParameters:** Décrit les limites de validation des éléments d'impulsion, notamment : + Échelle maximale/Valeurs d'amplitude maximales pour les formes d'onde (arbitraires et prédéfinies) + Largeur de bande de fréquence maximale à partir de la fréquence centrale fournie en Hz + Pouls minimal length/duration en secondes + Pouls maximal length/duration en secondes ## Opérations, résultats et types de résultats pris en charge avec OpenQASM Pour savoir quelles fonctionnalités d'OpenQASM 3.0 sont prises en charge par chaque appareil, vous pouvez vous référer à la `braket.ir.openqasm.program` clé dans le `action` champ de sortie des capacités de l'appareil. Par exemple, les opérations prises en charge et les types de résultats disponibles pour le simulateur SV1 Braket State Vector sont les suivants. ``` ... "action": { "braket.ir.jaqcd.program": { ... }, "braket.ir.openqasm.program": { "version": [ "1.0" ], "actionType": "braket.ir.openqasm.program", "supportedOperations": [ "ccnot", "cnot", "cphaseshift", "cphaseshift00", "cphaseshift01", "cphaseshift10", "cswap", "cy", "cz", "h", "i", "iswap", "pswap", "phaseshift", "rx", "ry", "rz", "s", "si", "swap", "t", "ti", "v", "vi", "x", "xx", "xy", "y", "yy", "z", "zz" ], "supportedPragmas": [ "braket_unitary_matrix" ], "forbiddenPragmas": [], "maximumQubitArrays": 1, "maximumClassicalArrays": 1, "forbiddenArrayOperations": [ "concatenation", "negativeIndex", "range", "rangeWithStep", "slicing", "selection" ], "requiresAllQubitsMeasurement": true, "supportsPhysicalQubits": false, "requiresContiguousQubitIndices": true, "disabledQubitRewiringSupported": false, "supportedResultTypes": [ { "name": "Sample", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 1, "maxShots": 100000 }, { "name": "Expectation", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 0, "maxShots": 100000 }, { "name": "Variance", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 0, "maxShots": 100000 }, { "name": "Probability", "minShots": 1, "maxShots": 100000 }, { "name": "Amplitude", "minShots": 0, "maxShots": 0 } { "name": "AdjointGradient", "minShots": 0, "maxShots": 0 } ] } }, ... ``` # Simulez le bruit avec OpenQASM 3.0 Pour simuler le bruit avec OpenQASM3, vous utilisez les instructions *pragma* pour ajouter des opérateurs de bruit. Par exemple, pour simuler la version bruyante du [programme GHZ](braket-openqasm-create-submit-task.md#braket-openqasm-example-program) fournie précédemment, vous pouvez soumettre le programme OpenQASM suivant. ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; qubit[3] q; bit[3] c; h q[0]; #pragma braket noise depolarizing(0.75) q[0] cnot q[0], q[1]; #pragma braket noise depolarizing(0.75) q[0] #pragma braket noise depolarizing(0.75) q[1] cnot q[1], q[2]; #pragma braket noise depolarizing(0.75) q[0] #pragma braket noise depolarizing(0.75) q[1] c = measure q; ``` Les spécifications de tous les opérateurs de bruit pragma pris en charge sont fournies dans la liste suivante. ``` #pragma braket noise bit_flip() #pragma braket noise phase_flip() #pragma braket noise pauli_channel(, , ) #pragma braket noise depolarizing() #pragma braket noise two_qubit_depolarizing() , #pragma braket noise two_qubit_dephasing() , #pragma braket noise amplitude_damping() #pragma braket noise generalized_amplitude_damping( ) #pragma braket noise phase_damping() #pragma braket noise kraus([[, ], ...], [[, ], ...], ...) [, ] // maximum of 2 qubits and maximum of 4 matrices for 1 qubit, 16 for 2 ``` ## Opérateur Kraus Pour générer un opérateur Kraus, vous pouvez parcourir une liste de matrices en imprimant chaque élément de la matrice sous forme d'expression complexe. Lorsque vous utilisez les opérateurs Kraus, n'oubliez pas les points suivants : + Le nombre de ne qubits doit pas dépasser 2. La [définition actuelle dans les schémas](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/noises.py#L811-L814)) définit cette limite. + La longueur de la liste d'arguments doit être un multiple de 8. Cela signifie qu'il ne doit être composé que de matrices 2x2. + La longueur totale ne dépasse pas 2 matrices 2\$1num\$1qubits. Cela signifie 4 matrices pour 1 qubit et 16 pour 2qubits. + Toutes les matrices fournies sont [totalement conservatrices de traces positives (CPTP).](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/quantum_operator_helpers.py#L94-L108) + Le produit des opérateurs de Kraus et de leurs conjugués de transposition doit constituer une matrice d'identité. # Qubitrecâblage avec OpenQASM 3.0 [Amazon Braket prend en charge la qubit notation physique dans OpenQASM sur les Rigetti appareils (pour en savoir plus, consultez cette page).](https://github.com/openqasm/openqasm/blob/main/source/language/types.rst) Lorsque vous utilisez le physique qubits avec une [stratégie de recâblage naïve](https://pyquil-docs.rigetti.com/en/v2.28.1/compiler.html#naive), assurez-vous qu'qubitsils sont connectés sur le périphérique sélectionné. Sinon, si qubit des registres sont utilisés à la place, la stratégie de recâblage PARTIEL est activée par défaut sur Rigetti les appareils. ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; h $0; cnot $0, $1; cnot $1, $2; measure $0; measure $1; measure $2; ``` # Compilation Verbatim avec OpenQASM 3.0 Lorsque vous exécutez un circuit quantique sur des ordinateurs quantiques fournis par des fournisseurs tels queRigetti, etIonQ, vous pouvez demander au compilateur d'exécuter vos circuits exactement comme définis, sans aucune modification. Cette fonctionnalité est connue sous le nom de *compilation textuelle.* Avec les appareils Rigetti, vous pouvez spécifier précisément ce qui doit être préservé, soit un circuit entier, soit uniquement des parties spécifiques de celui-ci. Pour ne conserver que des parties spécifiques d'un circuit, vous devrez utiliser des portes natives dans les régions préservées. Actuellement, il IonQ ne prend en charge que la compilation textuelle pour l'ensemble du circuit, de sorte que chaque instruction du circuit doit être incluse dans une boîte textuelle. Avec OpenQASM, vous pouvez spécifier explicitement un pragma textuel autour d'une boîte de code qui est ensuite laissée intacte et non optimisée par la routine de compilation de bas niveau du matériel. L'exemple de code suivant montre comment utiliser la `#pragma braket verbatim` directive pour y parvenir. ``` OPENQASM 3; bit[2] c; #pragma braket verbatim box{ rx(0.314159) $0; rz(0.628318) $0, $1; cz $0, $1; } c[0] = measure $0; c[1] = measure $1; ``` Pour des informations plus détaillées sur le processus de compilation des verbatim, y compris des exemples et des meilleures pratiques, consultez le bloc-notes d'exemples de [compilation Verbatim](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb) disponible dans le référentiel github. amazon-braket-examples ## La console Braket Les tâches OpenQASM 3.0 sont disponibles et peuvent être gérées dans la console Amazon Braket. Sur la console, vous avez la même expérience en soumettant des tâches quantiques dans OpenQASM 3.0 qu'en soumettant des tâches quantiques existantes. ## Ressources supplémentaires OpenQASM est disponible dans toutes les régions Amazon Braket. [Pour un exemple de bloc-notes permettant de démarrer avec OpenQASM sur Amazon Braket, consultez les didacticiels Braket. GitHub](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Getting_Started_with_OpenQASM_on_Braket.ipynb) # Calculer des dégradés avec OpenQASM 3.0 Amazon Braket prend en charge le calcul des dégradés sur des simulateurs locaux et à la demande lors de l'exécution en mode (exact). `shots=0` Ceci est réalisé grâce à l'utilisation de la méthode de différenciation adjointe. Pour spécifier le gradient que vous souhaitez calculer, vous pouvez fournir le pragma approprié, comme illustré dans le code de l'exemple suivant. ``` OPENQASM 3.0; input float alpha; bit[2] b; qubit[2] q; h q[0]; h q[1]; rx(alpha) q[0]; rx(alpha) q[1]; b[0] = measure q[0]; b[1] = measure q[1]; #pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) alpha ``` Au lieu de répertorier explicitement tous les paramètres individuels, vous pouvez également spécifier le `all` mot-clé dans le pragma. Cela permettra de calculer le gradient par rapport à tous les `input` paramètres listés, ce qui peut être une option pratique lorsque le nombre de paramètres est très élevé. Dans ce cas, le pragma ressemblera au code de l'exemple suivant. ``` #pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) all ``` Tous les types d'observables sont pris en charge dans l'implémentation OpenQASM 3.0 d'Amazon Braket, y compris les opérateurs individuels, les produits tensoriels, les observables hermitiens et les observables. `Sum` L'opérateur spécifique que vous souhaitez utiliser lors du calcul des dégradés doit être intégré à la `expectation()` fonction, et les qubits sur lesquels agit chaque terme de l'observable doivent être explicitement spécifiés. # Mesurer des qubits spécifiques avec OpenQASM 3.0 Le simulateur vectoriel d'état local et le simulateur de matrice de densité local fournis par Amazon Braket permettent de soumettre des OpenQASM programmes dans lesquels un sous-ensemble des qubits du circuit peut être mesuré de manière sélective. Cette capacité, souvent appelée mesure partielle, permet des calculs quantiques plus ciblés et plus efficaces. Par exemple, dans l'extrait de code suivant, vous pouvez créer un circuit à deux qubits et choisir de mesurer uniquement le premier qubit, tout en laissant le second qubit non mesuré. ``` partial_measure_qasm = """ OPENQASM 3.0; bit[1] b; qubit[2] q; h q[0]; cnot q[0], q[1]; b[0] = measure q[0]; """ ``` Dans cet exemple, nous avons un circuit quantique à deux qubits`q[1]`, `q[0]` mais nous ne voulons mesurer que l'état du premier qubit. Ceci est réalisé par la ligne`b[0] = measure q[0]`, qui mesure l'état du qubit [0] et stocke le résultat dans le bit classique b [0]. Pour exécuter ce scénario de mesure partielle, nous pouvons exécuter le code suivant sur le simulateur vectoriel d'état local fourni par Amazon Braket. ``` from braket.devices import LocalSimulator local_sim = LocalSimulator() partial_measure_local_sim_task = local_sim.run(OpenQASMProgram(source=partial_measure_qasm), shots = 10) partial_measure_local_sim_result = partial_measure_local_sim_task.result() print(partial_measure_local_sim_result.measurement_counts) print("Measured qubits: ", partial_measure_local_sim_result.measured_qubits) ``` Vous pouvez vérifier si un appareil prend en charge les mesures partielles en inspectant le `requiresAllQubitsMeasurement` champ dans ses propriétés d'action ; si c'est le cas`False`, les mesures partielles sont prises en charge. ``` from braket.devices import Devices AwsDevice(Devices.Rigetti.Ankaa3).properties.action['braket.ir.openqasm.program'].requiresAllQubitsMeasurement ``` `requiresAllQubitsMeasurement`Voilà`False`, ce qui indique que tous les qubits ne doivent pas être mesurés.