A. pyQuil

pyQuil — это библиотека для языка Python с открытым исходным кодом, разработанная Rigetti для создания, анализа и выполнения квантовых программ. Она построена на основе языка Quil — открытый язык квантовых инструкций (или просто квантовый язык), специально разработанного для ближайших перспективных квантовых компьютеров и основанного на общей модели классической/квантовой памяти [24] (это означает, что для памяти доступны как кубиты, так и классические биты). pyQuil — это одна из основных библиотек, разрабатываемых в Forest, которая является ключевой платформой для всего программного обеспечения Rigetti. Forest также включает Grove и Reference QVM, которые будут описаны далее.

a. Требования и установка

Чтобы установить и использовать pyQuil, требуется Python 2 или 3 версии, хотя настоятельно рекомендуется Python 3, поскольку будущие разрабатываемые функции будут поддерживать только Python 3. Кроме того, дистрибутив Python Anaconda рекомендуется для различных зависимостей модуля Python, хотя это не обязательно.

Самый простой способ установки pyQuil — использовать команду диспетчера пакетов Python. В командной строке Linux Ubuntu вводится

pip install pyquil

для успешной установки программного обеспечения. В качестве альтернативы, если Anaconda установлен, pyQuil можно установить, набрав

conda install −c rigetti pyquil

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

git clone https://github.com/rigetticomputing/pyquil
cd pyquil
pip install −e

Этот последний метод рекомендуется для всех пользователей, которые могут внести свой вклад в pyQuil. Более подробную информацию смотрите в руководстве по вкладам GitHub.

b. Документация и учебные пособия

pyQuil имеет отличную документацию, размещенную в Интернете, с введением в область квантовых вычислений, инструкциями по установке, базовыми программами и гейтовыми операциями, симулятором, известным как квантовая виртуальная машина (QVM), реальный квантовый компьютер и язык Quil с компилятором. Загрузив исходный код pyQuil с GitHub, вы также получите папку с примерами в Jupyter-тетрадях, обычных примеров на Python и программой $inline$textsf{run_quil.py}$inline$, которая может запускать текстовые документы, написанные в Quil, используя квантовую виртуальную машину. Наконец, упоминем Grove, набор квантовых алгоритмов, построенных с использованием pyQuil и среды Rigetti Forest.

c. Синтаксис

Синтаксис pyQuil очень простой и практичный. Основным элементом для записи квантовых схем является программа и может быть импортирована из $inline$textsf{pyquil.quil}$inline$. Гейтовые операции можно найти в $inline$textsf{pyquil.gates}$inline$. Модуль $inline$textsf{api}$inline$ позволяет запускать квантовые схемы на виртуальной машине. Одна из приятных особенностей pyQuil заключается в том, что регистры кубитов и классические регистры не обязательно должны быть определены априори и могут быть выделены в памяти динамически. Кубиты в регистре кубитов упоминаются индексами (0, 1, 2, ...) и аналогично для бит в классическом регистре. Таким образом, схему случайного генератора можно записать следующим образом:

# random number generator circuit in pyQuil
from pyquil.quil import Program
import pyquil.gates as gates
from pyquil import api

qprog = Program()
qprog += [gates.H(0), gates.MEASURE(0, 0)]

qvm = api.QVMConnection()
print(qvm.run(qprog))

Листинг 2. Код pyQuil для генератора случайных чисел.

В первых трех строках импортируется минимум, необходимый для объявления квантовой схемы/программы (строка 2), для выполнения гейтовых операций над кубитами (строка 3) [44] и для выполнения схемы (строка 4). В строке 6 создается квантовая программа, а в строках 7-8 передается ей список инструкций: сначала подействуем гейтом Адамара $inline$H$inline$ над кубитом под индексом 0, затем измеряем этот же кубит в классический бит под индексом 0. В строке 10 устанавливается соединение с QVM, а в 11 запускается и выводится результат нашей схемы. Эта программа печатает стандартный вывод pyQuil в виде списка списков целых чисел: в нашем случае — $inline$textsf{[[0]]}$inline$ или $inline$textsf{[[1]]}$inline$. В общем, количество элементов во внешнем списке — это количество выполненных испытаний. Целочисленные числа во внутренних списках представляют собой окончательные измерения в классическом регистре. Поскольку мы провели только одно испытание (это указано как аргумент в $inline$textsf{api.QVMConnection.run}$inline$, который по умолчанию установлен в единицу), мы получаем только один внутренний список. Поскольку в классическом регистре мы имели только один бит, то мы получаем только одно целое число.

d. Квантовый язык

Quil — это язык квантовых инструкций или просто квантовый язык, который передает команды квантовому компьютеру. Это аналогично ассемблеру на классических компьютерах. Основа синтаксиса Quil — это $inline$textsf{GATE index}$inline$, где $inline$textsf{GATE}$inline$ является квантовым вентилем, который применяется к кубиту, индексированным $inline$textsf{index}$inline$ (0, 1, 2, ...). pyQuil имеет функцию для генерации кода Quil из заданной программы. Например, в вышеупомянутом генераторе квантовых случайных чисел мы могли бы добавить строку:

print(qprog)

в конце для получения кода Quil-схемы, который показан ниже:

H 0
MEASURE 0 [0]

Листинг 3. Код Quil для генератора случайных чисел.

Возможно, если кто-то станет разбираться в Quil, написать квантовые схемы в текстовом редакторе на языке Quil, а затем выполнить схему на QVM с помощью программы $inline$textsf{run_quil.py}$inline$. Можно также модифицировать $inline$textsf{run_quil.py}$inline$, чтобы запустить схему на QPU. Заметим, что компилятор pyQuil (также называемый компилятором Quil в документации) преобразует заданную схему в код Quil, который может понять реальный квантовый компьютер. Мы обсудим это подробнее в разделе III C.

f. Квантовое аппаратное оборудование

