Vytvoření teleportace pomocí Q#

9 min

V předchozí lekci jste si prostudovali kroky kvantového teleportačního protokolu. Teď se můžete obrátit na pomoc Alice a Boba s jejich kvantovým teleportačním experimentem!

V této lekci vytvoříte kvantový teleportační program, který Q# pomocí kvantového teleportačního protokolu odešle stav qubitu z Alice do Boba.

Vytvoření kvantového teleportačního programu v Q#

Otevřete Visual Studio Code.
Vyberte Soubor > Nový textový soubor a uložte ho jako Main.qs.
Vyberte Zobrazit –> Paleta příkazů a zadejteQ#: Nastavte profil Azure Quantum QIRtarget. Stiskněte klávesu Enter.
Vyberte Q#: Bez omezení.

Import potřebných knihoven

Nejprve je potřeba naimportovat požadované knihovny, abyste mohli používat Q# operace a funkce. Zkopírujte a vložte následující kód do souboru Main.qs .

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

`Teleport` Definování operace

Nejprve musíte definovat Teleport operaci, která implementuje kvantový teleportační protokol. Operace přebírá jako vstup dva qubity: message qubit obsahující kvantový stav, který se má teleportovat, a bob qubit, který obdrží stav.

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

Pojďme operaci Teleport rozdělit:

Operace používá alice qubit a vytváří propletení mezi alice qubity a bob qubity. Qubit message se pak proplete s qubitem alice , takže dva qubity jsou propletené s qubitem bob a message kóduje se.
Pak potřebujete měřit alice a message qubity v základu Bell. Jak můžete vyjádřit měření v základu Q#zvonu ? Nemůžete. Nebo alespoň ne přímo. Máte Q# operaci M , která provádí měření v základu $Z$ nebo ve výpočetním základu. Aby bylo možné tuto operaci použít M správně, je nutné transformovat stavy Zvonu na výpočetní základní stavy. Můžete to provést použitím H operace na message qubit. Následující tabulka uvádí korespondenci mezi stavy Bellu a výpočetními stavy základu.

Stav zvonu Výpočet základního stavu

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

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

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

$\ket{\psi^-}$ $\ket{11}$

Tip

Dobrým cvičením je ověření ekvivalence stavů Bell a výpočetních stavů základu po použití operace Hadamard na první qubit. Hodně zdaru!
if Nakonec příkazy kontrolují výsledky měření a odpovídajícím způsobem aplikují opravy na bob qubit. message Pokud se qubit měří, Onepoužijete bránu Z na bob qubit. alice Pokud se qubit měří také na One qubit, použijete na qubit bránu bob X.

Stav zvonu	Výpočet základního stavu
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

`SetToPlus` Definování a `SetToMinus` operace

Pokud chcete teleportovat qubity v různých stavech, například |0⟩, |1⟩, |+⟩ a |−⟩, musíte definovat inicializované stavy. Už máte Teleport operaci pro teleportování qubitu, ale před jeho teleportováním je potřeba qubit připravit ve správném stavu.

Je potřeba definovat dvě další operace SetToPlus a SetToMinusnastavit qubit ve stavu |0⟩ na |+⟩ a |−⟩.

    /// 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` Definování operace

Každý Q# program musí mít Main operaci, která slouží jako vstupní bod programu. Operace Main spouští teleportační protokol pro různé kvantové stavy, $\ket{{0}$, , $\ket{1}$+ $\ket{}$a $\ket{-}$.

Pojďme operaci Main rozdělit:

Operace přidělí dva qubity a message bob.
Definuje seznam řazených kolekcí členů, které obsahují kvantový stav, operaci inicializátoru potřebnou k inicializaci qubitu v tomto stavu a základ pro teleportaci. Operace inicializátoru jsou I pro $\ket{0}$, X pro $\ket{1}$, SetToPlus pro $\ket{+}$ a SetToMinus pro $\ket{-}$. Operace SetToPlus jsou SetToMinus definovány v předchozích krocích.
Operace iteruje seznam řazených kolekcí členů a inicializuje message qubit v odpovídajícím stavu a používá DumpMachine k zobrazení stavu. Pak teleportuje stav qubitu message bob do qubitu Teleport pomocí operace definované v předchozích krocích.
Po teleportování stavu operace měří bob qubit v odpovídajícím základu a resetuje qubity, aby pokračovaly v teleportování dalších zpráv.
Nakonec operace vrátí výsledky měření pro každou teleportaci.

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

Spuštění programu

Váš kvantový teleportační program je připravený! Spuštěním programu můžete zjistit, jak kvantové teleportace funguje pro různé kvantové stavy. Program inicializuje message qubit v různých stavech a teleportuje stav do qubitu bob .

Následující kód obsahuje Teleport operaci, SetToPlus operace a SetToMinus Main operaci, která spouští teleportační protokol pro různé kvantové stavy.

Soubor Main.qs by měl vypadat takto:

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

Pokud chcete program spustit na integrovaném simulátoru, klikněte na Spustit nad operací nebo stiskněte Ctrl+F5.Main Výstup se zobrazí v konzole ladění.

Zkontrolujte, jestli přijaté stavy odpovídají stavům teleportování. Příklad:

Teleporting state |0〉

DumpMachine:

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

Received state |0〉

Vytvoření teleportace pomocí Q#

Vytvoření kvantového teleportačního programu v Q#

Import potřebných knihoven

Teleport Definování operace

SetToPlus Definování a SetToMinus operace

Main Definování operace

Spuštění programu

Váš názor

`Teleport` Definování operace

`SetToPlus` Definování a `SetToMinus` operace

`Main` Definování operace