Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Quali funzionalità di OpenQASM supporta Braket?
La sezione seguente elenca i tipi di dati, le istruzioni e le istruzioni pragma di OpenQASM 3.0 supportate da Braket.
**Topics**
+ [Tipi di dati OpenQASM supportati](#braket-openqasm-supported-features-datatypes)
+ [Istruzioni OpenQASM supportate](#braket-openqasm-supported-features-statements)
+ [Pragmi Braket OpenQASM](#braket-openqasm-supported-features-pragmas)
+ [Supporto di funzionalità avanzate per OpenQASM su Local Simulator](#braket-openqasm-supported-features-advanced-feature-local-simulator)
+ [Operazioni e grammatica supportate con OpenPulse](#braket-openpulse-supported-operations-grammar)
## Tipi di dati OpenQASM supportati
I seguenti tipi di dati OpenQASM sono supportati da Amazon Braket.
+ I numeri interi non negativi vengono utilizzati per gli indici di qubit (virtuali e fisici):
+ `cnot q[0], q[1];`
+ `h $0;`
+ È possibile utilizzare numeri o costanti a virgola mobile per gli angoli di rotazione del cancello:
+ `rx(-0.314) $0;`
+ `rx(pi/4) $0;`
**Nota**
pi è una costante incorporata in OpenQASM e non può essere utilizzata come nome di parametro.
+ Le matrici di numeri complessi (con la `im` notazione OpenQASM per la parte immaginaria) sono consentite nei pragmi di tipo di risultato per la definizione di osservabili hermitiane generali e nei pragmi unitari:
+ `#pragma braket unitary [[0, -1im], [1im, 0]] q[0]`
+ `#pragma braket result expectation hermitian([[0, -1im], [1im, 0]]) q[0]`
## Istruzioni OpenQASM supportate
Le seguenti istruzioni OpenQASM sono supportate da Amazon Braket.
+ `Header: OPENQASM 3;`
+ Dichiarazioni di bit classiche:
+ `bit b1;`(equivalentemente,) `creg b1;`
+ `bit[10] b2;`(equivalentemente,) `creg b2[10];`
+ Dichiarazioni Qubit:
+ `qubit b1;`(equivalentemente,) `qreg b1;`
+ `qubit[10] b2;`(equivalentemente,) `qreg b2[10];`
+ Indicizzazione all'interno di array: `q[0]`
+ Ingresso: `input float alpha;`
+ specificazione fisicaqubits: `$0`
+ Porte e operazioni supportate su un dispositivo:
+ `h $0;`
+ `iswap q[0], q[1];`
**Nota**
Le porte supportate da un dispositivo sono disponibili nelle proprietà del dispositivo per le azioni OpenQASM; non sono necessarie definizioni di gate per utilizzare queste porte.
+ Dichiarazioni letterali. Al momento, non supportiamo la notazione della durata delle caselle. Le porte native e fisiche qubits sono obbligatorie nelle caselle letterali.
```
#pragma braket verbatim
box{
rx(0.314) $0;
}
```
+ Misurazione e assegnazione delle misurazioni su qubits o su un intero registro. qubit
+ `measure $0;`
+ `measure q;`
+ `measure q[0];`
+ `b = measure q;`
+ `measure q → b;`
+ Le istruzioni Barrier forniscono un controllo esplicito sulla compilazione e l'esecuzione dei circuiti impedendo il riordino e l'ottimizzazione dei gate attraverso i confini delle barriere. Impongono inoltre un rigoroso ordinamento temporale durante l'esecuzione, garantendo che tutte le operazioni prima che una barriera sia completata prima dell'inizio delle operazioni successive.
+ `barrier;`
+ `barrier q[0], q[1];`
+ `barrier $3, $6;`
## Pragmi Braket OpenQASM
Le seguenti istruzioni relative al pragma OpenQASM sono supportate da Amazon Braket.
+ Pragmi del rumore
+ `#pragma braket noise bit_flip(0.2) q[0]`
+ `#pragma braket noise phase_flip(0.1) q[0]`
+ `#pragma braket noise pauli_channel`
+ Pragmi letterali
+ `#pragma braket verbatim`
+ Tipo di risultato: pragmi
+ Tipi di risultati invarianti di base:
+ Vettore di stato: `#pragma braket result state_vector`
+ Matrice di densità: `#pragma braket result density_matrix`
+ Pragmi di calcolo del gradiente:
+ Gradiente aggiunto: `#pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all`
+ Tipi di risultati di base Z:
+ Ampiezza: `#pragma braket result amplitude "01"`
+ Probabilità: `#pragma braket result probability q[0], q[1]`
+ Tipi di risultati ruotati di base
+ Aspettativa: `#pragma braket result expectation x(q[0]) @ y([q1])`
+ Varianza: `#pragma braket result variance hermitian([[0, -1im], [1im, 0]]) $0`
+ Esempio: `#pragma braket result sample h($1)`
**Nota**
OpenQASM 3.0 è retrocompatibile con OpenQASM 2.0, quindi i programmi scritti utilizzando 2.0 possono essere eseguiti su Braket. Tuttavia, le funzionalità di OpenQASM 3.0 supportate da Braket presentano alcune differenze di sintassi minori, come vs e vs. `qreg` `creg` `qubit` `bit` Esistono anche differenze nella sintassi di misurazione, che devono essere supportate con la sintassi corretta.
## Supporto di funzionalità avanzate per OpenQASM su Local Simulator
`LocalSimulator`Supporta funzionalità avanzate di OpenQASM che non sono offerte come parte delle QPU o dei simulatori on-demand di Braket. Il seguente elenco di funzionalità è supportato solo in: `LocalSimulator`
+ Modificatori di gate
+ Porte integrate in OpenQASM
+ Variabili classiche
+ Operazioni classiche
+ Cancelli personalizzati
+ Controllo classico
+ File QASM
+ Sottoroutine
Per esempi di ogni funzionalità avanzata, consultate questo taccuino di [esempio](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb). Per le specifiche complete di OpenQASM, consulta il sito Web di [OpenQASM](https://openqasm.com/language/index.html).
## Operazioni e grammatica supportate con OpenPulse
**Tipi di OpenPulse dati supportati**
Blocchi Cal:
```
cal {
...
}
```
Blocchi 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 {
...
}
```
Cornici:
```
frame my_frame = newframe(port_0, 4.5e9, 0.0);
```
Forme d'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};
```
**Esempio di calibrazione Custom Gate:**
```
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;
```
**Esempio di impulso 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);
}
```