Rigetti имеет квантовый процессор, который может использоваться теми, кто запросил доступ. Чтобы запросить доступ, вы должны посетить веб-сайт Rigetti и указать полное имя, адрес электронной почты, название организации и описание основания для доступа к QPU. Как только это будет сделано, представитель компании обратится по электронной почте, чтобы запланировать время, чтобы предоставить пользователю доступ к QPU. Преимущество этого процесса планирования в отличие от системы очередей QISKit, которая будет обсуждаться далее, заключается в том, что многие задания могут выполняться в распределенном временном интервале с детерминированными временем выполнения, что является ключевым для вариационных и гибридных алгоритмов. Эти типы алгоритмов отправляют данные в обратном и прямом направлении между классическими и квантовыми компьютерами — необходимость ждать очереди делает этот процесс значительно дольше. Недостатком (возможно) является то, что задания не могут выполняться в любое время, когда доступен QPU и необходимо указать, и согласиться на конкретное время.

По опыту автора сотрудники готовы помочь, и процесс, как правило, успешен. Актуальное устройство, топология которого показана на Фигуре 2, состоит из 8 кубит со связанностью ближайшего соседа. Мы рассмотрим этот компьютер более подробно в разделе III B.

g. Симулятор

Квантовая виртуальная машина (QVM) является основной утилитой, используемой для выполнения квантовых схем. Это программа, написанная для запуска на классическом процессоре, получает код Quil и моделирует развитие процесса на реальном квантовом компьютере. Чтобы подключиться к QVM, необходимо бесплатно зарегистрировать ключ API на https://www.rigetti.com/forest, указав имя и адрес электронной почты. Затем придёт электронное письмо, содержащее ключ API и идентификатор пользователя, который должен быть настроен при запуске:

pyquil−config−setup

в командной строке (после установки pyQuil, конечно). Затем появится запрос на ввод ключей из электронной почты.

Согласно документации, большинство ключей API предоставляют доступ к QVM до 30 кубит, и можно запросить доступ к большему количеству кубит. Ключ API автора дает доступ к 26 кубитам (обновления не запрашивались).

Кроме того, библиотека Forest содержит локальный симулятор, написанный на Python и с открытым исходным кодом, называемый как Reference QVM. Он не такой производительный, как QVM, но пользователи могут запускать схемы с количеством кубитов, ограниченными количеством памяти на локальных машинах. Как правило, схемы с количеством кубит меньше 20-ти возможно запустить на широком кругу оборудовании. Reference QVM должен устанавливаться отдельно, что может быть сделано с помощью $inline$textsf{pip}$inline$:

pip install referenceqvm

Чтобы использовать Reference QVM вместо QVM, просто импортируйте $inline$textsf{api}$inline$ из $inline$textsf{referenceqvm}$inline$ вместо pyQuil:

import referenceapi.api as api

B. QISKit

Quantum Information Software Kit, или QISKit, представляет собой комплект разработчика программного обеспечения (SDK) с открытым исходным кодом для работы с квантовым языком OpenQASM и квантовыми процессорами в платформе IBM Q. Он доступен для языков Python, JavaScript и Swift, но здесь мы обсуждаем только версию Python.

a. Требования и установка

QISKit доступен в MacOS, Windows и Linux. Для установки QISKit требуется Python 3.5+. Дополнительные полезные, но не обязательные компоненты — это Jupyter Notebooks для учебных пособий и дистрибутив Python Anaconda 3, в которым присутствуют все необходимые зависимости.

Самый простой способ установить QISKit — это использовать менеджер пакетов pip для Python. В командной строке, для установки программного обеспечение, введем:

pip install qiskit

Обратите внимание, что $inline$textsf{pip}$inline$ автоматически обрабатывает все зависимости и всегда будет устанавливать последнюю версию. Пользователи, которые могут быть заинтересованы внести вклад в QISKit, могут установить исходный код, введя в командной строке следующее, предполагается, что git установлен:

git clone https://github.com/QISKit/qiskit−core
cd qiskit−core
python −m pip install −e 

Для получения информации о вкладах смотрите в онлайн-документации руководства по вкладам на GitHub.

b. Документация и учебные материалы

Документацию QISKit можно найти в Интернете по адресу https://qiskit.org/documentation/. В нем содержатся инструкции по установке и настройке, примеры программ и подключение к реальным квантовым устройствам, организация проекта, обзор QISKit и документация для разработчика. Базовая информация о квантовых вычислениях также может быть найдена для пользователей, которые являются новичками в этой области. Очень хороший ресурс — это ссылка на SDK, где пользователи могут найти информацию о документации по исходному коду.

QISKit также содержит большое количество учебных пособий в отдельном репозитории GitHub (аналогично pyQuil и Grove). К ним относятся запутанные состояния; стандартные алгоритмы, такие как Дойча-Йожа, алгоритм Гровера, оценка фазы и квантовое преобразование Фурье; также более сложные алгоритмы, такие как решение квантовой вариационной задачи на собственные значения и приложение к фермионным гамильтонианам; и даже некоторые забавные игры, такие как квантовый «морской бой». Кроме того, библиотека ACQUA (Algorithms and Circuits for QUantum Applications) содержит многопрофильные алгоритмы для химии и искусственного интеллекта с многочисленными примерами.

Существует также очень подробная документация для каждого из четырех квантовых бэкендов, содержащих информацию о связности, времени когерентности и времени применения гейта. Наконец, упомянем веб-сайт IBM Q experience и руководства пользователя. Веб-сайт содержит графический интерфейс для квантовой схемы, в котором пользователи могут перетаскивать гейты на схему, что полезно для изучения квантовых схем. Руководства пользователя содержат больше инструкций по квантовым вычислениям и языку QISKit.

c. Синтаксис

На синтаксис QISKit можно посмотреть в следующей примерной программе. Здесь, в отличие от pyQuil, нужно явно выделить квантовые и классические регистры. Ниже показана программа для схемы случайных чисел в QISKit:

# random number generator circuit in QISKit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
qcircuit = QuantumCircuit(qreg , creg)

qcircuit.h(qreg[0])
qcircuit.measure(qreg[0], creg[0])

result = execute(qcircuit, ’local qasm simulator’).result()
print(result.get_counts())

Листинг 4. Код QISKit для генератора случайных чисел.

