Condividi tramite

Guida introduttiva: Creare il tuo primo programma Q#

Impara a scrivere un programma di base Q# che dimostra l'entanglement, un concetto chiave del quantum computing.

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 quickstart, si crea uno stato specifico a due qubit entangled denominato coppia di 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.
  • Intreccia i qubit.

Prerequisiti

Creare un file Q#

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

Scrivere il Q# codice

Nel file Main.qs segui i passaggi per intrecciare 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 Std.Diagnostics libreria. In questo modo è possibile accedere a tutte le funzioni e le operazioni della libreria, incluso DumpMachine, che in seguito si usa per visualizzare lo stato entangled.

import Std.Diagnostics.*;

Definire un'operazione

Dopo aver importato le librerie pertinenti, definire l'operazione quantistica e i relativi valori di input e output. Per questa procedura di avvio rapido, 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 ZeroOne, che rappresentano i risultati delle misurazioni del qubit:

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

Assegnare due qubit

L'operazione Main è attualmente vuota, quindi il passaggio successivo consiste nell'allocare due qubit e q1q2. In Q# alloca qubit usando la parola chiave use

        // 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 inserire uno di loro in una sovrapposizione equa, dove ha una probabilità del 50% di essere misurato 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}$.

Intrecciare i qubit

Ora sei pronto a intrecciare i qubit usando l'operazione controlled-NOT, CNOT. 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 mediante operazioni quantistiche.

Visualizzare lo stato intrecciato (entangled)

Prima di misurare i qubit, è importante verificare che il codice precedente li intrecci correttamente. Usare l'operazione DumpMachine , che fa parte della Std.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 intrecciati, è possibile usare l'operazione M per misurarli. Misurare q1 e q2 collassa i loro stati quantistici in Zero o One con una 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 intrecciato, 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

Esegui il Q# codice

Complimenti. Hai scritto un Q# programma che intreccia due qubit e crea una coppia di Bell.

Il programma finale Q# sarà simile al seguente:

import Std.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'intreccio 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 ulteriori informazioni sull'entanglement quantistico con Q#, vedere l'Esercitazione: Esplorare l'entanglement quantistico con Q#. Questo tutorial approfondisce i concetti trattati in questa guida introduttiva e consente di scrivere un programma di entanglement più avanzato.

  • Last updated on