Formazione
Modulo
Creare il primo programma Q# usando Azure Quantum Development Kit - Training
Introduzione alla programmazione Q# con la creazione di un generatore quantistico di numeri casuali.
Questo browser non è più supportato.
Esegui l'aggiornamento a Microsoft Edge per sfruttare i vantaggi di funzionalità più recenti, aggiornamenti della sicurezza e supporto tecnico.
Informazioni su come scrivere un programma di base Q# che illustra l'entanglement, un concetto chiave di calcolo quantistico.
Quando due o più qubit sono entangled, condividono informazioni quantistiche, il che significa che ciò che accade a un qubit avviene anche all'altro. In questo argomento di avvio rapido si crea uno stato particolare a due qubit entangled denominato coppia Bell. In una coppia Bell, se si misura un qubit nello
Questa guida introduttiva spiega come:
Main.qs
. L'estensione .qs indica un Q# programma.Main.qs
Nel file seguire questa procedura per entangle e misurare una coppia di qubit.
QDK include la Q# libreria standard con funzioni e operazioni predefinite per i programmi quantistici. Per usarli, è prima necessario importare la libreria pertinente.
Nel programma usare un'istruzione import
per aprire la Microsoft.Quantum.Diagnostics
libreria. In questo modo è possibile accedere a tutte le relative funzioni e operazioni, incluso DumpMachine()
, che in seguito si usa per visualizzare lo stato entangled.
import Microsoft.Quantum.Diagnostics.*;
Dopo aver importato le librerie pertinenti, definire l'operazione quantistica e i relativi valori di input e output. Per questa guida introduttiva, l'operazione è Main
. Qui si scriverà il codice rimanente Q# per allocare, modificare e misurare due qubit.
Main
non accetta parametri e restituisce due Result
valori, o Zero
One
, che rappresentano i risultati delle misurazioni del qubit:
operation Main() : (Result, Result) {
// Your entanglement code goes here.
}
L'operazione Main
è attualmente vuota, quindi il passaggio successivo consiste nell'allocare due qubit e q1
q2
. In Q#allocare qubit usando la use
parola chiave :
// Allocate two qubits, q1 and q2, in the 0 state.
use (q1, q2) = (Qubit(), Qubit());
Nota
In Q#i qubit vengono sempre allocati nello
I qubit q1
e q2
sono nello
Si inserisce un qubit in sovrapposizione applicando l'operazione Hadamard, H
, :
// Put q1 into an even superposition.
H(q1);
Lo stato risultante di q1
è $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),
È ora possibile creare un'entangle dei qubit usando l'operazione NOT, CNOT
, controllata. CNOT
è un'operazione di controllo che accetta due qubit, una che funge da controllo e l'altra come destinazione.
Per questa guida introduttiva, impostare q1
come qubit di controllo e q2
come qubit di destinazione. Ciò significa CNOT
che capovolge lo stato di q2
quando lo stato di q1
è
// Entangle q1 and q2, making q2 depend on q1.
CNOT(q1, q2);
Lo stato risultante di entrambi i qubit è la coppia $\frac{{1}{\sqrt{2}}Bell (\ket{00}+\ket{{11}).$
Suggerimento
Per informazioni su come le operazioni Hadamard e CNOT trasformano lo stato dei qubit, vedere Creazione di entanglement con operazioni quantistiche.
Prima di misurare i qubit, è importante verificare che il codice precedente li entangles correttamente. È possibile usare l'operazione DumpMachine
, che fa parte della Microsoft.Quantum.Diagnostics
libreria, per restituire lo stato corrente del Q# programma:
// Show the entangled state of the qubits.
DumpMachine();
Dopo aver verificato che i qubit sono entangled, è possibile usare l'operazione M
per misurarli. Misurare q1
e q2
comprimere i propri stati quantistici in Zero
o One
con probabilità pari.
In Q#usare la let
parola chiave per dichiarare una nuova variabile. Per archiviare i risultati della misurazione di q1
e q2
, dichiarare rispettivamente le variabili m1
e m2
:
// Measure q1 and q2 and store the results in m1 and m2.
let (m1, m2) = (M(q1), M(q2));
Prima di essere rilasciati alla fine di ogni Q# programma, i qubit devono trovarsi nello Reset
:
// Reset q1 and q2 to the 0 state.
Reset(q1);
Reset(q2);
Infine, per completare l'operazione Main
e osservare lo stato entangled, restituire i risultati della misurazione di m1
e m2
:
// Return the measurement results.
return (m1, m2);
Suggerimento
Per altre informazioni su una Q# funzione o un'operazione, passare il puntatore del mouse su di esso.
Complimenti. È stato scritto un Q# programma che entangles due qubit e crea una coppia Bell.
Il programma finale Q# sarà simile al seguente:
import Microsoft.Quantum.Diagnostics.*;
operation Main() : (Result, Result) {
// Allocate two qubits, q1 and q2, in the 0 state.
use (q1, q2) = (Qubit(), Qubit());
// Put q1 into an even superposition.
// It now has a 50% chance of being measured as 0 or 1.
H(q1);
// Entangle q1 and q2, making q2 depend on q1.
CNOT(q1, q2);
// Show the entangled state of the qubits.
DumpMachine();
// Measure q1 and q2 and store the results in m1 and m2.
let (m1, m2) = (M(q1), M(q2));
// Reset q1 and q2 to the 0 state.
Reset(q1);
Reset(q2);
// Return the measurement results.
return (m1, m2);
}
Per eseguire il programma e visualizzare il risultato di entrambi i qubit, selezionare Esegui sopra l'operazione Main
o premere CTRL+F5
È possibile eseguire il programma più volte, ognuno con un risultato diverso nella console di debug. Ciò dimostra la natura probabilistica delle misurazioni quantistiche e l'entanglement dei qubit.
Ad esempio, se il risultato è Zero
, la console di debug dovrebbe essere simile alla seguente:
DumpMachine:
Basis | Amplitude | Probability | Phase
-----------------------------------------------
|00⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000
|11⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000
Result: "(Zero, Zero)"
Per altre informazioni sull'entanglement quantistico con Q#, vedere Esercitazione: Esplorare l'entanglement quantistico con Q#. Questa esercitazione si espande sui concetti trattati in questa guida introduttiva e consente di scrivere un programma di entanglement più avanzato.
Formazione
Modulo
Creare il primo programma Q# usando Azure Quantum Development Kit - Training
Introduzione alla programmazione Q# con la creazione di un generatore quantistico di numeri casuali.