5. Запускаем движки: от квантовой генерации случайных чисел до телепортации с остановкой на сверхплотном кодировании

В этой главе вы познакомитесь с тремя замечательными возможностями квантовых систем по обработке информации. Мы начнем с одной из самых простых процедур, исследуя принципиально случайную природу квантовой механики как источника истинной случайности. Далее в главе рассматриваются две взаимосвязанные процедуры, называемые сверхплотным кодированием и квантовой телепортацией. Изучая сверхплотное кодирование, вы узнаете, как можно отправить два классических бита информации с помощью одного кубита. Читая о квантовой телепор­тации — как квантовое состояние кубита можно воссоздать с помощью гибридной классическо-квантовой процедуры передачи информации. Все алгоритмы включают разработку схем для IBM Q Experience Composer, а также код на Python и QASM. Результаты разберем и проанализируем, так что начнем.

Квантовый генератор случайных чисел

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

Генератор случайных битов на основе вентиля Адамара

Вентиль Адамара — один из фундаментальных логических элементов квантовых информационных систем. Он применяется для перевода кубита в суперпозицию состояний. С алгебраической точки зрения описывается матрицей:

.

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

На рис. 5.1 базисные состояния кубита описываются скобочной нотацией, где и . Вспомните из предыдущей главы, что кет-вектор — это просто единичный вектор (вектор, длина которого равна 1). Таким образом, общее состояние (или суперпозиция) определяется единичным вектором , где α и β — комплексные коэффициенты. Применение вентиля Н к базисным состояниям дает:

;

 

и полученное методом суперпозиции состояние ψ:

.

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

 

Рис. 5.1. Геометрическое представление общего (полученного методом суперпозиции) состояния ψ кубита

Примечание

Согласно принципам квантовой механики мы не можем с уверенностью предсказать значения коэффициентов α и β в предыдущих базисных состояниях, даже учитывая полное знание законов физики или изначальных условий, в которых находится частица. Лучшее, что мы можем сделать, — это рассчитать вероятность.

С учетом этого реализация схемы генератора случайных битов упрощена настолько, насколько это возможно. В IBM Q Experience Composer создайте схему с вентилем Адамара для первого кубита, а затем выполните измерение в базисном состоянии (рис. 5.2).

Пожалуй, не стоит запускать ее на реальном устройстве, так как процесс может оказаться длительным (помните, что выполнение запланировано и может занять некоторое время в зависимости от количества заданий в очереди выполнения). К тому же каждое выполнение на реальном устройстве уменьшает количество ваших кредитов. Запустите схему на моделирующем устройстве, чтобы получить результат немедленно (рис. 5.3). Обратите внимание на то, что появление каждого результата (0 или 1) имеет равную вероятность 1/2, поэтому мы можем создавать случайные данные: если вероятность для результата 1 > 1/2, получим 1, в противном случае — 0.

 

Рис. 5.2. Схема для генератора случайных битов

 

Рис. 5.3. Результаты выполнения для схемы, приведенной на рис. 5.2

Конечно, это очень неэффективный способ генерации случайных битов. Лучше было бы написать сценарий на Python с помощью QISKit для программного создания схемы в этом задании.

В листинге 5.1 показан простой сценарий для генерации n случайных чисел с помощью x кубитов, где число битов равно 2x. По умолчанию сценарий генерирует десять восьмибитовых случайных чисел, используя три кубита, то есть n = 10 и x = 3, при этом 23 = 8. Рассмотрим сказанное подробнее.

• В 12-й строке определяется функция qrng для создания схемы с применением n кубитов.

• С помощью QISKitAPI в строках 15–21 создается QuantumProgram с n кубитами и n классическими регистрами для хранения измерений.

• Ко всем кубитам применяется вентиль Адамара, затем выполняется измерение для каждого, и, наконец, результат сохраняется в n-м классическом регистре (строки 30–35).

• Схема компилируется для запуска на удаленном моделирующем устройстве от Q Experience с помощью системного вызова set_api(API-TOKEN,URL). Обратите внимание, что вам понадобится дескриптор конфигурации с токеном API и URL-адресом конечной точки. Схема запускается, и полученные в результате числовые значения накапливаются (строки 40–51).

• Наконец, чтобы сгенерировать случайные биты, посмотрите на итоговые числа. Например, получены результаты {'100':133,'101':134,'011':131,'110':125,'001':109,'111':128,'010':138,'000':126}. Для каждого результата, если значение больше средней вероятности, вы получаете 1, в противном случае — 0. Средняя вероятность рассчитывается делением количества запусков (в данном случае 1024) на количество результатов (для 2x, где x — количество кубитов (по умолчанию 3), получим 1024 / 8 = 128). Таким образом, для предыдущих результатов получается следующее.