В строке 2 импортируются инструменты для создания квантовых и классических регистров, квантовой схемы и функции для выполнения этой схемы. Затем мы создаем квантовый регистр с одним кубитом (строка 4), классический регистр с одним битом (строка 5) и квантовую схему с обоими этими регистрами (строка 6). Теперь, когда схема создана, мы начинаем подавать инструкции: в строке 8 применяем гейт Адамара к нулевому кубиту в нашем квантовом регистре (который является единственным кубитом в квантовом регистре); в строке 9 измеряем этот кубит в классический бит, индексированный нулем в нашем классическом регистре (который является единственным в классическом регистре) [45]. Теперь, когда квантовая схема построена, выполним ее в строке 11 и распечатаем результат в строке 12. Посредством вывода $inline$textsf{result.get_counts()}$inline$ мы получаем «подсчеты» схемы, то есть словарь выходных данных и сколько раз получали каждый результат. Для нашего случая единственными возможными выходами являются 0 или 1, а пример вывода вышеуказанной программы — $inline$textsf{{'0': 532, '1': 492}}$inline$, что указывает на то, что мы получили 532 экземпляра 0 и 492 экземпляра 1. (По умолчанию количество циклов для запуска схемы, называемое $inline$textsf{shots}$inline$ в QISKit, равно 1024.)

d. Квантовый язык

OpenQASM (открытый язык квантового ассемблера [25], который мы можем назвать просто QASM) — это квантовый язык, который предоставляет инструкцию для реальных квантовых устройств, аналогичных ассемблеру на классических компьютерах. Основой синтаксиса QASM является $inline$textsf{gate qubit}$inline$, где $inline$textsf{gate}$inline$ задает операцию квантового вентиля, а $inline$textsf{qubit}$inline$ — кубит. QISKit имеет функцию для генерации кода QASM из схемы. В приведенном выше примере схемы случайных чисел мы могли бы добавить строку.

print(qcircuit.qasm())

в конце для получения кода QASM для схемы, показанной ниже:

OPENQASM 2.0;
include ”qelib1.inc”;
qreg q0[1];
creg c0[1];
h q0[0];
measure q0[0] −> c0[0];

Листинг 5. Код OpenQASM для генератора случайных чисел.

Первые две строки включены в каждый файл QASM. Строка 3 (4) создает квантовый (классический) регистр, а строки 5 и 6 дают инструкции для схемы. В OpenQASM можно написать небольшие схемы, подобные этим, но для более крупных схем лучше использовать инструменты в QISKit для свободного и эффективного программирования квантовых компьютеров.

e. Квантовое аппаратное оборудование

Существует огромное количество документации для квантовых бэкендов, поддерживаемых QISKit. Эти устройства включают в себя IBMQX2 (5 кубитов), IBMQX4 (5 кубитов), IBMQX5 (16 кубитов) и QS1_1 (20 кубит, доступным только членами IBM Q Network). Документация для каждого доступна на GitHub. Мы подробно рассмотрим IBMQX5 в разделе III B, топология которого показана на Фигуре 3.

f. Симулятор

IBM включает в себя несколько симуляторов квантовых схем, которые запускаются локально или на облачно вычислительных ресурсах. Эти симуляторы содержат в себе локальный унитарный симулятор, который использует всю унитарную матрицу схемы и практически ограничен до около 12 кубитов, и симулятор векторного состояния, который лучше всего работает локально и может имитировать схемы до 25 кубит. На данный момент просто цитируется число кубитов, тем не менее рассматрии производительность симулятора векторного состояния и сравнивая его с другими симуляторами в разделе III D.

C. ProjectQ

ProjectQ — это программная среда с открытым исходным кодом для квантовых вычислений с возможностью подключения к квантовым бэкендам IBM, высокопроизводительным квантовым компьютерным симулятором и несколькими библиотечными плагинами. Первый релиз ProjectQ был разработан Thomas Häner и Damien S. Steiger в группе Matthias Troyer в ETH Zurich, и с тех пор он набрал больше участников.

a. Требования и установка

Для установки ProjectQ требуется текущая версия Python (2.7 или 3.4+). Документация содержит подробную информацию об установке для каждой операционной системы. В нашей среде рекомендуется установка через $inline$textsf{pip}$inline$:

python −m pip install −−user projectq

для успешной установки программного обеспечения (как пользователя). Для установки из исходного кода мы можем набрать следующее в командной строке:

git clone https://github.com/ProjectQ−Framework/ProjectQ
cd projectq
python −m pip install −−user

Как и в предыдущих программах, этот метод рекомендуется для пользователей, которые хотят внести свой вклад в исходный код. Инструкции по этому поводу смотрите в руководстве по вкладам на странице ProjectQ GitHub.

b. Документация и учебные материалы

ProjectQ имеет очень хорошую документацию по установке. Однако выделим, что оставшаяся часть документации немного скудна. В онлайн-учебном пособии представлены инструкции по базовому синтаксису и примерам квантовых программ (случайные числа, телепортация и алгоритм разложения Шора). Остальная часть — это документация/ссылка на код с информацией о структуре кода и каждом дополнительном модуле, включая функции и классы. Документы [18, 19] являются хорошими ссылками и источниками, но более вероятно, что онлайн-документация будет более актуальной.

c. Синтаксис

Синтаксис ProjectQ прост и практичен, хотя для этого нужно привыкнуть. Для ProjectQ нет языка квантового ассемблера (поскольку нет квантового бэкенда ProjectQ), но используется классический язык — своего рода гибридный классический/квантовый язык. Чтобы разъяснить, пример программы для создания случайного бита показан ниже:

# random number generator circuit in ProjectQ
from projectq import MainEngine
import projectq.ops as ops

eng = MainEngine()
qbits = eng.allocate_qureg(1)
    ops.H | qbits[0]
ops.Measure | qbits[0]
    eng.flush()
print(int(qbits[0]))

Листинг 6. Код ProjectQ для генератора случайных чисел.

