Oefening: verstrengeling gebruiken voor teleportatie met Q#

9 minuten

In de vorige les hebt u de stappen van het kwantumteleportatieprotocol geleerd. Nu is het uw beurt om Alice en Bob te helpen hun kwantumteleportatieexperiment te implementeren.

In deze les maakt u een programma in Q# om het kwantumteleportatieprotocol te gebruiken om de toestand van een bericht-qubit van Alice naar Bob te verzenden. Het programma bevat vier bewerkingen die samenwerken om de teleportatie uit te voeren.

Een kwantumteleportatieprogramma maken in Q#

Volg deze stappen om aan de slag te gaan met uw teleportatieprogramma:

Open Visual Studio Code (VS Code).
Open het menu Bestand en kies vervolgens Nieuw tekstbestand om een nieuw bestand te maken.
Sla het bestand op als Main.qs.

De vereiste bibliotheken importeren

Als u de bibliotheken wilt importeren die de Q# bewerkingen en functies bevatten die u nodig hebt om uw programma te schrijven, kopieert u de volgende code naar uw Main.qs-bestand :

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

`Teleport` De bewerking definiëren

Maak een bewerking Teleport die het kwantumteleportatieprotocol implementeert. De bewerking gebruikt twee qubits als invoer: de message qubit die de teleporteerde status bevat en de bob qubit die de teleporteerde status ontvangt.

operation Teleport(message : Qubit, bob : Qubit) : Unit {
    // Allocate an alice qubit.
    use alice = Qubit();

    // Create some entanglement that we can use to send our message
    H(alice);
    CNOT(alice, bob);

    // Encode the message into the entangled pair
    CNOT(message, alice);

    // Transform the Bell states into computational states for measurement
    H(message);

    // Measure the qubits to extract the classical data we need to decode
    // the message by applying the corrections on the bob qubit
    // accordingly.
    if M(message) == One {
        Z(bob);
    }
    if M(alice) == One {
        X(bob);
    }

    // Reset alice qubit before releasing
    Reset(alice);
}

Laten we de stappen in onze Teleport bewerking opsplitsen:

alice Een qubit maken. We hebben nu de drie qubits die we nodig hebben om kwantumteleportatie uit te voeren: alice, boben message.
Verstrengel de alice- en bob-qubits. Dit doen we op de gebruikelijke manier: pas een Hadamard-poort toe om de alice qubit in een superpositiestatus te plaatsen.
Codeer de message qubit in het verstrengelde paar alice en bob qubits. Hiervoor passen we een CNOT-poort toe met message als de controle-qubit en alice als de target qubit. De alice en message qubittoestanden bevinden zich nu in de Bell-basis.

Transformeer de belstatussen in rekenkundige toestanden. We doen dit omdat we in Q# niet rechtstreeks metingen kunnen uitvoeren op Bell-toestanden. Pas een Hadamard-poort toe op de message qubit om de statussen om te zetten in de rekenkundige basis. De volgende tabel relateert de Bell-toestanden met hun bijbehorende computationele toestanden.

Klokstatus	Berekeningsbasisstatus
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

Meet de alice en message qubits en pas de juiste poorten toe op de bob qubit op basis van de meetresultaten. Gebruik eerst de M bewerking om te meten message. Als het resultaat 1 is, past u de $Z-poort$ toe op bob. Meet alice vervolgens met de M bewerking. Als het resultaat 1 is, past u de $X-poort$ toe op bob.

Dit protocol teleporteert de initiële status van de message qubit naar de bob qubit.

`SetToPlus` De en `SetToMinus` bewerkingen definiëren

In een echt teleportatieprotocol kan de bericht-qubit elke superpositiestatus hebben. Alice noch Bob kennen de qubitstatus van het bericht. De toestand wordt geteleporteerd van de berichtqubit naar de qubit van Bob, ook al is de toestand niet bekend. Maar in Q# moeten we de toestand van de berichtqubit voor het teleportatieprotocol instellen.

Om ons teleportatieprotocol te testen met de bericht-qubit in verschillende begintoestanden, zoals |0⟩, |1⟩, |+⟩ en |−⟩, maken we de SetToPlus en SetToMinus bewerkingen. Met deze bewerkingen wordt de bericht-qubit in de gewenste initiële status geplaatst voordat we deze teleporteren.

Kopieer de volgende code voor de SetToPlus en SetToMinus bewerkingen naar uw Main.qs-bestand :

/// Sets a qubit in state |0⟩ to |+⟩.
operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {
    H(q);
}

/// Sets a qubit in state |0⟩ to |−⟩.
operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {
    X(q);
    H(q);
}

`Main` De bewerking definiëren

Elk Q# programma moet een invoerpuntbewerking hebben. Dit is standaard de Main bewerking. Hier voert onze Main bewerking het teleportatieprotocol uit voor verschillende beginstatussen van de bericht-qubit, $\ket{{0}$, $\ket{1}$+ $\ket{}$en $\ket{-}$. Als het protocol is geslaagd, eindigt de qubit van Bob in dezelfde staat als waarop we de berichtenqubit aanvankelijk hebben ingesteld.

Dit is de Main bewerking voor het kwantumteleportatieprogramma:

