Esercizio: Creare l'entanglement quantistico con Q#

  • 7 minuti

Nell'unità precedente si è appreso il concetto di entanglement quantistico e stati Bell.

Si creerà ora l'entanglement quantistico usando Q# e Azure Quantum Development Kit. Per creare l'entanglement, è necessario applicare due operazioni quantistiche: il gate Hadamard e il gate Controlled-NOT (CNOT).

Operazione CNOT (Controlled-NOT)

Quando due qubit sono sottoposti a entanglement, lo stato di un qubit dipende dallo stato dell'altro qubit. Di conseguenza per ottenere l'entanglement di due qubit è necessaria un'operazione che agisce contemporaneamente su entrambi i qubit. Questa operazione viene chiamata operazione su più qubit.

Per creare l'entanglement quantistico, è necessaria l'operazione di CNOT su più qubit, che è l'acronimo di Controlled-NOT. Questa operazione accetta due qubit come input: uno funge da qubit di controllo e l'altro è il qubit target. L'operazione CNOT inverte lo stato del secondo qubit (qubit target) se e solo se lo stato del primo qubit (qubit di controllo) è $|1\rangle$.

Input Output
$\ket{00}$ $\ket{00}$
$\ket{01}$ $\ket{01}$
$\ket{10}$ $\ket{11}$
$\ket{11}$ $\ket{10}$

In Q# l'operazione CNOT agisce su una matrice di due qubit e inverte il secondo qubit se il primo qubit è One.

Entanglement con un'operazione CNOT

Applicando l'operazione Hadamard, H, e l'operazione Controlled-NOT, CNOT, è possibile trasformare due qubit nello stato $|00\rangle$ allo stato Bell $\ket{\phi^+}=\frac1{\sqrt2}(|00\rangle+|11\rangle)$.

Ecco come funziona:

  1. Prendere due qubit con stato $|00\rangle$. Il primo qubit è il qubit di controllo e il secondo qubit è il qubit target.

  2. Creare uno stato di sovrapposizione solo nel qubit di controllo applicando $H$.

    $$H |0_c\rangle=\frac{1}{\sqrt{{2}}(|0_c\rangle+|1_c\rangle)$$

    Suggerimento

    I pedici ${}_c$ e ${}_t$ specificano i qbit di controllo e il qubit target.

  3. Applicare l'operatore $CNOT$ al qubit di controllo, che si trova in uno stato di sovrapposizione, e al qubit target, che si trova nello stato $|0_t\rangle$.

    $$ CNOT \frac{1}{\sqrt{2}}(\ket{0_c}+\ket{1_c})\ket{0}_t = CNOT \frac{1}{\sqrt2}(\ket{0_c 0_t}+|\ket{1_c 0_t})=$$$$=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} + CNOT \ket{1_c 0_t})=$$$$=\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$$

Creare un nuovo file Q#

  1. Aprire Visual Studio Code.
  2. Selezionare File > Nuovo file di testo e salvarlo come Main.qs.
  3. Selezionare Visualizza -> Riquadro comandi e digitare Q#: Impostare il profilo target QIR di Azure Quantum. Premere INVIO.
  4. Selezionare Q#: Senza restrizioni.

Creare lo stato di Bell $\ket{\phi^+}$

Per iniziare, creare lo stato di Bell $\ket{\phi^+}=\frac1{\sqrt2}(|00\rangle+|11\rangle)$.

  1. Prima di tutto, è necessario importare lo spazio dei nomi Microsoft.Quantum.Diagnostics dalla libreria Standard, che contiene la funzione DumpMachine. Questa funzione mostra lo stato corrente dei qubit. Copiare e incollare il codice Q# seguente nel file Main.qs.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

    Suggerimento

    È anche possibile importare la libreria Standard sostituendo Microsoft.Quantum con Std. Ad esempio, import Std.Diagnostics.* equivale a import Microsoft.Quantum.Diagnostics.*.

  2. Creare l'operazione Main che restituisce due valori di tipo Result, ovvero i risultati della misurazione dei qubit.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

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

  3. All'interno dell'operazione Main si allocano due qubit, q1 e q2, che verranno entangled.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
}

  4. Applicare il gate Hadamard, H, al primo qubit, q1, per inserirlo in uno stato di sovrapposizione. Quindi, entangle i due qubit usando l'operazione CNOT.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
}

  5. Usare la funzione DumpMachine per visualizzare lo stato corrente dei qubit. Questo non equivale a misurare i qubit.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();
}

  6. Misurare i qubit usando l'operazione M e archiviare i risultati in m1 e m2. Usare quindi l'operazione Reset per reimpostare i qubit. In Q# è necessario reimpostare sempre i qubit sullo stato $|0\rangle$.

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {

    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);
    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

}

  7. Infine, restituire i risultati della misurazione dei qubit con l'istruzione return. Il file Main.qs dovrebbe essere simile al seguente:

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    CNOT(q1, q2);

    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

  8. Per eseguire il programma nel simulatore predefinito, fare clic su Esegui sopra l'operazione Main o premere CTRL+F5. L'output verrà visualizzato nella console di debug.

  9. I risultati della misurazione sono correlati, quindi alla fine del programma si ottiene un risultato di (Zero, Zero) o (One, One) con la stessa probabilità.

  10. È possibile visualizzare il diagramma del circuito facendo clic su Circuito dall'elenco dei comandi sopra l'operazione di Main. Il diagramma del circuito mostra il gate Hadamard applicato al primo qubit e il gate CNOT applicato a entrambi i qubit.

    Screenshot del circuito dello stato di Bell.