133	1
134	1
131	1	11100010 = 226
125	0
109	0
128	0
138	1
126	0

Листинг 5.1. Квантовая программа, позволяющая генерировать n случайных 2x-битовых чисел

#############################

import sys,time

import qiskit

import logging

from qiskit import QuantumProgram

 

# конфигурация Q Experience

sys.path.append('../Config/')

import Qconfig

 

# Генерация случайного 2**n-битового числа, где n — количество кубитов

def qrng(n):

 

    # Создать программу

    qp = QuantumProgram()

 

    # Создать n кубитов

    quantum_r = qp.create_quantum_register("qr", n)

 

    # Создать n классических регистров

    classical_r = qp.create_classical_register("cr", n)

 

    # Создать схему

    circuit = qp.create_circuit("QRNG", [quantum_r], [classical_r])

 

    # Включить ведение журналов

    #qp.enable_logs(logging.DEBUG);

 

    # Вентиль Адамара для всех кубитов

    for i in range(n):

        circuit.h(quantum_r[i])

 

    # Измерить n-й кубит и сохранить результат в n-м классическом бите

    for i in range(n):

        circuit.measure(quantum_r[i], classical_r[i])

 

    # Серверное моделирующее устройство

    backend = 'ibmq_qasm_simulator'

 

    # Набор исполняемых схем

    circuits = ['QRNG']

 

    # Скомпилируйте вашу программу: ASM print(qp.get_qasm('Circuit')), JSON:

    print(str(qobj))

 

    # Установите APIToken и URL-адрес API Q Experience

    qp.set_api(Qconfig.APItoken, Qconfig.config['url'])

    shots=1024

    result = qp.execute(circuits, backend, shots=shots, max_credits=3,

    timeout=240)

 

    # Вывод полученных числовых значений

    # counts={'100': 133, '101': 134, '011': 131, '110': 125, '001': 109,

    # '111': 128, '010': 138, '000': 126}

    counts = result.get_counts('QRNG')

    bits = ""

    for v in counts.values():

        if v > shots/(2**n) :

            bits += "1"

        else:

            bits += "0"

 

    return int(bits, 2)

 

###########################################

if __name__ == '__main__':

    start_time = time.time()

    numbers = []

 

    # Генерация 100 восьмибитовых случайных чисел

    size = 10

    qubits = 3 # bits = 2**qubits

 

    for i in range(size):

        n = qrng(qubits)

        numbers.append(n)

 

    print ("list=" + str(numbers))

    print("--- %s seconds ---" % (time.time() — start_time))

Внимание

Перед выполнением любой программы убедитесь, что конфигурация задана правильно, включая корректные токен API и URL конечной точки. Это основной источник неприятностей. Помните, что программа не будет выполняться, если вы допустите промах на этом крайне важном шаге.

Квантовая схема для листинга 5.1 показана на рис. 5.4. В схеме используются три кубита для генерации восьмибитовых случайных чисел в диапазоне между 0 и 255.

 

Рис. 5.4. Схема в Q Experience для программы из листинга 5.1

Накопим данные после нескольких запусков и протестируем результаты.

Тестирование результатов на случайность

Linux предоставляет удобную программу ent (сокращение от entropy — «энтропия»), предназначенную для проверки последовательности псевдослучайных чисел. Мы можем воспользоваться ею для проверки чисел, сгенерированных в предыдущем разделе.

Примечание

Пользователям Windows: бинарный файл для Windows 32 доступен для скачивания на сайте проекта. Он включен также в исходники для этой главы, находится в Workspace\Ch05\ent.exe.

Итак, я собрал около 200 случайных восьмибитовых чисел, сгенерированных с помощью программы из листинга 5.1.

С использованием ent данную последовательность можно протестировать вводом команды ent[infile], как показано далее:

C:\Workspace\Ch05>ent qrnd-stdout.txt

Entropy = 3.122803 bits per byte.

Optimum compression would reduce the size of this 805 byte file by 60 percent.

 

Chi square distribution for 805 samples is 29149.54, and randomly would

exceed this value less than 99.9 percent of the times.

 

Arithmetic mean value of data bytes is 46.1503 (127.5 = random).

Monte Carlo value for Pi is 4.000000000 (error 27.32 percent).

Serial correlation coefficient is -0.356331 (totally uncorrelated = 0.0).

Считается, что критерий хи-квадрат определяет качество случайной последовательности. Если процентное распределение хи-квадрат меньше 1 % или больше 99 %, то последовательность недостаточно хороша. Мой вывод дает 99,9 %, что указывает на то, что случайность чисел низкая. Вероятно, это связано с тем, что я использовал дистанционное моделирующее устройство. Видимо, оно основано на генераторе случайных чисел от UNIX (довольно низкого качества), применяемом по умолчанию. Посмотрите, будет ли ваша последовательность лучше. В табл. 5.1 сравниваются результаты, полученные от различных детерминированных и квантовых источников (предоставлены разработчиками ent).

