Упражнение — Использование запутанности для телепортации с применением Q#

9 мин

В предыдущем уроке вы узнали шаги протокола квантового телепортации. Теперь это ваша очередь, чтобы помочь Алисе и Боб реализовать свой квантовый эксперимент телепортации!

В этом модуле вы создадите программу, которая Q# использует протокол квантовой телепортации для отправки состояния кубита сообщения от Алисы Бобу. Программа содержит четыре операции, которые работают вместе для выполнения телепортации.

Создайте программу квантовой телепортации в Q#

Чтобы приступить к работе с программой телепортации, выполните следующие действия.

Откройте Visual Studio Code (VS Code).
Откройте меню "Файл " и выберите "Создать текстовый файл ", чтобы создать новый файл.
Сохраните файл как Main.qs.

Импорт необходимых библиотек

Чтобы импортировать библиотеки, содержащие Q# операции и функции, необходимые для записи программы, скопируйте следующий код в файл Main.qs :

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

`Teleport` Определение операции

Создайте операцию под названием Teleport, которая реализует протокол квантовой телепортации. Операция принимает два кубита в качестве входных данных: message кубит, содержащий телепортированное состояние, и bob кубит, получающий телепортированное состояние.

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

Давайте разберем шаги, описанные в нашей Teleport операции:

alice Создайте кубит. Теперь у нас есть три кубита, которые нам нужны для выполнения квантовой телепортации: alice, bob, и message.
Переплести alice и bob кубиты. Мы делаем это обычным образом: применяем врата Адамара, чтобы перевести alice кубит в состояние суперпозиции.
Закодируйте кубит message в запутанную пару кубитов alice и bob. Для этого мы применяем гейт CNOT с message в качестве контрольного кубита и alice в качестве кубита target. Состояния alice и message кубитов в настоящее время находятся в базе Белла.

Преобразуйте состояния Белла в вычислительные состояния. Мы делаем это потому, что в Q# мы не можем выполнять измерения непосредственно на состоянии Белла. Примените оператор Адамара к message кубиту, чтобы преобразовать состояния в вычислительное базисное состояние. В следующей таблице перечислены состояния Bell с соответствующими вычислительными состояниями:

Беллово состояние	Состояние вычислительной основы
$\ket{\phi^+}$	$\ket{00}$
$\ket{\phi^-}$	$\ket{01}$
$\ket{\psi^+}$	$\ket{10}$
$\ket{\psi^-}$	$\ket{11}$

Измеряйте кубиты alice и message и применяйте соответствующие гейты к кубиту bob, в зависимости от результатов измерения. Сначала используйте операцию M, чтобы измерить message. Если результат равен 1, примените $шлюз Z$ к bob. Затем измерьте alice с помощью операции M. Если результат равен 1, примените шлюз $X$ к bob.

Этот протокол телепортирует исходное состояние message кубита на bob кубит.

Определите операции `SetToPlus` и `SetToMinus`

В протоколе телепортации реального времени кубит сообщения может находиться в любом состоянии суперпозиции. Ни Алиса, ни Боб не знают состояние кубита сообщения. Состояние телепортируется из кубита сообщения на кубит Боба, хотя состояние неизвестно. Но в Q#, мы должны задать состояние кубита сообщения перед протоколом телепортации.

Чтобы проверить протокол телепортации с кубитом сообщений в различных начальных состояниях, таких как |0⟩, |1⟩, |+⟩ и |−⟩, мы создадим SetToPlus и SetToMinus операции. Эти операции помещают кубит сообщения в требуемое начальное состояние перед его телепортацией.

Скопируйте следующий код для операций SetToPlus и SetToMinus в файл Main.qs:

/// 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` Определение операции

Каждая Q# программа должна иметь операцию точки входа, которая является Main операцией по умолчанию. Здесь наша Main операция выполняет протокол телепортации для различных начальных состояний кубита сообщения, $\ket{0}$, , $\ket{1}$$\ket{+}$и $\ket{-}$. Если протокол выполнен успешно, кубит Боба в конечном итоге находится в том же состоянии, в которое мы изначально задали кубит сообщения.

Ниже приведена Main операция для программы квантового телепортации:

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

Давайте разберем компоненты Main операции:

Выделите два кубита message и bob.
Создайте список кортежей, содержащих квантовое состояние, операцию, которая инициализирует кубит message в требуемое состояние, и базис для измерения. Операции инициализации следующие: I для $\ket{0}$, X для $\ket{1}$, SetToPlus для $\ket{+}$ и SetToMinus для $\ket{-}$.
Пройдите по списку кортежей для инициализации кубита message и отображения начального состояния. Затем вызовите Teleport операцию для телепорта состояния message кубита на bob кубит.
Измерьте кубит bob в соответствующей основе и сбросьте кубиты для их повторного использования в телепортации.
Возвращает результаты измерения для каждой телепортации.

Если протокол работает правильно, тогда результаты измерений для bob совпадают с инициализированными состояниями для message.

Запуск программы

Ваша программа квантовой телепортации готова! Запустите программу, чтобы узнать, как работает квантовое телепортирование для различных начальных состояний кубита сообщения.

Полная программа содержит операцию Teleport, операции SetToPlus и SetToMinus, а также операцию Main. Чтобы запустить код и проанализировать результаты, выполните следующие действия.

Замените содержимое файла Main.qs следующим Q# кодом:

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

Чтобы запустить программу на встроенном симуляторе, выберите линзу Run над операцией Main. Или нажмите клавиши CTRL+F5. Выходные данные отображаются в консоли отладки.

Убедитесь, что полученные состояния соответствуют телепортированным состояниям. Например:

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

Поздравляю! Вы успешно телепортировали состояние кубита Алисы к кубиту Боба через протокол квантового телепортации. Все благодаря квантовой запутанности!

Обратная связь

Были ли сведения на этой странице полезными?