Oefening: verstrengeling gebruiken om te teleporteren met Q#

Voltooid

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

In deze les maakt u een kwantumteleportatieprogramma waarin Q# het kwantumteleportatieprotocol wordt gebruikt om de status van een qubit van Alice naar Bob te verzenden.

Een kwantumteleportatieprogramma maken in Q#

  1. Open Visual Studio Code.
  2. Selecteer Nieuw > tekstbestand bestand en sla het op als Main.qs.
  3. Selecteer Weergave -> Opdrachtpalet en typQ#: Stel het Azure Quantum QIR-profiel target in. Druk op Enter.
  4. Selecteer Q#: Onbeperkt.

De vereiste bibliotheken importeren

Eerst moet u de vereiste bibliotheken importeren om de Q# bewerkingen en functies te kunnen gebruiken. Kopieer en plak de volgende code in 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

Eerst moet u de Teleport bewerking definiëren waarmee het kwantumteleportatieprotocol wordt geïmplementeerd. De bewerking gebruikt twee qubits als invoer: de message qubit die de kwantumstatus bevat die moet worden geteld en de bob qubit die de 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);
        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 Teleport bewerking opsplitsen:

  1. De bewerking maakt gebruik van de alice qubit en maakt verstrengeling tussen alice en bob qubits. De message qubit wordt vervolgens verstrengeld met de alice qubit, dus de twee qubits zijn verstrengeld met de bob qubit en de message qubit wordt gecodeerd.

  2. Vervolgens moet alice u meten en message qubits in de belbasis. Hoe kunt u een meting in de belbasis uitdrukken?Q# Dat is niet mogelijk. Of in ieder geval niet rechtstreeks. In Q# u hebt de M bewerking, die een meting uitvoert in de $Z-basis$ of rekenkundige basis. Als u de M bewerking dus correct wilt gebruiken, moet u de belstatussen omzetten in de rekenkundige basistoestanden. U kunt dit doen door een H bewerking toe te passen op de message qubit. In de volgende tabel ziet u de correspondentie tussen de beltoestanden en de rekenkundige basistoestanden.

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

    Tip

    Een goede oefening is om de gelijkwaardigheid van de Bell-toestanden en de rekenbasistoestanden te controleren nadat de Hadamard-bewerking is toegepast op de eerste qubit. Succes!

  3. Ten slotte controleren de if instructies de meetresultaten en passen ze dienovereenkomstig correcties toe op de bob qubit. Als de message qubit wordt gemeten One, past u de Z-poort toe op de bob qubit. Als de alice qubit ook in One u wordt gemeten, past u de X-poort toe op de bob qubit.

SetToPlus De en SetToMinus bewerkingen definiëren

Als u qubits in verschillende toestanden wilt teleporteren, zoals |0⟩, |1⟩, |+⟩ en |−⟩, moet u de geïnitialiseerde statussen definiëren. U hebt al de Teleport bewerking om de qubit te teleporteren, maar u moet de qubit in de juiste status voorbereiden voordat u deze teleporteert.

U moet nog twee bewerkingen SetToPlus definiëren en SetToMinuseen qubit instellen in status |0⟩ respectievelijk op |+⟩ en |−⟩.

    /// 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 Main bewerking hebben die fungeert als het toegangspunt voor het programma. De Main bewerking voert het teleportatieprotocol uit voor verschillende kwantumstatussen,$\ket{{0}$ , $\ket{1}$$\ket{+}$ en $\ket{-}$.

Laten we de Main bewerking opsplitsen:

  1. Met de bewerking worden twee qubits message en bob.
  2. Hiermee definieert u een lijst met tuples die de kwantumstatus bevatten, de initialisatiebewerking die nodig is om de qubit in een dergelijke toestand te initialiseren en de basis voor de teleportatie. De initialisatiebewerkingen zijn I voor $\ket{0}$, X voor $\ket{1}$+ SetToPlus$\ket{}$en SetToMinus voor .$\ket{-}$ De SetToPlus en SetToMinus bewerkingen worden gedefinieerd in de vorige stappen.
  3. De bewerking doorloopt de lijst met tuples en initialiseert de message qubit in de bijbehorende status en gebruikt DumpMachine om de status weer te geven. Vervolgens wordt de status van de message qubit naar de bob qubit geteld met behulp van de Teleport bewerking die in de vorige stappen is gedefinieerd.
  4. Na het teleporteren van de status meet de bewerking de bob qubit in de bijbehorende basis en stelt de qubits opnieuw in om door te gaan met het teleporteren van meer berichten.
  5. Ten slotte retourneert de bewerking de meetresultaten voor elke teleportatie.
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;
}

Het programma uitvoeren

Uw kwantumteleportatieprogramma is klaar. U kunt het programma uitvoeren om te zien hoe kwantumteleportatie werkt voor verschillende kwantumstatussen. Het programma initialiseert de message qubit in verschillende statussen en teleporteert de status naar de bob qubit.

De volgende code bevat de Teleport bewerking, de SetToPlus en SetToMinus bewerkingen en de Main bewerking waarmee het teleportatieprotocol voor verschillende kwantumstatussen wordt uitgevoerd.

  1. Het bestand Main.qs moet er als volgt uitzien:

    /// 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 one qubit to a bob qubit by using 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);
    }
    
  2. Als u uw programma wilt uitvoeren op de ingebouwde simulator, klikt u op Uitvoeren boven de bewerking of drukt u op Main. Uw uitvoer wordt weergegeven in de console voor foutopsporing.

  3. Controleer of de ontvangen statussen overeenkomen met de teleporterende statussen. Voorbeeld:

    Teleporting state |0〉
    
    DumpMachine:
    
     Basis | Amplitude      | Probability | Phase
     -----------------------------------------------
      |00⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
    
    Received state |0〉
    

Gefeliciteerd! U kunt de status van de qubit van Alice teleporteren naar de qubit van Bob met behulp van het kwantumteleportatieprotocol. Allemaal dankzij kwantumverstrengeling!

In de volgende les test u uw kennis van kwantumteleportatie en verstrengeling.