Övning – Använda sammanflätning för att teleportera med Q#

  • 9 minuter

I föregående lektion granskade du stegen i kvantteleporteringsprotokollet. Nu är det din tur att hjälpa Alice och Bob med deras kvantteleporteringsexperiment!

I den här lektionen skapar du ett kvantteleporteringsprogram i Q# som använder kvantteleporteringsprotokollet för att skicka tillståndet för en kvantbit från Alice till Bob.

Skapa ett kvantteleporteringsprogram i Q#

  1. Öppna Visual Studio Code.
  2. Välj Fil > Ny textfil och spara den som Main.qs.
  3. Välj Visa –> Kommandopalett och skriv Q#: Ange Azure Quantum QIR-profilentarget. Tryck på Retur.
  4. Välj Q#: Obegränsad.

Importera nödvändiga bibliotek

Först måste du importera de bibliotek som krävs för att använda Q# åtgärderna och funktionerna. Kopiera och klistra in följande kod i main.qs-filen.

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

Definiera åtgärden Teleport

Först måste du definiera den Teleport åtgärd som implementerar kvantteleporteringsprotokollet. Åtgärden tar två kvantbitar som indata: den message kvantbit som innehåller kvanttillståndet som ska teleporteras och den bob kvantbit som ska ta emot tillståndet.

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

Nu ska vi dela upp åtgärden Teleport :

  1. Åtgärden använder kvantbiten alice och skapar sammanflätning mellan alice och bob kvantbitar. Qubiten message är sedan sammanflätad med kvantbitenalice, så de två kvantbitarna är sammanflätade med qubiten message bob och kodas.

  2. Sedan måste du mäta alice och message qubits i Bell-basen. Hur kan du uttrycka en mätning i bellbasen i Q#? Det kan du inte. Eller åtminstone inte direkt. I Q# har du åtgärden M , som utför ett mått i $Z-basis$ eller beräkningsbas. För att kunna använda åtgärden M korrekt måste du omvandla klocktillstånden till beräkningsbastillstånden. Du kan göra detta genom att tillämpa en H åtgärd på kvantbiten message . I följande tabell visas korrespondensen mellan klocktillstånden och beräkningsbastillstånden.

    Klocktillstånd Beräkningsbastillstånd
    $\ket{\phi^+}$ $\ket{00}$
    $\ket{\phi^-}$ $\ket{01}$
    $\ket{\psi^+}$ $\ket{10}$
    $\ket{\psi^-}$ $\ket{11}$

    Dricks

    En bra övning är att verifiera motsvarigheten för klocktillstånden och beräkningsbastillstånden efter att ha tillämpat Hadamard-åtgärden på den första kvantbiten. Lycka till!

  3. Slutligen if kontrollerar instruktionerna mätresultaten och tillämpar korrigeringar på kvantbiten bob i enlighet med detta. Om kvantbiten message mäts i Oneanvänder du Z-grinden på kvantbiten bob . Om kvantbiten alice också mäts i One använder du X-grinden på kvantbiten bob .

Definiera åtgärderna SetToPlus och SetToMinus

Om du vill teleporteras kvantbitar i olika tillstånd, till exempel |0⟩, |1⟩, |+⟩ och |−⟩, måste du definiera de initierade tillstånden. Du har redan åtgärden Teleport för att teleportera kvantbiten, men du måste förbereda kvantbiten i rätt tillstånd innan du teleporterar den.

Du måste definiera ytterligare två åtgärder SetToPlus och SetToMinus, för att ange en qubit i tillstånd |0⟩ till |+⟩ |respektive −⟩.

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

Definiera åtgärden Main

Varje Q# program måste ha en Main åtgärd som fungerar som startpunkt för programmet. Åtgärden Main kör teleporteringsprotokollet för olika kvanttillstånd, $\ket{{0}$, $\ket{1}$, $\ket{+}$ och $\ket{-}$.

Nu ska vi dela upp åtgärden Main :

  1. Åtgärden allokerar två kvantbitar message och bob.
  2. Den definierar en lista över tupplar som innehåller kvanttillståndet, den initialiseraråtgärd som krävs för att initiera kvantbiten i ett sådant tillstånd och grunden för teleporteringen. Initieringsåtgärderna gäller I för $\ket{0}$, X för $\ket{1}$, SetToPlus för $\ket{+}$och SetToMinus för $\ket{-}$. Åtgärderna SetToPlus och SetToMinus definieras i föregående steg.
  3. Åtgärden itererar över listan över tupplar och initierar kvantbiten message i motsvarande tillstånd och använder DumpMachine för att visa tillståndet. Därefter teleporteras qubitens message tillstånd till kvantbiten bob med hjälp av åtgärden Teleport som definierades i föregående steg.
  4. Efter teleporteringen av tillståndet mäter åtgärden kvantbiten bob i motsvarande bas och återställer kvantbitarna för att fortsätta teleportera fler meddelanden.
  5. Slutligen returnerar åtgärden mätresultatet för varje teleportering.
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;
}

Köra programmet

Ditt kvantteleporteringsprogram är klart! Du kan köra programmet för att se hur kvantteleportering fungerar för olika kvanttillstånd. Programmet initierar kvantbiten message i olika tillstånd och teleporterar tillståndet till kvantbiten bob .

Följande kod innehåller Teleport åtgärden, SetToPlus åtgärderna och SetToMinus och den Main åtgärd som kör teleporteringsprotokollet för olika kvanttillstånd.

  1. Filen Main.qs bör se ut så här:

    /// 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. Om du vill köra programmet i den inbyggda simulatorn klickar du på Kör ovanför åtgärden eller trycker på Ctrl+F5Main. Dina utdata visas i felsökningskonsolen.

  3. Kontrollera att de mottagna tillstånden matchar teleporteringstillstånden. Till exempel:

    Teleporting state |0〉

DumpMachine:

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

Received state |0〉