Таблица 5.1. Результаты тестирования на случайность для различных источников

Источник	Критерий хи-квадрат
rand() от UNIX	99,9 % для 500 000 образцов (плохо)
Генератор UNIX, улучшенный Park & Miller	97,53 % для 500 000 образцов (чуть лучше)
HotBits: случайные числа на основе радиоактивного полураспада	40,98 % для 500 000 образцов (наилучший результат)

Таблица ясно показывает, что rand() от UNIX не следует доверять генерацию случайных чисел. Если требуется получить большое количество действительно случайных чисел (например, для генерации ключей шифрования), используйте квантовый источник, такой как HotBits. В общем, цель этого раздела заключается в том, чтобы получить первоначальное представление о предмете с помощью простой квантовой схемы для генерации случайных чисел. В следующем разделе мы перейдем на другой уровень, познакомившись с причудливым протоколом квантовой передачи данных под названием «сверхплотное кодирование».

Сверхплотное кодирование

Сверхплотное кодирование (super dense coding, SDC) — это протокол передачи данных, который демонстрирует замечательные возможности квантовой системы по обработке информации. Формально SDC представляет собой простую процедуру передачи двух классических битов информации другой стороне с помощью одного кубита. Этот протокол проиллюстрирован на рис. 5.5.

 

Рис. 5.5. Протокол сверхплотного кодирования

1. Процесс начинается с того, что третья сторона (Чарли) генерирует так называемую пару кубитов в состоянии Белла. Чарли начинает с двух кубитов в базисном состоянии , применяя вентиль Адамара к первому кубиту, чтобы создать суперпозицию. Затем задействует вентиль CNOT, используя первый кубит в качестве управляющего (точка), а второй — в качестве управляемого (+). Это дает состояния, приведенные в табл. 5.2.

Таблица 5.2. Пара кубитов в состоянии Белла

Вентиль	Результирующее состояние	Подробности
H		Когда вентиль Адамара применяется к первому кубиту, он переходит в состояние суперпозиции. Таким образом, мы получаем состояние 00 + 10, где второй кубит остается как 0. Обратите внимание на то, что в матрице Адамара для простоты был опущен квадратный корень из 2
CNOT		Вентиль CNOT запутывает оба кубита. В частности, он инвертирует управляемый кубит (+), если управляющий (.) имеет значение 1. Таким образом мы инвертируем второй кубит, если первый имеет значение 1, получая 00 + 11

2. На втором этапе процесса первый кубит отправляется Алисе, а второй — Бобу. Обратите внимание, что Алиса и Боб могут быть значительно удалены друг от друга. Цель протокола состоит в том, чтобы Алиса отправила два классических бита информации Бобу, используя свой кубит. Но прежде, чем она это сделает, ей нужно применить набор квантовых правил (или вентилей) к своему кубиту в зависимости от двух битов информации, которые она хочет отправить (табл. 5.3).

Таблица 5.3. Правила сверхплотного кодирования

Правила	Результирующие состояния
00: I (единичный вентиль)	I(00 + 11) = 00 + 11
01: X	X(00 + 11) = 10 + 01
10: Z	Z(00 + 11) = 00 – 11
11: ZX	ZX(00 + 11) = 10 – 11

3. Таким образом, если она отправляет 00, то ничего не делает со своим кубитом (применяет единичный вентиль (identity)). Если отправляет 01, то задействует вентиль X (или инверсию битов). Чтобы получить 10, она применяет вентиль Z. Обратите внимание, что последний меняет знак (или фазу) на противоположный, если кубит имеет значение 1. Тогда , . Наконец, если она отправляет 11, то применяет вентили XZ к своему кубиту. Алиса отправляет свой кубит Бобу в качестве последнего шага данного процесса.

4. Боб получает кубит Алисы (нулевой) и использует свой кубит, чтобы запустить в обратном направлении процесс состояния Белла, созданного Чарли. То есть он применяет к первому кубиту вентиль CNOT, затем вентиль Адамара и, наконец, выполняет измерение на двух кубитах, чтобы получить два классических бита, закодированных в кубите Алисы (табл. 5.4).

Таблица 5.4. Состояния кубитов после восстановления

Вентиль	Результирующее состояние	Подробности
CNOT	00 +10 11 + 01 00 – 10 11 – 10	Начинаем с состояний Алисы на втором шаге: 00 + 11 10 + 01 00 – 11 10 – 11 Вентиль CNOT инвертирует второй кубит, если первый имеет значение 1, давая в результате состояния, приведенные во втором столбце
H	00 01 10 –11	Применение вентиля Адамара к первому кубиту в последней строке дает результаты, приведенные во втором столбце. Когда Боб выполняет измерения в вычислительных базисных состояниях, он получает четыре возможных результата с вероятностью 1 каждый. Эти результаты соответствуют тому, что Алиса хотела отправить на втором шаге в первом столбце. Обратите внимание, что последний результат со знаком минус. Тем не менее, поскольку вероятность рассчитывается как квадрат амплитуды, –1 становится 1, что корректно

