Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Welche OpenQASM-Funktionen unterstützt Braket?
Der folgende Abschnitt listet die OpenQASM 3.0-Datentypen, Anweisungen und Pragma-Anweisungen auf, die von Braket unterstützt werden.
**Topics**
+ [Unterstützte OpenQASM-Datentypen](#braket-openqasm-supported-features-datatypes)
+ [Unterstützte OpenQASM-Anweisungen](#braket-openqasm-supported-features-statements)
+ [Braket OpenQASM Pragmas](#braket-openqasm-supported-features-pragmas)
+ [Erweiterte Funktionsunterstützung für OpenQASM auf dem Local Simulator](#braket-openqasm-supported-features-advanced-feature-local-simulator)
+ [Unterstützte Operationen und Grammatik mit OpenPulse](#braket-openpulse-supported-operations-grammar)
## Unterstützte OpenQASM-Datentypen
Die folgenden OpenQASM-Datentypen werden von Amazon Braket unterstützt.
+ Nichtnegative Ganzzahlen werden für (virtuelle und physische) Qubit-Indizes verwendet:
+ `cnot q[0], q[1];`
+ `h $0;`
+ Fließkommazahlen oder Konstanten können für Gate-Drehwinkel verwendet werden:
+ `rx(-0.314) $0;`
+ `rx(pi/4) $0;`
**Anmerkung**
pi ist eine eingebaute Konstante in OpenQASM und kann nicht als Parametername verwendet werden.
+ Arrays komplexer Zahlen (mit der `im` OpenQASM-Notation für den Imaginärteil) sind in Ergebnistyp-Pragmas zur Definition allgemeiner hermitescher Observablen und in unitären Pragmas zulässig:
+ `#pragma braket unitary [[0, -1im], [1im, 0]] q[0]`
+ `#pragma braket result expectation hermitian([[0, -1im], [1im, 0]]) q[0]`
## Unterstützte OpenQASM-Anweisungen
Die folgenden OpenQASM-Anweisungen werden von Amazon Braket unterstützt.
+ `Header: OPENQASM 3;`
+ Klassische Bit-Deklarationen:
+ `bit b1;`(äquivalent,) `creg b1;`
+ `bit[10] b2;`(gleichwertig,) `creg b2[10];`
+ Qubit-Deklarationen:
+ `qubit b1;`(äquivalent,) `qreg b1;`
+ `qubit[10] b2;`(gleichwertig,) `qreg b2[10];`
+ Indizierung innerhalb von Arrays: `q[0]`
+ Eingabe: `input float alpha;`
+ physikalische Spezifikationqubits: `$0`
+ Unterstützte Tore und Operationen auf einem Gerät:
+ `h $0;`
+ `iswap q[0], q[1];`
**Anmerkung**
Die unterstützten Gates eines Geräts finden Sie in den Geräteeigenschaften für OpenQASM-Aktionen. Für die Verwendung dieser Gates sind keine Gate-Definitionen erforderlich.
+ Wörtliche Angaben in der Box. Derzeit unterstützen wir die Notation mit der Dauer von Boxen nicht. Bei wörtlichen Boxen qubits sind systemeigene Gates und physische Elemente erforderlich.
```
#pragma braket verbatim
box{
rx(0.314) $0;
}
```
+ Messung und Messzuweisung in einem qubits oder einem ganzen qubit Register.
+ `measure $0;`
+ `measure q;`
+ `measure q[0];`
+ `b = measure q;`
+ `measure q → b;`
+ Barrierenanweisungen ermöglichen eine explizite Kontrolle über die Zusammenstellung und Ausführung von Schaltungen, indem sie eine Neuanordnung von Gates und Optimierungen über Barrierengrenzen hinweg verhindern. Sie setzen auch eine strikte zeitliche Reihenfolge bei der Ausführung durch und stellen sicher, dass alle Operationen vor einer Barriere abgeschlossen sind, bevor nachfolgende Operationen beginnen.
+ `barrier;`
+ `barrier q[0], q[1];`
+ `barrier $3, $6;`
## Braket OpenQASM Pragmas
Die folgenden OpenQASM-Pragma-Anweisungen werden von Amazon Braket unterstützt.
+ Noise-Pragmas
+ `#pragma braket noise bit_flip(0.2) q[0]`
+ `#pragma braket noise phase_flip(0.1) q[0]`
+ `#pragma braket noise pauli_channel`
+ Wörtliche Pragmas
+ `#pragma braket verbatim`
+ Pragmas vom Typ Ergebnis
+ Basisinvariante Ergebnistypen:
+ Zustandsvektor: `#pragma braket result state_vector`
+ Dichtematrix: `#pragma braket result density_matrix`
+ Pragmas zur Gradientenberechnung:
+ Adjungierter Gradient: `#pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all`
+ Z-Basis-Ergebnistypen:
+ Amplitude: `#pragma braket result amplitude "01"`
+ Wahrscheinlichkeit: `#pragma braket result probability q[0], q[1]`
+ Auf Basis rotierte Ergebnistypen
+ Erwartung: `#pragma braket result expectation x(q[0]) @ y([q1])`
+ Varianz: `#pragma braket result variance hermitian([[0, -1im], [1im, 0]]) $0`
+ Stichprobe: `#pragma braket result sample h($1)`
**Anmerkung**
OpenQASM 3.0 ist abwärtskompatibel mit OpenQASM 2.0, sodass Programme, die mit 2.0 geschrieben wurden, auf Braket laufen können. Die von Braket unterstützten Funktionen von OpenQASM 3.0 weisen jedoch einige geringfügige Syntaxunterschiede auf, wie zum Beispiel vs und vs `qreg` `creg` `qubit` `bit` Es gibt auch Unterschiede in der Messsyntax, und diese müssen mit ihrer korrekten Syntax unterstützt werden.
## Erweiterte Funktionsunterstützung für OpenQASM auf dem Local Simulator
Das `LocalSimulator` unterstützt erweiterte OpenQASM-Funktionen, die nicht als Teil der QPUs oder On-Demand-Simulatoren von Braket angeboten werden. Die folgende Liste von Funktionen wird nur in folgenden Versionen unterstützt: `LocalSimulator`
+ Gate-Modifikatoren
+ Integrierte OpenQASM-Gates
+ Klassische Variablen
+ Klassische Operationen
+ Benutzerdefinierte Tore
+ Klassische Steuerung
+ QASM-Dateien
+ Subroutinen
Beispiele für jede erweiterte Funktion finden Sie in diesem [Beispielnotizbuch](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb). Die vollständige OpenQASM-Spezifikation finden Sie auf der [OpenQASM-Website](https://openqasm.com/language/index.html).
## Unterstützte Operationen und Grammatik mit OpenPulse
**Unterstützte OpenPulse Datentypen**
Blöcke aufrufen:
```
cal {
...
}
```
Aufkleberblöcke:
```
// 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 {
...
}
```
Rahmen:
```
frame my_frame = newframe(port_0, 4.5e9, 0.0);
```
Wellenformen:
```
// 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};
```
**Beispiel für eine benutzerdefinierte Gate-Kalibrierung:**
```
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;
```
**Beispiel für einen beliebigen Impuls:**
```
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);
}
```