Creare altri stati Bell

Per creare altri stati di Bell, è necessario applicare altre operazioni Pauli $X$ e $Z$ ai qubit.

Ad esempio, per creare lo stato di Bell $\ket{\phi^-}=\frac1{\sqrt2}(|00\rangle-|11\rangle)$, è possibile applicare l'operazione Pauli $Z$ al qubit di controllo dopo aver applicato il gate Hadamard. L'operazione $Z$ inverte lo stato $\ket{+}$ in $\ket{-}$.

Suggerimento

Gli stati $\frac{{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ e $\frac{1}{\sqrt{{2}}(|0\rangle -|1\rangle)$ sono noti anche come $\ket{+}$ e $\ket{{-}$, rispettivamente.

Ecco come funziona:

  1. Prendere due qubit con stato $|00\rangle$.

  2. Creare uno stato di sovrapposizione solo nel qubit di controllo applicando $H$.

    $$H |0_c\rangle=\frac{{1}{\sqrt{2}}(|0_c\rangle+|1_c\rangle) =\ket{+}_c$$

  3. Applicare l'operazione $Z$ al qubit di controllo.

    $$Z \frac{{1}{\sqrt{{2}}(|0_c\rangle+|1_c\rangle)=\frac{1}{\sqrt{{2}}(|0_c\rangle-|1_c\rangle)=\ket{{-}_c$$

  4. Applicare l'operatore $CNOT$ al qubit di controllo e al qubit target, che si trova nello stato $|0_t\rangle$.

    $$ CNOT \frac{1}{\sqrt{2}}(\ket{0_c}-\ket{1_c})\ket{0}_t = CNOT \frac{1}{\sqrt2}(\ket{0_c 0_t}-|\ket{1_c 0_t})=$$$$=\frac{{1}{\sqrt2}(CNOT \ket{0_c 0_t} - CNOT \ket{1_c 0_t})=$$$$=\frac{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 1_t})$$

Analogamente, gli stati di Bell $\ket{\psi^+}$ e $\ket{\psi^-}$ possono essere creati applicando le operazioni Pauli $X$ e $Z$ ai qubit.

  • Lo stato di Bell $\ket{\psi^+}=\frac1{\sqrt2}(|01\rangle+|10\rangle)$ può essere creato applicando l'operazione Pauli $X$ al qubit target dopo aver applicato il gate Hadamard.
  • Lo stato di Bell $\ket{\psi^-}=\frac1{\sqrt2}(|01\rangle-|10\rangle)$ può essere creato applicando l'operazione Pauli $Z$ al qubit di controllo e l'operazione Pauli $X$ al qubit target dopo aver applicato il gate Hadamard.

Creare lo stato Bell $\ket{\phi^-}$ in Q#

  1. Modificare il codice Q# per creare lo stato di Bell $\ket{\phi^-}$. Il file Main.qs dovrebbe essere simile al seguente:

    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());

    H(q1);
    Z(q1); // Apply the Pauli Z operation to the control qubit
    CNOT(q1, q2);

    DumpMachine();

    let (m1, m2) = (M(q1), M(q2));
    Reset(q1);
    Reset(q2);

    return (m1, m2);
}

  2. Per eseguire il programma nel simulatore predefinito, fare clic su Esegui sopra l'operazione Main o premere CTRL+F5. L'output verrà visualizzato nella console di debug.

  3. È possibile visualizzare il diagramma del circuito facendo clic su Circuito dall'elenco dei comandi sopra l'operazione di Main. Il diagramma del circuito mostra il gate Hadamard applicato al primo qubit, il gate Pauli $Z$ applicato al primo qubit e il gate CNOT applicato a entrambi i qubit.

Nell'unità successiva si apprenderà come usare l'entanglement per il teletrasporto delle informazioni quantistico.