Oefening: kwantumverstrengeling maken met Q#

  • 7 minuten

In de vorige les hebt u geleerd over het concept van kwantumverstrengeling en bellstatussen.

In deze eenheid gebruikt u Azure Quantum Development Kit (QDK) voor het schrijven van code Q# waarmee verstrengelde Bell-toestanden tussen twee qubits worden gecreëerd. Als u uw eerste Bell-toestand wilt creëren, past u twee kwantumbewerkingen toe: de Hadamard-bewerking en de Controlled-NOT (CNOT)-bewerking.

Laten we eerst begrijpen hoe deze bewerkingen werken en waarom ze verstrengelde toestanden creëren.

De Hadamard-bewerking

Zoals u weet, plaatst de Hadamard- of H-bewerking een qubit die zich in een pure $\ket{0}$ toestand of $\ket{1}$ toestand in een gelijke superpositiestatus bevindt.

$$ H \ket{0} = \frac1{\sqrt2} \ket{0} + \frac1{\sqrt2} \ket{1}$$ $$ H \ket{1} = \frac1{\sqrt2} \ket{0} - \frac1{\sqrt2} \ket{1}$$

De eerste stap om je Bell-toestand te creëren is het uitvoeren van een Hadamard-bewerking op een van de qubits.

De bewerking Controlled-NOT (CNOT)

Wanneer twee qubits zijn verstrengeld, is de status van één qubit afhankelijk van de toestand van de andere qubit. Om twee qubits te verstrengelen, moet u daarom een bewerking met meerdere qubits toepassen. Dit is een bewerking die op beide qubits tegelijk werkt. De Controlled-NOT- of CNOT-bewerking is een multi-qubit bewerking die helpt bij het creëren van verstrengeling.

De CNOT-bewerking gebruikt twee qubits als invoer. Een van de qubits is de controle-qubit en de andere qubit is de target qubit. Als de controle qubit in de $\ket{1}$ toestand is, dan keert de CNOT-bewerking de toestand van de target qubit om. Anders doet CNOT niets.

In de volgende twee qubitstatussen is de controle-qubit bijvoorbeeld de meest linkse qubit en is de target qubit de meest rechtse qubit.

Invoer voor CNOT Uitvoer van CNOT
$\ket{00}$ $\ket{00}$
$\ket{01}$ $\ket{01}$
$\ket{10}$ $\ket{11}$
$\ket{11}$ $\ket{10}$

In Q#, de CNOT-bewerking werkt op een array van twee qubits, en het draait de tweede qubit alleen om als de eerste qubit One is.

Verstrengeling met Hadamard- en CNOT-bewerkingen

Stel dat u een systeem met twee qubits in de status $\ket{00}$hebt. In deze status zijn de qubits niet verstrengeld. Als u deze qubits in de verstrengelde klokstatus $\ket{\phi^+}=\frac1{\sqrt2}(\ket{00}+\ket{11})$wilt plaatsen, past u de Hadamard- en CNOT-bewerkingen toe.

Dit werkt als volgt:

  1. Kies één qubit in de c-status om de controle-qubit te zijn en de andere qubit als de target qubit. Hier kiezen we de meest linkse qubit om het besturingselement en de meest rechtse qubit te zijn target.

  2. Plaats alleen de controle-qubit in een gelijke superpositiestatus. Hiervoor past u een H-bewerking alleen toe op de controle-qubit:

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

    Opmerking

    De subscripts ${}_c$ en ${}_t$ geven respectievelijk het besturingselement en target de qubits op.

  3. Pas een CNOT-bewerking toe op het qubitpaar. Zoals u weet, heeft de controle-qubit een superpositiestatus en heeft de target qubit de $\ket{0_t}$ status.

    $$ \begin{uitgelijnde} CNOT \frac{{1}{\sqrt{{2}}(\ket{0_c}+\ket{1_c)}0_t\ket{}& amp;= 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}) \end{uitgelijnd}$$

De status $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ is verstrengeld. Deze specifieke verstrengelde toestand is een van de vier Bell-toestanden, $\ket{\phi^{+}}$.

Opmerking

In kwantumcomputing worden bewerkingen vaak poorten genoemd. Bijvoorbeeld de H-poort en de CNOT-poort.

Kwantumverstrengeling maken in Q#

Volg deze stappen in Visual Studio Code (VS Code) om een Bell-status met Q# code te maken:

  1. Open VS Code.
  2. Open het menu Bestand en kies vervolgens Nieuw tekstbestand om een nieuw bestand te maken.
  3. Sla het bestand op als Main.qs.

Een Bell-toestand creëren