operation Main() : Result[] {
    // Allocate the message and bob qubits
    use (message, bob) = (Qubit(), Qubit());

    // Use the `Teleport` operation to send different quantum states
    let stateInitializerBasisTuples = [
        ("|0〉", I, PauliZ),
        ("|1〉", X, PauliZ),
        ("|+〉", SetToPlus, PauliX),
        ("|-〉", SetToMinus, PauliX)
    ];

    mutable results = [];
    for (state, initializer, basis) in stateInitializerBasisTuples {
        // Initialize the message and show its state using the `DumpMachine`
        // function.
        initializer(message);
        Message($"Teleporting state {state}");
        DumpMachine();

        // Teleport the message and show the quantum state after
        // teleportation.
        Teleport(message, bob);
        Message($"Received state {state}");
        DumpMachine();

        // Measure bob in the corresponding basis and reset the qubits to
        // continue teleporting more messages.
        let result = Measure([basis], [bob]);
        set results += [result];
        ResetAll([message, bob]);
    }

    return results;
}

Laten we de onderdelen van de Main bewerking opsplitsen:

Wijs twee qubits message toe en bob.
Maak een lijst met tuples die de kwantumstatus bevatten, de bewerking die de message qubit initialiseert in de gewenste status en de basis voor meting. De initialisatiebewerkingen zijn I voor $\ket{0}$, X voor $\ket{1}$+ SetToPlus$\ket{}$en SetToMinus voor .$\ket{-}$
Doorloop de lijst met tuples om de message qubit te initialiseren en de initiële status weer te geven. Roep vervolgens de Teleport bewerking aan om de status van de message qubit naar de bob qubit te teleporteren.
Meet de bob qubit in de bijbehorende basis en stel de qubits opnieuw in, zodat u deze opnieuw kunt gebruiken voor teleportatie.
Retourneer de meetresultaten voor elke teleportatie.

Als het protocol correct werkt, komen de meetresultaten voor bob overeen met de geïnitialiseerde toestanden voor message.

Het programma uitvoeren

Uw kwantumteleportatieprogramma is klaar. Voer het programma uit om te zien hoe kwantumteleportatie werkt voor verschillende beginstatussen van de bericht-qubit.

Het volledige programma bevat de Teleport bewerking, de SetToPlus en SetToMinus bewerkingen en de Main bewerking. Voer de volgende stappen uit om uw code uit te voeren en de resultaten te analyseren:

Vervang de inhoud van het bestand Main.qs door de volgende Q# code:

/// This Q# program implements quantum teleportation
import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Measurement.*;

operation Main() : Result[] {
    // Allocate the message and bob qubits.
    use (message, bob) = (Qubit(), Qubit());

    // Use the `Teleport` operation to send different quantum states
    let stateInitializerBasisTuples = [
        ("|0〉", I, PauliZ),
        ("|1〉", X, PauliZ),
        ("|+〉", SetToPlus, PauliX),
        ("|-〉", SetToMinus, PauliX)
    ];

    mutable results = [];
    for (state, initializer, basis) in stateInitializerBasisTuples {
        // Initialize the message and show its state using the `DumpMachine`
        // function
        initializer(message);
        Message($"Teleporting state {state}");
        DumpMachine();

        // Teleport the message and show the quantum state after
        // teleportation
        Teleport(message, bob);
        Message($"Received state {state}");
        DumpMachine();

        // Measure bob in the corresponding basis and reset the qubits to
        // continue teleporting more messages
        let result = Measure([basis], [bob]);
        set results += [result];
        ResetAll([message, bob]);
    }

    return results;
}

/// # Summary
/// Sends the state of a message qubit to a bob qubit by teleportation
///
/// Notice that after calling Teleport, the state of `message` is collapsed
///
/// # Input
/// ## message: A qubit whose state we wish to send
/// ## bob: A qubit initially in the |0〉 state that we want to send
/// the state of message to
operation Teleport(message : Qubit, bob : Qubit) : Unit {
    // Allocate an alice qubit.
    use alice = Qubit();

    // Create some entanglement that we can use to send our message
    H(alice);
    CNOT(alice, bob);

    // Encode the message into the entangled pair
    CNOT(message, alice);
    H(message);

    // Measure the qubits to extract the classical data we need to decode
    // the message by applying the corrections on the bob qubit
    // accordingly
    if M(message) == One {
        Z(bob);
    }
    if M(alice) == One {
        X(bob);
    }

    // Reset alice qubit before releasing.
    Reset(alice);
}

/// # Summary
/// Sets a qubit in state |0⟩ to |+⟩
operation SetToPlus(q : Qubit) : Unit is Adj + Ctl {
    H(q);
}

/// # Summary
/// Sets a qubit in state |0⟩ to |−⟩
operation SetToMinus(q : Qubit) : Unit is Adj + Ctl {
    X(q);
    H(q);
}

Als u uw programma op de ingebouwde simulator wilt uitvoeren, kiest u de Code Lens Uitvoeren boven de Main bewerking. Of druk op Ctrl+F5. De uitvoer verschijnt in de debugconsole.

Controleer of de ontvangen statussen overeenkomen met de teleporteerde statussen. Voorbeeld:

Teleporting state |0〉

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Received state |0〉

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Gefeliciteerd! U hebt met succes de status van de qubit van Alice naar de qubit van Bob geteleporteerd via het kwantumteleportatieprotocol. Allemaal dankzij kwantumverstrengeling!

Feedback

Is deze pagina nuttig?