Сведем все это воедино в схеме, составленной в Composer от IBM Q Expe­rience.

Схема в Composer

На рис. 5.6 показаны схема для сверхплотного кодирования, а также код в Composer.

• Создание схемы начинается с пары кубитов в состоянии Белла, то есть qubit[0] переводится в суперпозицию (с помощью вентиля Адамара) и запутывается с qubit[1] с использованием вентиля CNOT.

• Два следующих вентиля представляют правила кодирования Алисы. Помните, что она применяет единичный вентиль (ничего не выполняется) для кодирования битов 00, X — для 01, Z — для 10 и ZX — для 11. В данном конкретном случае кодированию подвергаются биты 11. Это показано на рис. 5.6 слева от разделительного знака. Учтите, что разделитель станет препятствовать выполнению до тех пор, пока все вентили не будут использованы обоими кубитами.

• Справа от разделительного знака находится протокол Боба. По сути, он выполняет в обратном порядке те же операции, что и Алиса. Он применяет к кубитам сначала вентили CNOT, а затем Адамара. Наконец, на обоих кубитах производится измерение, чтобы извлечь два закодированных классических бита.

 

Рис. 5.6. Схема для сверхплотного кодирования для Q Experience

Запустите предыдущую схему на моделирующем устройстве. Результат должен быть гистограммой с вероятностью, очень близкой к 1 или равной ей для результирующего состояния 11. Он должен соответствовать тому, который будет получен в следующем разделе с использованием сценария Python.

Удаленный запуск с использованием Python

В листинге 5.2 приведен сценарий Python для схемы, изображенной на рис. 5.6.

• В строках 17–19 создаются два кубита и два классических регистра для хранения результатов.

• Затем создается сверхплотная схема с запутанной парой кубитов в состоянии Белла (строки 22–24).

• Алиса кодирует 11, применяя вентили ZX. По своему усмотрению закомментируйте любую из этих строк для кодирования другой пары, а затем убедитесь, что результат соответствует схеме кодирования Алисы (строки 32–35).

• Боб выполняет в обратном порядке операции Алисы и измеряет кубиты (строки 38–41).

• Наконец, схема выполняется на удаленном моделирующем устройстве (ibmq_qasm_simulator) и результаты отображаются в виде графиков, поддерживаемых в Python.

Листинг 5.2. Сценарий Python для сверхплотного кодирования

import sys,time,math

 

# Импорт QISKit

from qiskit import QuantumCircuit, QuantumProgram

 

sys.path.append('../Config/')

import Qconfig

 

# Импорт основных средств вывода графиков

from qiskit.tools.visualization import plot_histogram

 

def main():

    # Первоначальная настройка квантовой программы

    Q_program = QuantumProgram()

    Q_program.register (Qconfig.APItoken, Qconfig.config["url"])

 

    # Создание регистров

    q = Q_program.create_quantum_register("q", 2)

    c = Q_program.create_classical_register("c", 2)

 

    # Квантовая схема для создания запутанного состояния

    superdense = Q_program.create_circuit("superdense", [q], [c])

    superdense.h(q[0])

    superdense.cx(q[0], q[1])

 

    # Для 00 ничего не делать

    # Для 10 применить вентиль X

    # superdense.x(q[0])

    # Для 01 применить вентиль Z

    # superdense.z(q[0])

    # Алиса: Для 11 применить вентили ZX

    superdense.z(q[0])

    superdense.x(q[0])

    superdense.barrier()

 

    # Боб

    superdense.cx(q[0], q[1])

    superdense.h(q[0])

    superdense.measure(q[0], c[0])

    superdense.measure(q[1], c[1])

 

    circuits = ["superdense"]

    print(Q_program.get_qasms(circuits)[0])

 

    backend = "ibmq_qasm_simulator" #квантовое устройство ibmqx2

    shots = 1024 # количество запусков эксперимента

 

    result = Q_program.execute(circuits, backend=backend, shots=shots,

    max_credits=3, timeout=240)

 

    print("Counts:" + str(result.get_counts("superdense")))

 

    plot_histogram(result.get_counts("superdense"))

 

###########################################

# main

if __name__ == '__main__':

    start_time = time.time()

    main()

    print("--- %s seconds ---" % (time.time() - start_time))

Рассмотрим результаты единичного запуска программы из листинга 5.2 в следующем разделе.

Результаты