Voer de volgende stappen uit om de Bell-toestand $\ket{\phi^+}$ in Q# te maken:

  1. Importeer de Std.Diagnostics naamruimte uit de Q# standaardbibliotheek, zodat u de DumpMachine functie kunt gebruiken. Deze functie bevat informatie over de qubitstatussen wanneer u de functie aanroept in uw code. Als u de naamruimte wilt importeren, kopieert u de volgende Q# code naar uw Main.qs-bestand :

    import Std.Diagnostics.*;

  2. Maak de Main bewerking die twee Result typewaarden retourneert. Dit zijn de meetresultaten van de qubits.

    import Std.Diagnostics.*;

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

  3. Wijs binnen de Main operatie twee qubits toe, q1 en q2, die verstrengeld moeten worden.

    import Std.Diagnostics.*;

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

  4. Pas de Hadamard-poort toe op Hde controle-qubit.q1 Hierdoor wordt alleen die qubit in een superpositiestatus geplaatst. Pas vervolgens de CNOT-poort toe op CNOTbeide qubits om de twee qubits te verstrengelen. Het eerste argument voor CNOT is de controlequbit en het tweede argument is de target qubit.

    import Std.Diagnostics.*; 

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

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

  5. Gebruik de DumpMachine functie om de status van de qubits weer te geven nadat u ze hebt verstrengeld. Houd er rekening mee dat DumpMachine er geen meting wordt uitgevoerd op de qubits, dus DumpMachine dit heeft geen invloed op de qubitstatussen.

    import Std.Diagnostics.*;

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

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

    DumpMachine();
}

  6. Gebruik de M bewerking om de qubits te meten en de resultaten op te slaan in m1 en m2. Gebruik vervolgens de Reset bewerking om de qubits opnieuw in te stellen.

    import 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. Retourneert de meetresultaten van de qubits met de return instructie. Dit is het laatste programma in uw Main.qs-bestand :

    import 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. Als u uw programma op de ingebouwde simulator wilt uitvoeren, kiest u de codelens Uitvoeren boven de Main bewerking of drukt u op Ctrl + F5. De uitvoer verschijnt in de debugconsole.

  9. De meetresultaten worden gecorreleerd, dus aan het einde van het programma krijgt u een resultaat van (Zero, Zero) of (One, One) met gelijke waarschijnlijkheid. Voer het programma meerdere keren opnieuw uit en bekijk de uitvoer om uzelf te overtuigen van de correlatie.

  10. Als u het circuitdiagram wilt visualiseren, kiest u de circuitlens boven de Main bewerking. In het circuitdiagram ziet u dat de Hadamard-poort is toegepast op de eerste qubit en de CNOT-poort die op beide qubits is toegepast.

    Schermopname van het circuit dat de Bell-toestand creëert.

Andere Bell-toestanden creëren

Als u andere bellstatussen wilt maken, past u extra Pauli $X$ of $Z$ bewerkingen toe op de qubits.

Als u bijvoorbeeld de klokstatus $\ket{\phi^-}=\frac1{\sqrt2}(\ket{00}-\ket{11})$wilt maken, past u de Pauli $Z-bewerking$ toe op de controle-qubit nadat u de Hadamard-poort hebt toegepast, maar voordat u CNOT toepast. Met $Z$ de bewerking wordt de status $\ket{+}$ omgedraaid naar $\ket{-}$.

Opmerking

De staten $\frac{1}{\sqrt{2}}(\ket{0}+\ket{1})$ en $\frac{1}{\sqrt{2}}(\ket{0} - \ket{1})$ worden ook wel bekend als $\ket{+}$ en $\ket{-}$, respectievelijk.

U maakt als volgt de $\ket{\phi^-}$ status:

  1. Maak twee qubits in de toestand $\ket{00}$.

  2. Plaats de controle-qubit in een superpositiestatus met de $H$ bewerking:

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

  3. Pas de $Z$ bewerking toe op de controle-qubit.

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

  4. Pas de CNOT-bewerking toe op de controle-qubit en de target qubit, die zich in de $\ket{0_t}$ status bevindt.

    $$ \begin{uitgelijnd} CNOT\frac{{1}{\sqrt{{2}} (\ket{0_c-1_c}\ket{})\ket{0_t}&= CNOT \frac{{1}{\sqrt2}(\ket{0_c 0_t-1_c 0_t}\ket{})\\&=\frac{{1}{\sqrt2}(CNOT 0_c 0_t\ket{ - CNOT }1_c 0_t\ket{)}\\&=\frac{{1}{\sqrt2}(\ket{0_c 0_t-1_c 1_t}\ket{}) \end{uitgelijnd}$$

Als u de $\ket{\phi^-}$ Bell-toestand in Q# wilt creëren, vervang de code in uw Main.qs door de volgende code:

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

Op dezelfde manier kunt u de bellstatussen $\ket{\psi^+}$ and $\ket{\psi^-}$ maken door de Pauli $X$ - en $Z-bewerkingen$ toe te passen op de qubits.

  • Om de Bell-toestand $\ket{\psi^+}=\frac1{\sqrt2}(\ket{01}+\ket{10})$ te creëren, past u de Pauli $X$-poort toe op de target-qubit nadat u de Hadamard-poort op de controlequbit hebt toegepast. Pas vervolgens de CNOT-poort toe.
  • Als u de klokstatus $\ket{\psi^-}=\frac1{\sqrt2}(\ket{01}-\ket{10})$wilt maken, past u de Pauli $Z$ toe op de controle-qubit en de Pauli $X$ op de target qubit nadat u de Hadamard-poort op de controle-qubit hebt toegepast. Pas vervolgens de CNOT-poort toe.

In de volgende les leert u hoe u verstrengeling gebruikt om kwantuminformatie te verzenden, een proces dat kwantumteleportatie wordt genoemd.