Guida introduttiva: Creare il primo Q# programma

Articolo
10/29/2024

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:

Creare un file Q#.
Allocare una coppia di qubit.
Entangle i qubit.

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#

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

Scrivere il Q# codice

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

Importare una libreria quantistica

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.*;

Definire un'operazione

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.
}

Allocare due qubit

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 $\ket{0}$ stato .

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

Suggerimento

Per informazioni su come le operazioni Hadamard e CNOT trasformano lo stato dei qubit, vedere Creazione di entanglement con operazioni quantistiche.

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 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.

Screenshot dei dettagli visualizzati quando si passa il mouse sull'operazione

Eseguire il Q# codice

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

Screenshot del Q# file in Visual Studio Code che mostra dove trovare il comando

È 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.

Condividi tramite