Вот стандартный вывод для запуска программы из листинга 5.2:

C:\python36-64\python.exe p05-superdensecoding.py

OPENQASM 2.0;

include "qelib1.inc";

qreg q[2];

creg c[2];

h q[0];

cx q[0],q[1];

z q[0];

x q[0];

barrier q[0],q[1];

cx q[0],q[1];

h q[0];

measure q[0] -> c[0];

measure q[1] -> c[1];

 

Counts:{'11': 1024}

--- 167.52969431877136 seconds ---

Сценарий выводит код ассемблера для схемы, а также количество появлений выходного значения: {'11':1024} плюс время выполнения. Количество появлений результата используется для расчета вероятности данного выходного значения путем деления количества появлений результата (1024) на количество запусков (1024). Таким образом, вероятность равна 1 для результата 11, как показано на графике, который выводится на последнем шаге в листинге 5.2 (рис. 5.7). Обратите внимание, что при выполнении на моделирующем устройстве вероятность всегда будет равна 1, то есть count=shot. Но если вы работаете на реальном квантовом устройстве, из-за шума и ошибок, обусловленных окружающей средой, количество появлений результата будет меньше 1024, что даст вероятность меньше 1.

Таким образом, сверхплотное кодирование обеспечивает средства для кодирования двух классических битов в одном кубите. Стоит упомянуть: согласно квантовым вычислениям невозможно сохранить более одного классического бита на кубит, что, кажется, противоречит показанному в этом протоколе. На самом деле никакого противоречия нет. Протокол работает, потому что кубиты Алисы и Боба запутаны через пару в состоянии Белла. Это позволяет отправлять два классических бита в запутанном кубите Алисы. В общем, вы можете хранить максимум два классических бита на кубит при условии, что ваш кубит запутан с другим в паре в состоянии Белла.

В общих чертах этот протокол можно интерпретировать как набор модульных абстракций: модуль генератора пары в состоянии Белла для создания двух запутанных кубитов, за которым следует модуль кодера информации, применяющий правила Алисы для кодирования двух классических битов информации. Наконец, модуль декодера извлекает классические биты из кубитов, предоставляемых парой в состоянии Белла так же, как и модулем кодера (своего рода инструмент квантовой архивации и распаковки архивов (zip/unzip), если хотите). Сверхплотное кодирование дает общую картину квантовой обработки информации и поможет вам понять тему следующего раздела — квантовую телепортацию.

 

Рис. 5.7. Графическое отображение результатов для сверхплотного кодирования

Примечание

Этот простой протокол был разработан в 1992 году физиком Чарльзом Беннетом, почти через 70 лет после открытия квантовой механики. Несмотря на относительную простоту, это отнюдь не стандартная процедура, и, если копнуть глубже, можно обнаружить много интересного.

Квантовая телепортация

Квантовая телепортация — это процедура, тесно связанная со сверхплотным кодированием. Возможно, термин «телепортация» не совсем подходит, так как мы на самом деле ничего не телепортируем, по крайней мере в том смысле, в каком это делается в научной фантастике или «Звездном пути». Формально квантовая телепортация представляет собой процесс, с помощью которого состояние кубита ψ может передаваться из одного местоположения в другое с помощью классической связи и пары в состоянии Белла, обсуждавшейся в предыдущем разделе. Процедура в краткой форме представлена на рис. 5.8.

 

Рис. 5.8. Рабочий цикл квантовой телепортации

1. Алиса и Боб начинают с того, что разделяют пару запутанных кубитов в состоянии Белла. Один из них идет к Алисе, а другой — к Бобу, которые находятся в разных местах на расстоянии друг от друга. Представьте, что пара кубитов в состоянии Белла подготовлена третьей стороной (Чарли).

2. Алиса готовит свой кубит к телепортации в состоянии . Затем измеряет состояния в базисе Белла своего кубита и запутанного кубита из пары в состоянии Белла, предоставленной Чарли. Затем отправляет результат измерения классическим способом Бобу.

3. На данном этапе для кубита Боба имеется апостериорное состояние как функция измерения, выполненного Алисой. Это ключ к пониманию процедуры (помните, что у обоих есть по запутанному кубиту). Таким образом, мы увидим, как Боб, применяя соответствующий квантовый вентиль, может восстановить исходное состояние, созданное Алисой.

Разберемся с этим, рассмотрев апостериорное состояние кубита Боба в момент измерения, выполненного Алисой перед операцией восстановления. Для этого запишем объединенные состояния трех кубитов, участвующих в процессе. Обратите внимание, что для простоты скобочная нотация не приводится.

Таким образом, если мы объединим кубит Алисы, учитывая его состояние , с одним из запутанных кубитов, взятым из пары в состоянии Белла, предоставленной Чарли, то получим:

