Øvelse - Brug sammenfiltring til teleportering med Q#

9 minutter

I den forrige enhed lærte du trinene i kvanteteleportationsprotokollen. Nu er det din tur til at hjælpe Alice og Bob med at implementere deres kvanteteleportationseksperiment!

I denne enhed opretter du et program Q# , der bruger kvanteteleportationsprotokollen til at sende tilstanden af en meddelelsesqubit fra Alice til Bob. Programmet indeholder fire operationer, der arbejder sammen for at udføre teleporteringen.

Opret et kvanteteleporteringsprogram i Q#

Følg disse trin for at komme i gang med dit teleporteringsprogram:

Åbn Visual Studio Code (VS Code).
Åbn menuen Filer , og vælg derefter Ny tekstfil for at oprette en ny fil.
Gem filen som Main.qs.

Importér de påkrævede biblioteker

Hvis du vil importere de biblioteker, der indeholder de Q# handlinger og funktioner, du skal bruge til at skrive programmet, skal du kopiere følgende kode til filen Main.qs :

import Std.Diagnostics.*;
import Std.Intrinsic.*;
import Std.Measurement.*;

Definer handlingen `Teleport`

Opret en handling, der kaldes Teleport , der implementerer kvanteteleportationsprotokollen. Handlingen tager to qubits som input: den message qubit, der indeholder den teleporterede tilstand, og qubitten bob , der modtager den teleporterede tilstand.

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

Lad os nedbryde trinene i vores Teleport drift:

Opret en alice qubit. Vi har nu de tre qubits, som vi skal bruge for at udføre kvanteteleportation: alice, bob, og message.
Sammenfiltring af alice og bob qubits. Vi gør dette på den sædvanlige måde: Anvend en Hadamard-port for at sætte qubitten alice i en superpositionstilstand.
Kod qubitten message ind i det sammenfiltrede par af alice og bob qubits. For at gøre dette anvender vi en CNOT-gate med message som kontrol-qubit og alice som qubit.target Tilstandene alice og message qubit er nu i Bell-basis.
Transformer Bell-tilstandene til beregningstilstande. Vi gør dette, fordi vi i Q#, ikke kan udføre målinger direkte på Bell-tilstande. Anvend en Hadamard-port på qubitten message for at omdanne tilstandene til beregningsgrundlaget. Følgende tabel relaterer Bell-tilstandene med deres tilsvarende beregningstilstande:

Klokketilstand Beregningsgrundlagtilstand

$\ket{\phi^+}$ $\ket{00}$

$\ket{\phi^-}$ $\ket{01}$

$\ket{\psi^+}$ $\ket{10}$

$\ket{\psi^-}$ $\ket{11}$
Mål alice og message qubits, og anvend de relevante porte på qubitten bob baseret på måleresultaterne. Brug først operationen M til at måle message. Hvis resultatet er 1, skal du anvende Z-porten $$ på bob. Mål alice derefter med operationen M . Hvis resultatet er 1, så anvend porten $X$ på bob.

Klokketilstand	Beregningsgrundlagtilstand
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

Denne protokol teleporterer qubittens message oprindelige tilstand til qubitten bob .

Definer handlingerne `SetToPlus` og `SetToMinus`

I en teleportationsprotokol i det virkelige liv kan meddelelses-qubitten være i en hvilken som helst superpositionstilstand. Hverken Alice eller Bob kender tilstanden af besked-qubitten. Staten teleporteres fra besked-qubit til Bobs qubit, selvom staten ikke er kendt. Men i Q#, skal vi indstille tilstanden af besked-qubit'en før teleportationsprotokollen.

For at teste vores teleporteringsprotokol med meddelelses-qubitten i forskellige starttilstande, såsom |0⟩, |1⟩, |+⟩ og |−⟩, opretter SetToPlus vi og-operationerne SetToMinus . Disse handlinger sætter meddelelses-qubit'en i den ønskede starttilstand, før vi teleporterer den.

Kopiér følgende kode til handlingerne SetToPlus og SetToMinus til din Main.qs-fil :

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

Definer handlingen `Main`

Hvert Q# program skal have en entrypoint-handling, som er handlingen Main som standard. Her kører vores Main operation teleportationsprotokollen for forskellige initialtilstande af beskedqubitten, $\ket{0}$, $\ket{1}$, $\ket{+}$, og $\ket{-}$. Hvis protokollen lykkes, ender Bobs qubit i den samme tilstand, som vi oprindeligt indstillede meddelelsesqubit til.

Her er operationen Main for kvanteteleporteringsprogrammet:

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

Lad os opdele komponenterne i operationen Main :

Tildel to qubits, message og bob.
Opret en liste over tuppler, der indeholder kvantetilstanden, den handling, der initialiserer qubitten message til den ønskede tilstand, og grundlaget for måling. Initialiseringsoperationerne er I for $\ket{0}$, X for $\ket{1}$, SetToPlus for $\ket{+}$, og SetToMinus for $\ket{-}$.
Gentag over listen over tupler for at initialisere qubitten message og få vist den oprindelige tilstand. Ring derefter til handlingen Teleport for at teleportere qubittens message tilstand til qubitten bob .
Mål qubitten bob i det tilsvarende grundlag, og nulstil qubits, så du kan genbruge dem til teleportering.
Returner måleresultaterne for hver teleportering.

Hvis protokollen fungerer korrekt, svarer dine måleresultater til bob de initialiserede tilstande for message.

Kør programmet

Dit kvanteteleportationsprogram er klar! Kør programmet for at se, hvordan kvanteteleportering fungerer for forskellige starttilstande for meddelelsesqubitten.

Det komplette program indeholder operationen Teleport , operationerne SetToPlus og SetToMinus operationen Main . Følg disse trin for at køre din kode og analysere resultaterne:

Erstat indholdet af din Main.qs-fil med følgende Q# kode:

/// This Q# program implements quantum teleportation
import Std.Diagnostics.*;
import Std.Intrinsic.*;
import Std.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);
}

For at køre dit program på den indbyggede simulator skal du vælge Kør kodelinse over handlingen Main . Du kan også trykke på Ctrl + F5. Dit output vises i fejlfindingskonsollen.

Kontroller, at de modtagne tilstande stemmer overens med de teleporterede tilstande. For eksempel:

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

Tillykke! Du teleporterede med succes tilstanden af Alices qubit til Bobs qubit gennem kvanteteleportationsprotokollen. Alt takket være kvante-indfiltrering!

Feedback

Var denne side nyttig?