Guida introduttiva: Creare il primo Q# programma

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 $\ket{0}$ stato, si sa che anche l'altro qubit è nello $\ket{0}$ stato senza misurarlo. Per altre informazioni, vedere Entanglement quantistico.

Questa guida introduttiva spiega come:

Prerequisiti

• La versione più recente di Visual Studio Code.
• Estensione Azure Quantum Development Kit (QDK). Per informazioni dettagliate sull'installazione, vedere Configurare Quantum Development Kit.

Creare un file Q#

1. Aprire Visual Studio Code.
2. Selezionare File>nuovo file di testo.
3. Salvare il file come Entanglement.qs. L'estensione .qs indica un Q# programma.

Scrivere il Q# codice

Entanglement.qs Nel file seguire questa procedura per entangle e misurare una coppia di qubit.

Definire uno spazio dei nomi

Ogni Q# programma inizia con uno spazio dei nomi definito dall'utente, che consente di organizzare le funzionalità correlate. Per questa guida introduttiva, lo spazio dei nomi è BellPair:

namespace BellPair {
    // Your code goes here.
}

Aprire una libreria quantistica

QDK include la Q# libreria standard con funzioni e operazioni predefinite per i programmi quantistici. Per usarle, è prima necessario aprire la libreria pertinente.

BellPair Nello spazio dei nomi usare un'istruzione open per importare 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.

    open Microsoft.Quantum.Diagnostics;

Definire un'operazione

Dopo aver aperto le librerie pertinenti, definire l'operazione quantistica e i relativi valori di input e output. Per questa guida introduttiva, l'operazione è EntangleQubits. Qui si scriverà il codice rimanente Q# per allocare, modificare e misurare due qubit.

EntangleQubits non accetta parametri e restituisce due Result valori, Zero o One, che rappresentano i risultati delle misurazioni del qubit:

    operation EntangleQubits() : (Result, Result) {
        // Your entanglement code goes here.
}

Allocare due qubit

L'operazione EntangleQubits è 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());

Inserire un qubit in sovrapposizione

I qubit q1 e q2 sono nello $\ket{0}$ stato . Per preparare i qubit per l'entanglement, è necessario inserirli in una sovrapposizione uniforme, dove ha una probabilità del 50% di essere misurata come $\ket{0}$ o $\ket{1}$.

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}),$ che è una sovrapposizione pari di $\ket{0}$ e $\ket{{1}$.

Entangle i qubit

È 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 è $\ket{1}$.

        // 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}).$

Visualizzare lo stato entangled

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();

Misurare i qubit

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));

Reimpostare i qubit

Prima di essere rilasciati alla fine di ogni Q# programma, i qubit devono trovarsi nello $\ket{0}$ stato . A tale scopo, usare l'operazione Reset :

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Restituire i risultati della misurazione

Infine, per completare l'operazione EntangleQubits e osservare lo stato entangled, restituire i risultati della misurazione di m1 e m2:

        // Return the measurement results.
        return (m1, m2);

Eseguire il Q# codice

Complimenti. È stato scritto un Q# programma che entangles due qubit e crea una coppia Bell. Prima di eseguire il programma, usare l'attributo @EntryPoint() per indicare al Q# compilatore dove avviare l'esecuzione del programma. Ogni Q# programma deve contenere un oggetto @EntryPoint(). In questo caso, posizionare @EntryPoint() prima dell'operazione EntangleQubits .

Il programma finale Q# sarà simile al seguente:

namespace BellPair {
    open Microsoft.Quantum.Diagnostics;
        
    @EntryPoint()
    operation EntangleQubits() : (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 in o premere CTRL+F5:@EntryPoint()

È 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)"

Passaggio successivo

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.