(α|0〉 + β|1〉) (|00〉 + |11〉) = α|000〉 + α|011〉 + β|100〉 + β|111〉          (5.1)

Теперь нужно записать состояние первых двух кубитов с помощью состояний в базисе Белла.

|B0〉 = (|00〉 + |11〉) / √2 |B1〉 = (|10〉 + |01〉) / √2 |B2〉 = (|00〉 – |11〉) / √2 |B3〉 = (|10〉 – |01〉) / √2

|00〉 = (|B0〉 – |B1〉) / √2 |01〉 = (|B1〉 – |B3〉) / √2 |10〉 = (|B1〉 – |B3〉) / √2 |11〉 = (|B0〉 – |B2〉) / √2

Выражение (5.1) приводится к виду

(α|0〉 + β|1〉) (|00〉 + |11〉) = |B0〉 (α|0〉 + β|1〉) + |B1〉 (α|1〉 + β|0〉) + |B2〉 (α|0〉 – β|1〉) + |B3〉 (–α|1〉 + β|0〉)          (5.2)

Выражение (5.2) показывает состояния трех кубитов после того, как Алиса выполнит свои измерения. Боб знает, как восстановить состояние кубита Алисы ψ, рассмотрев апостериорное состояние кубита в выражении (5.2) (состояния в скобках). Более наглядно это показано в табл. 5.5.

Таблица 5.5. Восстановление информации при квантовой телепортации

Состояние Белла	Апостериорное состояние	Операция восстановления информации на стороне Боба
B0	α0 + β1	ψ
B1	α1 + β0	Xψ
B2	α0 – β1	Zψ
B3	–α1 + β0	ZXψ

В целом протокол квантовой телепортации предоставляет средства для восстановления состояния ψ любого кубита путем разделения запутанной пары в состоянии Белла между двумя удаленными сторонами. Отсюда и название «телепортация». Теперь давайте создадим схему для этого протокола, запустим ее на моделирующем устройстве и, наконец, рассмотрим результаты.

Схема в Composer

На рис. 5.9 показаны схема в Composer, а также результаты выполнения (только для моделирующего устройства, на этот раз версии для реального устройства нет) для протокола квантовой телепортации.

• Вентиль слева от разделительного символа (пунктирная линия) представляет пару кубитов в состоянии Белла, подготовленную третьей стороной (Чарли): первый и второй кубиты.

• Алиса готовит свой кубит (0) к заданному состоянию ψ. Фактическое значение ψ не имеет значения, так как оно будет восстановлено Бобом на заключительной стадии процесса. Алиса получает qubit[1] от Чарли, а qubit[2] отправляется к Бобу.

• Алиса выполняет измерение своих кубитов [0, 1] (показано справа от пунк­тирной линии) и классическим способом отправляет результаты Бобу.

• Боб применяет к своему кубиту (2) правила восстановления, упомянутые в предыдущем разделе, в зависимости от результатов, отправленных Алисой. Наконец, после измерения qubit[2] Боб восстанавливает состояние, изначально созданное Алисой. Все это стало возможным благодаря тому, что Алиса и Боб имеют запутанную пару кубитов, которая заставляет все это работать.

 

Рис. 5.9. Схема для квантовой телепортации в Composer

Конечно, результаты выполнения, показанные на рис. 5.9, нужно обработать, чтобы убедиться, что полученное Бобом значение ψ соответствует созданному Алисой. Лучший способ сделать это — воспользоваться сценарием Python. В следующем разделе мы запустим ту же самую схему удаленно и посмотрим на результаты, чтобы убедиться, что протокол работает.

Удаленный запуск с помощью Python

В этом разделе мы используем Python для удаленного запуска протокола квантовой телепортации на моделирующем устройстве. Обратите внимание, что на данный момент квантовую телепортацию нельзя запустить на реальном квантовом устройстве в IBM Q Experience. Это связано с тем, что аппаратное обеспечение не поддерживает вентили физического вращения, необходимые Алисе для создания своего состоя­ния ψ. В связи с этим мы будем применять удаленное моделирующее устройство — локальное моделирующее устройство на Python тоже подойдет. В листинге 5.3 протокол показан в действии. В частности:

• созданы три кубита для совместного использования обеими сторонами, Алисой и Бобом, а также три классических регистра (c0, c1, c2) для хранения результатов Алисы (строки 20–23);

• Чарли подготавливает пару кубитов в состоянии Белла, применяя вентиль Адамара (H), за которым следует контролируемое НЕ (CNOT) на первом и втором кубитах (строки 27–29);

• Алиса подготавливает свое состояние ψ в нулевом кубите, выполняя поворот вокруг оси Y на π/4 радиан (строка 33);

• Алиса теперь запутывает свой кубит(0) с кубитом(1) из пары в состоянии Белла, переданным ей. Затем выполняет измерение на обоих кубитах и сохраняет результаты в нулевом и первом классических регистрах (строки 37–43);