В строке 2 импортируется необходимый модуль для создания квантовой схемы, а в строке 3 импортируются операции с гейтом. В строке 5 выделяется память и создаем движок (engine) $inline$textsf{MainEngine}$inline$, а в строке 6 мы выделяем один кубитный регистр. В строках 8 и 9 приводятся инструкции схемы: сначала действуем гейтом Адамара на кубит в регистре с индексом 0, затем измеряем этот кубит. Здесь «квантовый синтаксис» появляется на классически написанном языке. Общая формулировка — $inline$textsf{operation | qubit}$inline$ с вертикальной линией между двумя похожими на обозначения Дирака, $inline$H|0>$inline$, например. Затем мы сбрасываем движок, отправляя его на бэкэнд и обеспечивая его оценку/имитацию. В отличие от pyQuil и QISKit, в ProjectQ при измерении не указывается классический регистр. Вместо этого, когда мы измеряем $inline$textsf{qbits[0]}$inline$ в строке 9, мы получаем его значение, преобразовывая его в $inline$textsf{int}$inline$, когда выводим его в строке 12.

d. Квантовый язык

Как уже упоминалось, ProjectQ не имеет собственного специализированного квантового языка. Если вы используете ProjectQ совместно с бэкендом от IBM, код в конечном итоге будет преобразован в OpenQASM: язык квантового ассемблера IBM.

e. Квантовое аппаратное оборудование

ProjectQ не имеет собственного специализированного квантового компьютера. Тем не менее, каждый может использовать квантовые ресурсы IBM при использовании ProjectQ.

f. Симулятор

ProjectQ предоставляется с быстродействующим симулятором, написанным на C++, который будет установлен по умолчанию, если не возникнет ошибка, иначе будет установлен более медленный симулятор на Python. Кроме того, ProjectQ включает в себя $inline$textsf{ClassicalSimulator}$inline$ для эффективного моделирования групповых схем (stabilizer circuits), т. е. схем, которые состоят из гейтов нормализатора группы Паули, которые могут быть получены из гейта Адамара, CNOT и фазового гейта [26]. Этот симулятор способен обрабатывать тысячи кубитов, чтобы проверить, например, схемы сумматора гейта Тоффоли, для конкретных данных. Однако групповые схемы не являются универсальными, поэтому наш тест и тестирование фокусируется на $inline$textsf{C++ Simulator}$inline$.

$inline$textsf{C++ Simulator}$inline$ ProjectQ технически сложный и быстродействующий. На компьютере автора [23]() (отметим, что максимальное количество кубитов ограничено локальной памятью пользователя), он может обрабатывать схемы с 26 кубитами и глубиной 5 в минуту, а схемы с 28 кубитами и глубиной 20 — чуть меньше десяти минут. Полную информацию смотрите в разделе [III D]() и на Фигуре 6.

h. ProjectQ в других платформах

ProjectQ является хорошо проверенным, надежным кодом и используется для других платформ, упомянутых в этой статье. В частности, pyQuil содержит код ProjectQ [27], а ядра симулятора Microsoft QDK разработаны Thomas Häner и Damian Steiger из ETH Zurich [28], оригинальными авторами проекта. (Обратите внимание, что это не обязательно означает, что симулятор QDK достигает производительности симулятора ProjectQ C++, так как обернутый код может снизить производительность.)

D. Quantum Development Kit

В отличие от технологии сверхпроводящих кубитов Rigetti и IBM, Microsoft делает ставку на топологические кубиты на основе майорановских фермионов. Эти частицы были недавно обнаружены [29] и обеспечивают длительное время когерентности и другие требуемые свойства, но функционального квантового компьютера, использующего топологические кубиты, в настоящее время не существует. Таким образом, у Microsoft в настоящее время нет устройства, с которым пользователи могут подключаться через комплект Quantum Development Kit (QDK), самую молодую из четырех платформ, представленных в этой статье. Несмотря на это, QDK имеет новый «квантово-ориентированный» язык под названием Q#, который имеет высокую степень интеграции с Visual Studio и Visual Studio Code и может локально имитировать квантовые схемы до 30 кубитов. Это предварительное программное обеспечение было впервые дебютировано в январе 2018 года и, несмотря на все это находится в альфа-тестировании, с доступностью на MacOS, Windows и Linux.

a. Требования и установка

Несмотря на то, что в документации Visual Studio Code указана как дополнительная, установка настоятельно рекомендуется для всех платформ. (В этой статье мы используем только VS Code, но Visual Studio также является особой средой. Мы по-прежнему платформенно-независимо относимся к тому, что лучше, и нам предпочтительно использовать VS Code.) Как только это будет сделано, текущую версию QDK можно установить, введя следующее в командной строке Bash:

dotnet new −i "Microsoft.Quantum.ProjectTemplates::0.2 −*"

Чтобы получить примеры кода и библиотеки QDK из репозитория GitHub (настоятельно рекомендуется всем и особенно тем, кто может внести свой вклад в QDK), можно дополнительно набрать:

git clone https://github.com/Microsoft/Quantum.git
cd Quantum
code

b. Документация и учебные материалы

Вышеприведенные примеры кода и библиотеки — отличный способ изучить язык Q#, а онлайн-документация содержит информацию о проверке успешной установки, запуске первой квантовой программы, квантового симулятора, стандартных библиотек Q# и языка программирования. Эта документация подробна и содержит большой объем информации; читатель может сам решить, является ли это плюсом или минусом.

c. Синтаксис

Синтаксис Q# совершенно отличается от предыдущих трех языков. Он очень похож на C#: более подробный, чем Python, и может иметь более крутую кривую обучения для тех, кто не знаком с C#. Ниже показана такая же схема генераторов случайных чисел, что и для всех языков:

// random number generator circuit in QDK
operation random (count: Int, initial: Result) : (Int, Int)
{
    body
    {
        mutable numOnes = 0;
        using ( qubits = Qubit[1])
        {
            for (test in 1..count)
            {
                Set(initial, qubits[0]);
                H(qubits[0]);
                let res = M(qubits[0]);
                 // count the number of ones
                if (res == One)
                {
                   set numOnes = numOnes + 1;
                }
            }
            Set(Zero, qubits[0]);
        }
        // return statistics
        return (count − numOnes, numOnes);
    }
}

Листинг 7. Код Q# для генератора случайных чисел.

