Tworzenie teleportacji za pomocą polecenia Q#

9 min

W poprzedniej lekcji zapoznaliśmy się z krokami protokołu teleportacji kwantowej. Teraz to twoja kolej, aby pomóc Alicji i Bobowi w eksperymencie teleportacji kwantowej!

W tej lekcji utworzysz program teleportacji kwantowej, który Q# używa protokołu teleportacji kwantowej do wysyłania stanu kubitu z Alicji do Boba.

Tworzenie programu teleportacji kwantowej w programie Q#

Otwórz Visual Studio Code.
Wybierz pozycję Plik > nowy plik tekstowy i zapisz go jako Main.qs.
Wybierz pozycję Widok —> Paleta poleceń i wpisz Q#: Ustaw profil usługi Azure Quantum QIRtarget. Naciśnij klawisz Enter.
Wybierz pozycję Q#: Bez ograniczeń.

Importowanie wymaganych bibliotek

Najpierw należy zaimportować wymagane biblioteki, aby używać Q# operacji i funkcji. Skopiuj i wklej następujący kod do pliku Main.qs .

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

Definiowanie `Teleport` operacji

Najpierw należy zdefiniować operację Teleport implementującą protokół teleportacji kwantowej. Operacja przyjmuje dwa kubity jako dane wejściowe: message kubit zawierający stan kwantowy do teleportowania i bob kubit, który otrzyma stan.

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

Przeanalizujmy operację Teleport :

Operacja używa kubitu alice i tworzy splątanie między alice bob i kubitami. message Kubit jest następnie splątany kubitemalice, więc dwa kubity są splątane kubitem bob i message kodowany.
Następnie należy zmierzyć alice i message kubity w bazie Bell. Jak można wyrazić pomiar w bazie Bell w Q#? Nie można. A przynajmniej nie bezpośrednio. W Q# przypadku operacji, która wykonuje pomiar w podstawie Z$ lub w oparciu M $o obliczenia. Aby więc prawidłowo użyć M operacji, należy przekształcić stany Bell w stany obliczeniowe podstawy. Można to zrobić, stosując operację H do kubitu message . W poniższej tabeli przedstawiono korespondencję między stanami Bell a stanami baz obliczeniowych.

Stan dzwonka Stan podstawy obliczeniowej

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

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

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

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

Napiwek

Dobrym ćwiczeniem jest sprawdzenie równoważności stanów Bell i stanów baz obliczeniowych po zastosowaniu operacji Hadamard do pierwszego kubitu. Powodzenia!
if Na koniec instrukcje sprawdzają wyniki pomiaru i odpowiednio stosują poprawki do kubitubob. Jeśli kubit jest mierzony w Oneelemecie message , należy zastosować bramę Z do kubitubob. alice Jeśli kubit jest również mierzony, One zastosuj bramę X do kubitubob.

Stan dzwonka	Stan podstawy obliczeniowej
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

Definiowanie operacji `SetToPlus` i `SetToMinus`

Jeśli chcesz teleportować kubity w różnych stanach, takich jak |0⟩, |1⟩, |+⟩ i |−⟩, musisz zdefiniować zainicjowane stany. Masz już operację Teleport teleportowania kubitu, ale przed teleportowaniem należy przygotować kubit w prawidłowym stanie.

Należy zdefiniować dwie kolejne operacje i SetToPlus SetToMinus, aby ustawić kubit w stanie |0⟩ odpowiednio na |+⟩ i |−⟩.

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

Definiowanie `Main` operacji

Każdy Q# program musi mieć operację Main , która służy jako punkt wejścia dla programu. Operacja Main uruchamia protokół teleportacji dla różnych stanów kwantowych, $\ket{{0}$, , $\ket{$\ket{1}$+}$i $\ket{-}$.

Przeanalizujmy operację Main :

Operacja przydziela dwa kubity i message bob.
Definiuje listę krotki, które zawierają stan kwantowy, operację inicjatora wymaganą do zainicjowania kubitu w takim stanie oraz podstawę teleportacji. Operacje inicjatora są I dla $\ket{0}$X , dla , dla $\ket{}$$\ket{1}$+ SetToPlus i SetToMinus dla $\ket{-}$. Operacje SetToPlus i SetToMinus są zdefiniowane w poprzednich krokach.
Operacja wykonuje iterację na liście krotki i inicjuje message kubit w odpowiednim stanie i używa DumpMachine go do wyświetlania stanu. Następnie teleportuje stan kubitu message do kubitu bob przy użyciu Teleport operacji zdefiniowanej w poprzednich krokach.
Po teleportowaniu stanu operacja mierzy bob kubit w odpowiedniej bazie i resetuje kubity, aby kontynuować teleportowanie większej liczby komunikatów.
Na koniec operacja zwraca wyniki pomiaru dla każdej teleportacji.

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

Uruchamianie programu

Twój program teleportacji kwantowej jest gotowy! Możesz uruchomić program, aby zobaczyć, jak działa teleportacja kwantowa dla różnych stanów kwantowych. Program inicjuje message kubit w różnych stanach i teleportuje stan do kubitu bob .

Poniższy kod zawiera operację Teleport , SetToPlus operacje i SetToMinus oraz Main operację, która uruchamia protokół teleportacji dla różnych stanów kwantowych.

Plik Main.qs powinien wyglądać następująco:

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

Aby uruchomić program w wbudowanym symulatorze, kliknij pozycję Uruchom nad operacją Main lub naciśnij Ctrl+F5. Dane wyjściowe zostaną wyświetlone w konsoli debugowania.

Sprawdź, czy odebrane stany są zgodne ze stanami teleportowania. Na przykład:

Teleporting state |0〉

DumpMachine:

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

Received state |0〉

Tworzenie teleportacji za pomocą polecenia Q#

Tworzenie programu teleportacji kwantowej w programie Q#

Importowanie wymaganych bibliotek

Definiowanie Teleport operacji

Definiowanie operacji SetToPlus i SetToMinus

Definiowanie Main operacji

Uruchamianie programu

Opinia

Definiowanie `Teleport` operacji

Definiowanie operacji `SetToPlus` i `SetToMinus`

Definiowanie `Main` operacji