• теперь очередь Боба — он применяет вентили Z или X к своему кубиту (2) в зависимости от результатов, отправленных Алисой. Если значение нулевого классического регистра соответствует 1, то применяет вентиль Z. Если первый классический регистр имеет значение 1, то применяет вентиль X. Затем он измеряет свой кубит и сохраняет результат во втором классическом регистре (строки 50–53);

• программа выполняется на удаленном моделирующем устройстве (ibmq_qasm_simulator), и результаты накапливаются для вывода и проверки (строки 62–84).

Примечание

Код этой программы включен в исходники для данной книги и размещен в файле Workspace\Ch05\p05-teleport.py.

Листинг 5.3. Сценарий Python для квантовой телепортации

import sys,time,math

import numpy as np

 

# Импорт QISKit

from qiskit import QuantumCircuit, QuantumProgram

 

# Конфигурация Q Experience

sys.path.append('../Config/')

import Qconfig

 

# Импорт основных средств вывода графиков

from qiskit.tools.visualization import plot_histogram

 

def main():

    # Первоначальная настройка квантовой программы

    Q_program = QuantumProgram()

    Q_program. register(Qconfig.APItoken, Qconfig.config["url"])

 

    # Создание регистров

    q = Q_program.create_quantum_register('q', 3)

    c0 = Q_program.create_classical_register('c0', 1)

    c1 = Q_program.create_classical_register('c1', 1)

    c2 = Q_program.create_classical_register('c2', 1)

 

    # Квантовая схема для создания разделенного запутанного состояния

    # (пара кубитов в состоянии Белла)

    teleport = Q_program.create_circuit('teleport', [q], [c0,c1,c2])

    teleport.h(q[1])

    teleport.cx(q[1], q[2])

 

    # Алиса подготавливает свое квантовое состояние перед телепортацией

    # psi = a|0> + b|1> где a = cos(theta/2), b = sin (theta/2),

    # theta = pi/4

    teleport.ry(np.pi/4,q[0])

 

    # Алиса применяет вентиль CNOT к двум своим квантовым состояниям,

    # а затем вентиль H, чтобы перепутать их

    teleport.cx(q[0], q[1])

    teleport.h(q[0])

    teleport.barrier()

 

    # Алиса измеряет два своих квантовых состояния:

    teleport.measure(q[0], c0[0])

    teleport.measure(q[1], c1[0])

 

    circuits = ['teleport']

    print(Q_program.get_qasms(circuits)[0])

 

    ##### Боб в зависимости от результата применяет вентили X или Z

    # или оба этих вентиля к своему состоянию

    teleport.z(q[2]).c_if(c0, 1)

    teleport.x(q[2]).c_if(c1, 1)

 

    teleport.measure(q[2], c2[0])

 

    # Вывод кода ассемблера

    circuits = ['teleport']

    print(Q_program.get_qasms(circuits)[0])

 

    # Запуск на моделирующем устройстве

    # (реальные устройства еще не поддерживают эту процедуру)

    #backend = "local_qasm_simulator"

    backend = "ibmq_qasm_simulator"

    shots = 1024 # количество запусков эксперимента

 

    result = Q_program.execute(circuits, backend=backend, shots=shots

        , max_credits=3, timeout=240)

 

    print("Counts:" + str(result.get_counts("teleport")))

 

    # РЕЗУЛЬТАТЫ

    # Измерения Алисы:

    data = result.get_counts('teleport')

    alice = {}

    alice['00'] = data['0 0 0'] + data['1 0 0']

    alice['10'] = data['0 1 0'] + data['1 1 0']

    alice['01'] = data['0 0 1'] + data['1 0 1']

    alice['11'] = data['0 1 1'] + data['1 1 1']

    plot_histogram(alice)

 

    #Боб

    bob = {}

    bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']

    bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']

    plot_histogram(bob)

 

###########################################

# main

if __name__ == '__main__':

    start_time = time.time()

    main()

    print("--- %s seconds ---" % (time.time() - start_time))

Для проверки нужно собрать статистику появления результатов, полученных Алисой и Бобом и возвращаемых моделирующим устройством. Вывести график результатов — лучший способ убедиться в том, что состояние Алисы ψ было восстановлено Бобом. Вот пример того, что возвращает моделирующее устройство:

{'1 0 0': 37, '1 0 1': 45, '1 1 1': 43, '0 1 1': 215, '0 0 1': 200,

'0 0 0': 206, '0 1 0': 230, '1 1 0': 48}