Использование скобок и ключевых слов может, возможно, сделать этот язык немного более сложным для новичков при изучении/чтении, но по своей сути код выполняет ту же схему, что и предыдущие три примера. Для краткости мы опустим анализ кода. Заметим, однако, что это один из трех файлов, необходимых для запуска этого кода. Вышеуказанное — это $inline$textsf{.qs}$inline$ файл для языка Q#, и нам также необходим файл $inline$textsf{Driver.cs}$inline$ для запуска $inline$textsf{.qs}$inline$ кода, а также $inline$textsf{.csproj}$inline$, содержащий метаданные. В общем, этот пример насчитывает около 65 строк кода. Поскольку этот пример можно найти в онлайн-документации, мы эти программы добавляются, но тем не менее заинтересованный читатель направляется к учебному пособию «Quickstart» в документации.

Автор хотел бы отметить, что QDK стремится к высокоуровневому языку, который абстрагируется от аппаратного обеспечения и облегчает пользователям программирование квантовых компьютеров. Как аналог, при составлении сложения на классическом компьютере не выделяется схема сумматора — это выполняется в высокоуровневой структуре $inline$(a + b)$inline$, и программное обеспечение компилирует это на аппаратный уровень. Поскольку QDK ориентирован на разработку таких стандартов, что измерение легкости написания кода на основе простых примеров, таких как генератор случайных чисел и схема телепортации (смотрите Приложение C, может не оправдать общий синтаксис языка и возможности платформы, но тем не менее эти программы, имеющие определенную степень согласованности в нашем анализе, добавлены.

d. Квантовый язык / аппаратное обеспечение

Как уже упоминалось, QDK не имеет возможности подключаться к реальному квантовому компьютеру и не имеет специального языка квантового ассемблера. Однако язык Q# можно считать гибридным классическим/квантовым языком.

e. Симулятор

На локальном компьютере пользователя набор QDK включает в себя квантовый симулятор, который может запускать схемы до 30 кубитов. Как упоминалось выше, ядро для симулятора QDK было написано разработчиками ProjectQ, поэтому можно ожидать, что производительность будет аналогична производительности симулятора ProjectQ. (Смотрите Раздел III D.) Благодаря платной подписке на облако Azure можно получить доступ к высокопроизводительным вычислениям, которые позволяют моделировать более 40 кубитов. Однако в документации QDK в настоящее время мало инструкций о том, как это сделать.

Кроме того, QDK обеспечивает симулятор диагностики (trace simulator), которая очень эффективен для отладки классического кода, который является частью квантовой программы, а также оценки ресурсов, необходимых для запуска данного экземпляра квантовой программы на квантовом компьютере. Симулятор диагностики позволяет использовать различные показатели производительности для квантовых алгоритмов, содержащих тысячи кубитов. Схемы такого размера возможны, потому что симулятор диагностики выполняет квантовую программу без фактического моделирования состояния квантового компьютера. Рассматривается широкий спектр оценки ресурсов, включая подсчеты для гейта Клиффорда, Т-образного гейта, произвольно заданных квантовых операций и т. д. Он также позволяет определять глубину схемы на основе заданных длительностей гейтов. Полную информацию о симуляторе диагностики можно найти в онлайн-документации QDK.

Список литературы

1. Bernhard Ömer, A procedural formalism for quantum computing, Master’s thesis, Department of Theoretical Physics, Technical University of Vienna, 1998.
2. S. Bettelli, L. Serafini, T. Calarco, Toward an architecture for quantum programming, Eur. Phys. J. D, Vol. 25, No. 2, pp. 181-200 (2003).
3. Peter Selinger (2004), A brief survey of quantum programming languages, in: Kameyama Y., Stuckey P.J. (eds) Functional and Logic Programming. FLOPS 2004. Lecture Notes in Computer Science, vol 2998. Springer, Berlin, Heidelberg.
4. Benjamin P. Lanyon, James D. Whitfield, Geoff G. Gillet, Michael E. Goggin, Marcelo P. Almeida, Ivan Kassal, Jacob D. Biamonte, Masoud Mohseni, Ben J. Powell, Marco Barbieri, Alaґn Aspuru-Guzik, Andrew G. White, Towards quantum chemistry on a quantum computer, Nature Chemistry 2, pages 106-111 (2010), doi:10.1038/nchem.483.
5. Jonathan Olson, Yudong Cao, Jonathan Romero, Peter Johnson, Pierre-Luc Dallaire-Demers, Nicolas Sawaya, Prineha Narang, Ian Kivlichan, Michael Wasielewski, Alaґn Aspuru-Guzik, Quantum information and computation for chemistry, NSF Workshop Report, 2017.
6. Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, Seth Lloyd, Quantum machine learning, Nature volume 549, pages 195-202 (14 September 2017).
7. Seth Lloyd, Masoud Mohseni, Patrick Rebentrost, Quantum principal component analysis, Nature Physics volume 10, pages 631-633 (2014).
8. Vadim N. Smelyanskiy, Davide Venturelli, Alejandro Perdomo-Ortiz, Sergey Knysh, and Mark I. Dykman, Quantum annealing via environment-mediated quantum diffusion, Phys. Rev. Lett. 118, 066802, 2017.
9. Patrick Rebentrost, Brajesh Gupt, Thomas R. Bromley, Quantum computational finance: Monte Carlo pricing of financial derivatives, arXiv preprint (arXiv:1805.00109v1), 2018.
10. I. M. Georgescu, S. Ashhab, Franco Nori, Quantum simulation, Rev. Mod. Phys. 86, 154 (2014), DOI: 10.1103/RevModPhys.86.153.
11. E. F. Dumitrescu, A. J. McCaskey, G. Hagen, G. R. Jansen, T. D. Morris, T. Papenbrock, R. C. Pooser, D. J. Dean, P. Lougovski, Cloud quantum computing of an atomic nucleus, Phys. Rev. Lett. 120, 210501 (2018), DOI: 10.1103/PhysRevLett.120.210501.
12. Lukasz Cincio, Yigit Subasi, Andrew T. Sornborger, and Patrick J. Coles, Learning the quantum algorithm for state overlap, arXiv preprint (arXiv:1803.04114v1), 2018
13. Patrick J. Coles, Stephan Eidenbenz, Scott Pakin, et al., Quantum algorithm implementations for beginners, arXiv preprint (arXiv:1804.03719v1), 2018.
14. Mark Fingerhuth, Open-Source Quantum Software Projects, accessed May 12, 2018.
15. Quantiki: List of QC Simulators, accessed May 12, 2018
16. R. Smith, M. J. Curtis and W. J. Zeng, A practical quantum instruction set architecture, 2016.
17. QISKit, originally authored by Luciano Bello, Jim Challenger, Andrew Cross, Ismael Faro, Jay Gambetta, Juan Gomez, Ali Javadi-Abhari, Paco Martin, Diego Moreda, Jesus Perez, Erick Winston, and Chris Wood, https://github.com/QISKit/qiskit-sdk-py.
18. Damian S. Steiger, Thomas Häner, and Matthias Troyer ProjectQ: An open source software framework for quantum computing, 2016.
19. Thomas Häner, Damian S. Steiger, Krysta M. Svore, and Matthias Troyer A software methodology for compiling quantum programs, 2016.
20. The Quantum Development Kit by Microsoft, homepage: https://www.microsoft.com/en — us/quantum/development-kit, github: https://github.com/Microsoft/Quantum.
21. Michael A. Nielsen and Isaac L. Chuang, Quantum Computation and Quantum Information 10th Anniversary Edition, Cambridge University Press, 2011.
22. Doug Finke, Education, Quantum Computing Report, https://quantumcomputingreport.com/resources/education/, accessed May 26, 2018.
23. All code in this paper was run and tested on a Dell XPS 13 Developer Edition laptop running 64 bit Ubuntu 16.04 LTS with 8 GB RAM and an Intel Core i7-8550U CPU at 1.80 GHz. Programs were run primarily from the command line but the Python developer environment Spyder was also used for Python programs and Visual Studio Code was used for C# (Q#) programs.
24. Forest: An API for quantum computing in the cloud, https://www.rigetti.com/index.php/forest, accessed May 14, 2018.
25. Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta, Open quantum assembly language, 2017.
26. Scott Aaronson, Daniel Gottesman, Improved Simulation of Stabilizer Circuits, Phys. Rev. A 70, 052328, 2004.
27. pyQuil Lisence, github.com/rigetticomputing/pyquil/blob/master/LICENSE#L204, accessed June 7, 2018.
28. Microsoft Quantum Development Kit License, marketplace.visualstudio.com/items/quantum.DevKit/license, accessed June 7, 2018.
29. Hao Zhang, Chun-Xiao Liu, Sasa Gazibegovic, et al. Quantized Majorana conductance, Nature 556, 74-79 (05 April 2018).
30. 16-qubit backend: IBM QX team, “ibmqx5 backend specification V1.1.0,” (2018). Retrieved from https://ibm.biz/qiskit-ibmqx5 and https://quantumexperience.ng.bluemix.net/qx/devices on May 23, 2018.
31. Talia Gershon, Celebrating the IBM Q Experience Community and Their Research, March 8, 2018.
32. M. Reck, A. Zeilinger, H.J. Bernstein, and P. Bertani, Experimental realization of any discrete unitary operator, Physical Review Letters, 73, p. 58, 1994.
33. Ryan LaRose, Distributed memory techniques for classical simulation of quantum circuits, arXiv preprint (arXiv:1801.01037v1), 2018.
34. Thomas Haner, Damian S. Steiger, 0.5 petabyte simulation of a 45-qubit quantum circuit, arXiv preprint (arXiv:1704.01127v2), September 18, 2017.
35. Jianxin Chen, Fang Zhang, Cupjin Huang, Michael Newman, Yaoyun Shi, Classical simulation of intermediate-size quantum circuits, arXiv preprint (arXiv:1805.01450v2), 2018.
36. Alwin Zulehner, Robert Wille, Advanced simulation of quantum computations, arXiv preprint (arXiv:1707.00865v2), November 7, 2017.
37. Jarrod R. McClean, Ian D. Kivlichan, Kevin J. Sung, et al., OpenFermion: The electronic structure package for quantum computers, arXiv:1710.07629, 2017.
38. Nathan Killoran, Josh Izaac, Nicols Quesada, Ville Bergholm, Matthew Amy, Christian Weedbrook, Strawberry Fields: A Software Platform for Photonic Quantum Computing, arXiv preprint (arXiv:1804.03159v1), 2018.
39. IonQ website, https://ionq.co/, accessed June 15, 2018.
40. D-Wave: The quantum computing company, https://www.dwavesys.com/home, accessed June 20, 2018.
41. Вплоть до 4 июня 2018 года у Rigetti был 20-ти кубитный компьютер, который являлся общедоступным для использования. Согласно электронной почте от сотрудников службы поддержки, замена на 8-ми кубитный чип произошла «из-за ухудшения производительности». Неясно, является ли эта замена временной или 20-ти кубитный процессор будет удален навсегда (и, возможно, заменен новым чипом).
42. Текущими членами IBMQ Network являются те, кто был объявлен в декабре 2017 года — JP Morgan Chase, Daimler, Samsung, Honda, Oak Ridge National Lab, — и другие, анонсированные в апреле 2018 года — Zapata Computing, Strangeworks, QxBranch, Quantum Benchmark, QC Ware, Q-CTRL, Cambridge Quantum Computing (CQC), и 1QBit. North Carolina State University является первым американским университетом, который будет членом IBM Q Hub, который также включает в себя University of Oxford и University of Melbourne. Полный и обновленный список смотрите в https://www.research.ibm.com/ibmq/network/.
43. Действительно, все четыре из этих платформ в настоящее время являются альфа- или бета-программным обеспечением. При написании этой статьи были выпущены две новые версии QISKit, а также новая библиотека ACQUA для химии и искусственного интеллекта, и была выпущена новая версия pyQuil.
44. Это обычный синтаксис pyQuil для импорта только используемых гейтов: например, $inline$ textsf{from pyquil.gates import H, MEASURE} $inline$. Автор предпочитает импортировать весь $inline$ textsf{pyquil.gates} $inline$ для операторной прозрачности и для сравнения с другими языками программирования, но обратите внимание, что предпочтительным методом разработчика является первый, который может незначительно помочь ускорить код и держать программы более опрятными.
45. Мы могли бы просто объявить один кубит и один классический бит для этой программы вместо того, чтобы иметь регистр и ссылаться на (ку)биты по индексу. Однако, для более крупных схем обычно проще указывать регистры и ссылаться на (ку)биты по индексу, чем на отдельные названия, поэтому мы придерживаемся этой практики здесь.
46. Конкурс от IBM, завершившийся 31 мая 2018 года, «задача квантового разработчика» заключается в написании лучшего кода компилятора в Python или Cython, которому подают на вход квантовую схему и получают оптимальную схему для данной топологии.

A. Другие программные платформы

Как уже упоминалось в основном тексте, было бы нецелесообразно включать анализ всех программных платформ или компаний с квантовыми вычислениями. Обновленный и текущий список смотрите на странице Players в отчете Quantum Computing Report [22]. Наши выбранные варианты в этой статье во многом определялись возможностью обычных пользователей подключиться к реальным квантовым устройствам и использовать их, а также неизбежными личными факторами, такими как опыт автора. Наше опущение программного обеспечения/компаний не является заявлением об их неработоспособности — здесь кратко упомминаются некоторые.

a. Strawberry Fields

Разработанный стартапом Xanadu, основанным в Торонто, Strawberry Fields представляет собой полноценную библиотеку для Python по проектированию, моделированию и оптимизации квантовых оптических схем [38]. Xanadu разрабатывает фотонные квантовые компьютеры с непрерывными переменными или «qumodes» (в отличие от дискретных переменных кубитов), и, хотя компания еще не объявила о выпуске доступной квантовой микросхемы для обычных пользователей, она может стать доступна в ближайшем будущем. Strawberry Fields имеет встроенные симуляторы с использованием Numpy и TensorFlow, а также язык квантового программирования Blackbird. Есть возможость загрузить исходный код с GitHub, и, например, найти учебные пособия для квантовой телепортации, выборки бозонов и машинного обучения. Кроме того, сайт Xanadu https://www.xanadu.ai/ содержит интерактивную квантовую схему, в которой пользователи могут перетаскивать гейты или выбирать из библиотеки примерные алгоритмы.

b. IonQ

IonQ — новая стартап-компания, находящаяся в College Park штата Мэриленд, и возглавляемая исследователями из Университета Мэриленда и Университета Дьюка. IonQ использует метод захваченных ионов для архитектуры квантовых вычислений, который обладает некоторыми очень подходящими свойствами. Используя ядерный спин $inline$^{171}$inline$Yb в виде кубита, IonQ достигла T2 (декогеренции) равной 15-ти минутам, в то время как более распространено время T2 равной 1 секунде. Кроме того, время релаксации T1 (время релаксации возбуждения) составляет порядка 20 000 лет, а ошибки однокубитового квантового гейта составляют около $inline$10^{-4}$inline$ с использованием рамановских переходов. Для схем малого размера, связанность многие-ко-многим доступна из-за широких диапазонов кулоновских взаимодействий между ионами, и можно «перебросить» кубиты в разные линейные массивы для достижения универсальной связи в больших схемах. Также были продемонстрированы более интересные эффекты, такие как нелокальная телепортация между кубитами посредством излучения фотонов.

Аппаратное обеспечение IonQ в настоящее время недоступно через программный интерфейс для обычных пользователей, но можно связаться с IonQ и запросить доступ. Экспериментаторы запускали различные алгоритмы от машинного обучения до теории игр. Чтобы узнать больше о компании, посетите их веб-сайт [39].

c. D-Wave Systems

D-Wave [40], возможно, является самой старой компанией с квантовыми вычислениями. D-Wave, основанная в 1999 году в Ванкувере, Канада, создает специальные типы адиабатических квантовых компьютеров, известных как квантовые отжиги, которые решают для основного состояния энергии модели Изинга поперечного поля

D-Wave выпустила несколько компьютеров, самый последний из которых — в 2048 кубитов, и имеет широкое программное обеспечение в Matlab, C/C++ и Python для их программирования. Поскольку эти квантовые компьютеры не работают на модели квантовых вычислений с гейтами/схемами, D-Wave не было включено в основную часть текста. Однако исключение D-Wave не дает точной картины текущего ландшафта квантовых вычислений.

B. Тестирование производительности симулятора

Ниже приведен список программ для тестирования производительности локального симулятора ProjectQ на C++. Эти тесты были выполнены на Dell XPS 13 Developer Edition с 64-разрядным Ubuntu 16.04 LTS с 8 ГБ оперативной памяти и процессором Intel Core i7-8550U на частоте 1,80 ГГц.

# ------------------------------------------------------------------------------
# imports
# ------------------------------------------------------------------------------

from projectq import MainEngine
import projectq.ops as ops
from projectq.backends import Simulator
import sys
import time

# ------------------------------------------------------------------------------
# number of qubits and depth
# ------------------------------------------------------------------------------

if len(sys.argv) > 1:
    n = int(sys.argv[1])
else:
    n = 16

if len(sys.argv) > 1:
    depth = int(sys.argv[2])
else:
    depth = 10 

# ------------------------------------------------------------------------------
# engine and qubit register
# ------------------------------------------------------------------------------

eng = MainEngine(backend=Simulator(gate_fusion=True), engine_list=[])
qbits = eng.allocate_qureg(n)

# ------------------------------------------------------------------------------
# circuit
# ------------------------------------------------------------------------------

# timing -- get the start time
start = time.time()

# random circuit
for level in range(depth):
    for q in qbits:
        ops.H | q
        ops.SqrtX | q
        if q != qbits[0]:
            ops.CNOT | (q, qbits[0])

# measure
for q in qbits:
    ops.Measure | q

# flush the engine
eng.flush()

# timing -- get the end time
runtime = time.time() - start

# print out the runtime
print(n, depth, runtime)

Схема, которая была выбрана случайным образом, показана на Фигуре 7. Отметим, что симулятор QISKit был протестирован на идентичной схеме — опустим код для краткости.

C. Пример программы: Схема телепортации

В этом разделе мы продемонстрируем программы для схемы квантовой телепортации на каждом из четырех языков для сравнения бок о бок. Заметим, что показанная программа QDK является одной из трех программ, необходимых для выполнения схемы, как обсуждалось в основной части. Схема телепортации является стандартной для квантовых вычислений и отправляет неизвестное состояние из одного кубита — обычно первый или верхний кубит в схеме, — другому — обычно последний или нижний кубит в схеме. Базовая информация об этом процессе может быть найдена в любом стандартном источнике о квантовых вычислений или квантовой механики. Эта квантовая схема более сложна, чем очень маленькие программы, показанные в основном тексте, и демонстрирует несколько более продвинутые функции каждого языка — например, выполнение условных операций.

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

Фигура 8. Схема телепортации, созданная с помощью $inline$textsf{circuit_drawer}$inline$, добавденный в QISKit v0.5.4.

pyQuil

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# ==============================================================================
# teleport.py
#
# Teleportation circuit in pyQuil.
# ==============================================================================

# ------------------------------------------------------------------------------
# imports
# ------------------------------------------------------------------------------

from pyquil.quil import Program
from pyquil import api
import pyquil.gates as gate

# ------------------------------------------------------------------------------
# program and simulator
# ------------------------------------------------------------------------------

qprog = Program()
qvm = api.QVMConnection()

# ------------------------------------------------------------------------------
# teleportation circuit
# ------------------------------------------------------------------------------

# teleport |1> to qubit three
qprog += gates.X(0)

# main circuit
qprog += [gates.H(1),
          gates.CNOT(1, 2),
          gates.CNOT(0, 1),
          gates.H(0),
          gates.MEASURE(0, 0),
          gates.MEASURE(1, 1)]

# conditional operations
qprog.if_then(0, gates.Z(2))
qprog.if_then(1, gates.X(2))

# measure qubit three
qprog.measure(2, 2)

# ------------------------------------------------------------------------------
# run the circuit and print the results
# ------------------------------------------------------------------------------

print(qvm.run(qprog))

# optionally print the quil code
print(qprog)

QISKit

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# ==============================================================================
# teleport.py
#
# Teleportation circuit in QISKit.
# ==============================================================================

# ------------------------------------------------------------------------------
# imports
# ------------------------------------------------------------------------------

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute

# ------------------------------------------------------------------------------
# registers and quantum circuit
# ------------------------------------------------------------------------------

qreg = QuantumRegister(3)
creg = ClassicalRegister(3)
qcircuit = QuantumCircuit(qreg, creg)

# ------------------------------------------------------------------------------
# do the circuit
# ------------------------------------------------------------------------------

# teleport |1> to qubit three
qcircuit.x(qreg[0])

# main circuit
qcircuit.h(qreg[0])
qcircuit.cx(qreg[1], qreg[2])
qcircuit.cx(qreg[0], qreg[1])
qcircuit.h(qreg[0])
qcircuit.measure(qreg[0], creg[0])
qcircuit.measure(qreg[1], creg[1])

# conditional operations
qcircuit.z(qreg[2]).c_if(creg[0][0], 1)
qcircuit.x(qreg[2]).c_if(creg[1][0], 1)

# measure qubit three
qcircuit.measure(qreg[2], creg[2])

# ------------------------------------------------------------------------------
# run the circuit and print the results
# ------------------------------------------------------------------------------
result = execute(qcircuit, 'local_qasm_simulator').result()
counts = result.get_counts()

print(counts)

# optionally print the qasm code
print(qcircuit.qasm())

# optionally draw the circuit
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(qcircuit)

ProjectQ

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# ==============================================================================
# teleport.py
#
# Teleportation circuit in ProjectQ.
# ==============================================================================

# ------------------------------------------------------------------------------
# imports
# ------------------------------------------------------------------------------
from projectq import MainEngine
from projectq.meta import Control
import projectq.ops as ops

# ------------------------------------------------------------------------------
# engine and qubit register
# ------------------------------------------------------------------------------

# engine
eng = MainEngine()

# allocate qubit register
qbits = eng.allocate_qureg(3)

# ------------------------------------------------------------------------------
# teleportation circuit
# ------------------------------------------------------------------------------

# teleport |1> to qubit three
ops.X | qbits[0]

# main circuit
ops.H | qbits[1]
ops.CNOT | (qbits[1], qbits[2])
ops.CNOT | (qbits[0], qbits[1])
ops.H | qbits[0]
ops.Measure | (qbits[0], qbits[1])

# conditional operations
with Control(eng, qbits[1]):
    ops.X | qbits[2]
with Control(eng, qbits[1]):
    ops.Z | qbits[2]

# measure qubit three
ops.Measure | qbits[2]

# ------------------------------------------------------------------------------
# run the circuit and print the results
# ------------------------------------------------------------------------------

eng.flush()
print("Measured:", int(qbits[2]))

Quantum Developer Kit

// =============================================================================
// teleport.qs
//
// Teleportation circuit in QDK.
// =============================================================================

operation Teleport(msg : Qubit, there : Qubit) : () {
    body {

        using (register = Qubit[1]) {
            // get auxiliary qubit to prepare for teleportation
            let here = register[0];

            // main circuit
            H(here);
            CNOT(here, there);
            CNOT(msg, here);
            H(msg);

            // conditional operations
            if (M(msg) == One)  { Z(there); }
            if (M(here) == One) { X(there); }

            // reset the "here" qubit
            Reset(here);
        }

    }
}

operation TeleportClassicalMessage(message : Bool) : Bool {
    body {
        mutable measurement = false;

        using (register = Qubit[2]) {
            // two qubits
            let msg = register[0];
            let there = register[1];

            // encode message to send
            if (message) { X(msg); }

            // do the teleportation
            Teleport(msg, there);

            // check what message was sent
            if (M(there) == One) { set measurement = true; }

            // reset all qubits
            ResetAll(register);
        }

        return measurement;
    }
}