В этой строке в формате JSON слева приведены результаты для трех кубитов в обратном порядке. Например, в первом результате 1 0 0: B (1) A (0) A (0) для Алисы (A) и Боба (B). Справа приведено количество появлений данного результата. Помните, что вероятность этого выходного значения (используется для построения графиков) рассчитывается делением количества его появлений на общее количество запусков (1024). Таким образом:

P (1 0 0) = 37/1024 = 0,036

Гистограммы для результатов Алисы и Боба, полученных при выполнении программы из листинга 5.3, показаны на рис. 5.10.

 

Рис. 5.10. Результирующие вероятности для измерений, выполненных Алисой и Бобом

Что же все это значит? И как мы узнаем, что состояние ψ было восстановлено Бобом? Рассмотрим результаты подробнее.

Результаты

Чтобы интерпретировать результаты, сначала посмотрим, как рассчитываются вероятности по числовым значениям, полученным для листинга 5.3:

{'1 0 0': 37, '1 0 1': 45, '1 1 1': 43, '0 1 1': 215, '0 0 1': 200,

'0 0 0': 206, '0 1 0': 230, '1 1 0': 48}

Используя эти числа, мы можем рассчитать вероятности появления результатов для Алисы и Боба, показанные на рис. 5.10 (табл. 5.6).

Таблица 5.6. Результирующие вероятности для эксперимента по квантовой телепортации

Строка	Алиса	Боб	Резуль­тат	Счетчик появлений результата	Вероятность	Алиса	Суммарная вероятность
0	Алиса(00)	Боб(0)	0 0 0	206	0,201171875	0 0	0,237304688
1	Алиса(01)	Боб(0)	0 0 1	200	0,195312500	1 0	0,239257813
2	Алиса(10)	Боб(0)	0 1 0	230	0,224609375	0 1	0,271484375
3	Алиса(11)	Боб(0)	0 1 1	215	0,209960938	1 1	0,251953125
4	Алиса(00)	Боб(1)	1 0 0	37	0,036132813
5	Алиса(01)	Боб(1)	1 0 1	45	0,043945313	Боб
6	Алиса(10)	Боб(1)	1 1 0	48	0,046875000	0	0,831054688
7	Алиса(11)	Боб(1)	1 1 1	43	0,041992188	1	0,168945313

Как показано в табл. 5.6, для вычисления полной вероятности результата Алисы 00 нужно суммировать вероятности в нулевой и четвертой строках. Таким образом, P(A00) = 0,201 + 0,036 = 0,237. То же самое правило применяется к данным Боба. Например, P(B0) = 0,20 + 0,19 + 0,22 + 0,20 = 0,83 (вероятности в строках с нулевой по третью). Это то, что показано с правой стороны для всех результатов Алисы и Боба. Таким образом, сценарий в листинге 5.3 обрабатывает данные перед построением графиков результатов, приведенных на рис. 5.10. Но что все это означает и как мы узнаем, что Боб восстановил ψ Алисы? Взглянем на полную вероятность, полученную Бобом для его кубита:

Боб
0	0,20 + 0,19 + 0,22 + 0,20 = 0,83
1	0,036 + 0,043 + 0,046 + 0,041 = 0,168

Согласно принципам квантовой механики вероятность ψ определяется по формуле P(ψ) = |ψ|2. Таким образом, плотность вероятности — это квадрат модуля ψ. Теперь вспомним, что Алиса подготовила ψ как

ψ = RY(θ), где .

То есть Алиса применила к своему кубиту поворот на π/4 радиан вокруг оси Y. Чтобы сделать это более наглядным, представим состояние ψ геометрически (рис. 5.11).

 

Рис. 5.11. Полученное в результате суперпозиции состояние для ψ Алисы

Помните, что полученное в результате суперпозиции состояние ψ описывается комплексными коэффициентами α и β как:

.

Вероятность , вероятность .

Но, исходя из рис. 5.11, данные коэффициенты можно представить как α = cos (θ/2) и β = sin (θ/2). Тогда, наконец, если θ = π/4, то:

• = |cos (π/8)|2 = 0,85;

• = |sin (π/8)|2 = 0,14.

Это соответствует результатам Боба, показанным на графике, созданном программой для телепортации из листинга 5.3 (рис. 5.12). Это большой успех!

 

Рис. 5.12. Результаты телепортации для Боба

Вы сделали первый шаг к пониманию замечательных возможностей квантовых систем обработки информации. Мы начали с простой процедуры, где используется источник истинной случайности, свойственной квантовой механике, для генерации случайных чисел. Кроме того, разобрали два странных протокола — сверхплотное кодирование для кодирования классической информации и квантовую телепортацию для восстановления состояния кубита удаленной стороной. Эти протоколы были описаны с применением схем для IBM Q Experience, а также сценариев Python для удаленного выполнения на моделирующем или реальном квантовом устройстве. Чтобы вам было проще понять все происходящее, мы собирали результаты и объясняли их.

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