Обзор и сравнение квантовых программных платформ гейтового уровня

в 14:23, , рубрики: open source, projectq, pyquil, q#, qasm, qdk, qiskit, quil, квантовые алгоритмы, квантовые вычисления, квантовые компьютеры, квантовые технологии, Облачные вычисления, Программирование

Привет! Представляю вашему вниманию перевод статьи "Overview and Comparison of Gate Level Quantum Software Platforms" автора Ryan LaRose.

Квантовые компьютеры доступны для использования в облачной инфраструктуре, но в тоже время недавний бурный рост квантовых программных платформ может быть ошеломляющим для тех, кто будет принимать решение, что использовать. В этой статье предлагается текущая картина быстро развивающегося ландшафта квантовых вычислений путем сравнения четырех программных платформ — Forest (pyQuil), QISKit, ProjectQ и комплекта Quantum Development Kit, — которые позволяют исследователям использовать реальные и моделируемые квантовые устройства. Этот анализ охватывает требования и установку, синтаксис языка на примере программ, поддержку на уровне библиотек и возможности квантового симулятора для каждой платформы. Для платформ с поддержкой квантового компьютера мы сравним аппаратные средства, квантовые ассемблерные языки и квантовые компиляторы. В заключение мы рассмотрим особенности каждого из них и кратко упомянем другие пакеты программного обеспечения для квантовых вычислений.

Содержание

I. Введение
II. Платформы программного обеспечения
    A. pyQuil
    B. QISKit
    C. ProjectQ
    D. Quatum Development Kit
III. Сравнение
    A. Поддержка на уровне библиотек
    B. Квантовое аппаратное оборудование
    C. Квантовые компиляторы
    D. Производительность симулятора
    E. Особенности
IV. Обсуждение и выводы
Список литературы
Приложение A. Другие программные платформы
Приложение B. Тестирование производительности симулятора
Приложение C. Пример программы: Схема телепортации

I. Введение

Квантовые языки программирования были рассмотрены как минимум два десятилетия назад [1-3], но они были в основном теоретическими и без существующего оборудования. Квантовые компьютеры теперь являются реальностью, и существуют квантовые языки программирования, которые позволят любому, у кого есть доступ к Интернету, использовать их. Достаточное множество исследователей как в индустрии, так и в академических кругах, создало небольшие квантовые устройства, которые работают на схемной модели квантовых вычислений. Эти компьютеры небольшие, зашумленные и не такие мощные, как современные классические компьютеры. Но они зарождаются, неуклонно растут и предвещают будущие невообразимо большие вычислительные мощности для задач химии [4, 5], машинного обучения [6, 7], оптимизации [8], финансовой сферы [9] и более [10]. Эти устройства являются испытательным стендом для подготовки следующего поколения квантовых инженеров-программистов для решения существующих в настоящее время классически сложных задач вычислительной техники. Действительно, облачные квантовые вычисления уже использовались для расчета энергии связи дейтрона [11] и тестовых подпрограмм в алгоритмах машинного обучения [12, 13].

В последнее время произошел бурный рост программного обеспечения для квантовых вычислений на широком наборе классических компьютерных языков. Список проектов с открытым исходным кодом, насчитывающий свыше пятидесяти, доступен в [14], а список квантовых компьютерных симуляторов доступен в [15]. Это огромное количество программ, позитивно отражающих рост в области, затрудняет студентам и исследователям принимать решение какой программный пакет использовать, чтобы не потеряться в документации или не быть потрясённым от необходимых начальных знаний.

В этой статье ожидается представить краткий обзор и сравнение основных программных платформ для квантовых вычислений общего назначения на гейтовом уровне. Из длинного списка было выбрано четыре: три, предоставляющие пользователю возможность подключаться к реальным квантовым устройствам — pyQuil от Rigetti [16], QISKit от IBM [17] и ProjectQ от ETH Zurich [18, 19], — и один с аналогичной функциональностью, но без текущей возможности подключения к квантовому компьютеру — Quantum Development Kit от Microsoft [20]. В пользу выбора данных платформ стала возможность подключения к реальному квантовому устройству. Из-за этого и ради лаконичности намеренно опускается ряд респектабельных программ. Некоторые из них упоминаются в Приложении А.

На данный момент главной целью является представление картины ландшафта квантовых вычислений, обусловленными этими четырьмя платформами. В разделе II мы рассмотрим каждую платформу поочередно, обсуждая требования и установку, документацию и учебные пособия, синтаксис языка и квантовое оборудование. В разделе III предлагается подробное сравнение платформ. В него включается: поддержка на уровне библиотек квантовых алгоритмов в III A, квантовая аппаратная поддержка в III B, компиляторы квантовых схем в III C и квантовые компьютерные симуляторы III D. В разделе IV обсуждаются и некоторые субъективные замечания о каждой платформе. Приложение A содержит информацию о других квантовых программных обеспечениях, Приложение B содержит подробную информацию о тестировании симуляторов квантовой схемы, а в Приложении C показан код для схемы квантовой телепортации на каждом из четырех языков для сравнения бок о бок.

II. Платформы программного обеспечения

На Фигуре 1 представлены различные квантовые компьютеры и программные обеспечения, используемые для подключения к устройствам. В настоящее время, четыре программные платформы позволяют подключаться к четырем различным квантовым компьютерам — один от Rigetti, 8-ми кубитный квантовый компьютер, подключиться можно с помощью pyQuil [41]; и три от IBM, с наибольшим доступным количеством в 16 кубит, которые могут быть подключены с помощью QISKit или ProjectQ. Кроме того, IBM предлагает четвертый 20-кубитный квантовый компьютер, но это устройство доступно только членам IBM Q Network [42]: группе компаний, университетов и национальных лабораторий, заинтересованных и инвестирующих в квантовые вычисления. На Фигуре 1 также показаны квантовые компьютеры таких компаний, как Google, IBM и Intel, которые были объявлены, но в настоящее время недоступны для обычных пользователей.

Обзор и сравнение квантовых программных платформ гейтового уровня - 1

Фигура 1. Схематическая диаграмма, показывающая способы подключения персонального компьютера к используемому квантовому компьютеру на гейтовом уровне. Начиная с персонального компьютера (снизу в центре), узлы зеленого цвета показывают программное обеспечение, которое можно установить на персональный компьютер пользователя. Серые узлы показывают, что симуляторы запускаются локально (то есть на компьютере пользователя). Пунктирные линии показывают API / облачные подключения к ресурсам компании, показанным в желтых «облаках». Квантовые симуляторы и используемые квантовые компьютеры, обеспечиваемые этими облачными ресурсами, показаны в синем и золотом соответственно. Красные рамки показывают требования на выбранном способе. Например, чтобы подключиться к Rigetti Forest и использовать квантовый компьютер Agave 8 qubit, необходимо загрузить и установить pyQuil (доступный на MacOS, Windows и Linux), зарегистрироваться на веб-сайте Rigetti для получения ключа API, а затем запросить доступ к устройству через онлайн-форму. Примечания: (i) Квантовая виртуальная машина Rigetti требует повышения прав для более 30 кубитов, (ii) локальные симуляторы зависят от компьютера пользователя, поэтому приведенные числа являются приблизительными, и (iii) в серой рамке показаны квантовые компьютеры, которые были анонсированы, но которые в настоящее время недоступны для обычных пользователей.

Технология квантового оборудования быстро меняется. Весьма вероятно, что к концу года появятся новые компьютеры, и через два-три года этот список может быть полностью устаревшим. Однако, что останется, так это программное обеспечение, используемое для подключения к этой технологии. Было бы очень просто использовать новые квантовые компьютеры, изменив всего несколько строк кода, не изменяя фактически синтаксис, используемый для генерации или запуска квантовой схемы. Например, в QISKit нужно просто изменить имя backend-устройства при выполнении схемы:

execute(quantum_circuit, backend="name", ...)

Листинг 1. Cтрока «name» указывает на backend-устройство для запуска квантовых программ с использованием QISKit. Когда будущие квантовые компьютеры будут выпущены, выполнение на новом оборудовании будет такой же простой, как и изменение имени.

Хотя программное обеспечение также меняется с выходом новой версии [43], это, по большей части, относительно незначительные синтаксические изменения, которые существенно не изменяют функциональность программного обеспечения.

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

Все фрагменты кода и программы, включенные в этот документ, были протестированы и запущены на ноутбуке Dell XPS 13 Developer Edition под управлением Linux Ubuntu 16.04 LTS, полные спецификации которого перечислены в [23]. Хотя все программные пакеты работают во всех трех основных операционных системах, по опыту автора значительно проще установить и использовать программное обеспечение на платформе, на которой она была разработана. В среде Linux Ubuntu при установке этих пакетов программного обеспечения не возникало никаких трудностей и необычных сообщений об ошибках.

pyQuil QISKit ProjectQ QDK
Institution Rigetti IBM ETH Zurich Microsoft
First Release v0.0.2 on Jan 15, 2017 0.1 on March 7, 2017 v0.1.0 on Jan 3, 2017 0.1.1712.901 on Jan 4, 2018 (pre-release)
Current Version v1.9.0 on June 6, 2018 0.5.4 on June 11, 2018 v0.3.6 on Feb 6, 2018 0.2.1802.2202 on Feb 26, 2018 (pre-release)
Open Source?
License Apache-2.0 Apache-2.0 Apache-2.0 MIT
Homepage Home Home Home Home
GitHub Git Git Git Git
Documentation Docs, Tutorials (Grove) Docs, Tutorial Notebooks, Hardware Docs, Example Programs, Paper Docs
OS Mac, Windows, Linux Mac, Windows, Linux Mac, Windows, Linux Mac, Windows, Linux
Requirements Python 3, Anaconda (recommended) Python 3.5+, Jupyter Notebooks (for tutorials), Anaconda 3 (recommended) Python 2 or 3 Visual Studio Code (strongly recommended)
Classical Language Python Python Python Q#
Quantum Language Quil OpenQASM none/hybrid Q#
Quantum Hardware 8 qubits IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits), QS1_1 (20 qubits) no dedicated hardware, can connect to IBM backends none
Simulator ∼20 qubits locally, 26 qubits with most API keys to QVM, 30+ w/private access ∼25 qubits locally, 30 through cloud ∼28 qubits locally 30 qubits locally, 40 through Azure cloud
Features Generate Quil code, example algorithms in Grove, topology-specific compiler, noise capabilities in simulator, community Slack channel Generate QASM code, topology specific compiler, community Slack channel, circuit drawer, ACQUA library Draw circuits, connect to IBM backends, multiple library plug-ins Built-in algorithms, example algorithms

pyQuil

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

Обзор и сравнение квантовых программных платформ гейтового уровня - 2

Фигура 2. Схематическая диаграмма, показывающая топологию (связность) 8-кубитного Agave QPU Rigetti. Qubits отмечены целыми числами 0, 1, ..., 7, а линии, соединяющие кубиты, указывают, что между этими кубитами может быть выполнена двух кубитная операция. Например, мы можем выполнить Controlled-$inline$Z$inline$ над кубитами 0 и 1, но не между 0 и 2. Чтобы выполнить последнее, компилятор Quil преобразует Controlled-$inline$Z$inline$ (0, 2) в операции, которые может выполнить QPU. Эта диаграмма взята из документации pyQuil.

QISKit

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.

Обзор и сравнение квантовых программных платформ гейтового уровня - 3

Фигура 3. Схематическая топология IBMQX5, взятая из [30]. Направленные стрелки показывают возможности запутывания. Например, мы могли бы выполнить операцию (в QASM) $inline$textsf{cx Q1, Q2}$inline$, но не операцию $inline$textsf{cx Q2, Q1}$inline$. Чтобы сделать последнее, компилятор переводит инструкцию в эквивалентные гейты, которые выполняются в топологии и наборе гейтов.

ProjectQ

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++, так как обернутый код может снизить производительность.)

Quantum Development Kit

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.

III. Сравнение

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

A. Поддержка на уровне библиотек

Термин «поддержка на уровне библиотек» используется для обозначения примеров квантовых алгоритмов (в обучающих программах или документации) или конкретной функции для квантового алгоритма (например, $inline$textsf{language.DoQuantumFourierTransform (...)}$inline$). Мы уже затронули некоторые из них в предыдущем разделе. Более подробная таблица, показывающая поддержку на уровне библиотек для четырех программных платформ, показана на Фигуре 4.

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

Как видно из таблицы, pyQuil, QISKit и QDK имеют относительно большую библиотечную поддержку. ProjectQ содержит FermiLib, плагины для FermiLib, а также он совместим с OpenFermion, являющимися проектами с открытым исходным кодом для алгоритмов квантового моделирования. Все примеры, которые работают с этими проектами, естественно, работают с ProjectQ. Microsoft QDK отличается количеством встроенных функций, выполняющих эти алгоритмы автоматически, без необходимости явно программировать квантовую схему. В частности, библиотека QDK предлагает подробную итеративную фазу оценки, важную процедуру во многих алгоритмах, которые могут быть легко реализованы на QDK, не жертвуя адаптацией. QISKit отличается большим количеством учебных материалов по широкому кругу тем от фундаментальных квантовых алгоритмов до поучительных квантовых игр.

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

В этом разделе мы обсудим только pyQuil и QISKit, поскольку это единственные платформы со своим собственным квантовым оборудованием. Кубит является важной характеристикой в квантовых компьютерах, но не менее важна — если не важнее — «качество кубита». Под этим подразумевается время когерентности (как долго кубиты живут до момента разрушения в биты), время на применение гейта, коэффициент ошибки гейта и топологию/связность кубитов. В идеале можно было бы иметь бесконечные время когерентности, нулевое время на применение гейта, нулевой коэффициент ошибок и связанность многие-ко-многим. В следующих параграфах мы опишем некоторые из характеристик IBMQX5 и Agave, двух наибольших общедоступных квантовых компьютеров. Подробную информацию смотрите в онлайн-документации каждой платформы.

a. IBMQX5

IBMQX5 — 16-ти кубитный сверхпроводящий квантовый компьютер со связанностью ближайших соседей (смотрите Фигуру 3). Минимальное время когерентности (T2) составляет $inline$31 pm 5$inline$ микросекунд на 0-ом кубите, а максимум — $inline$89 pm 17$inline$ микросекунд на 15-ом кубите. Однокубитному гейту необходимо 80 наносекунд на исполнение и плюс 10 наносекунд на амортизацию после каждого импульса. Гейтам $inline$textsf{CNOT}$inline$ необходимо примерно два-четыре раза больше, начиная со 170-ти наносекунд для $inline$textsf{cx q[6], q[7]}$inline$ до 348 наносекунд для $inline$textsf{cx q[3], q[14]}$inline$. Качество воспроизведения однокубитового гейта очень хороша с точностью более 99,5% для всех кубитов (точность = 1 — ошибка). Мульти-кубитная точность выше 94,9% для всех пар кубитов в топологии. Самая большая ошибка считывания довольно велика примерно на 12,4% при среднем около 6%. Эти статистические данные были получены из [30].

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

b. Agave

Квантовый компьютер Agave состоит из 8 сверхпроводящих трансмоновых (transmon) кубитов с фиксированной емкостной связью и связностью, показанной на Фигуре 2. Минимальное время когерентности (T2) составляет 9,2 микросекунды на 1-ом кубите, а максимум составляет 15,52 микросекунды на 2-ом кубите. Время реализации на гейт Controlled-$inline$Z$inline$ составляет от 118 до 195 наносекунд. Точность однокубитового гейта составляет в среднем 96,2% (опять же, точность = 1 — ошибка) и минимум 93,2%. Точность мульти-кубитового гейта в среднем составляет 87% для всех пар кубит-кубит в топологии. Ошибки считывания неизвестны. Эти статистические данные можно найти в онлайн-документации или через pyQuil.

Algorithm pyQuil QISKit ProjectQ QDK
Random Number Generator (T) (T) (T) (T)
Teleportation (T) (T) (T) (T)
Swap Test (T)
Deutsch-Jozsa (T) (T) (T)
Grover's Algorithm (T) (T) (T) (B)
Quantum Fourier Transform (T) (T) (B) (B)
Shor's Algorithm (T) (D)
Bernstein Vazirani (T) (T) (T)
Phase Estimation (T) (T) (B)
Optimization/QAOA (T) (T)
Simon's Algorithm (T) (T)
Variational Quantum Eigensolver (T) (T) (P)
Amplitude Amplification (T) (B)
Quantum Walk (T)
Ising Solver (T) (T)
Quantum Gradient Descent (T)
Five Qubit Code (B)
Repetition Code (T)
Steane Code (B)
Draper Adder (T) (D)
Beauregard Adder (T) (D)
Arithmetic (B) (D)
Fermion Transforms (T) (T) (P)
Trotter Simulation (D)
Electronic Structure (FCI, MP2, HF, etc.) (P)
Process Tomography (T) (T) (D)
Meyer-Penny Game (D)
Vaidman Detection Test (T)
Battleships Game (T)
Emoji Game (T)
Counterfeit Coin Game (T)

Фигура 4. Таблица, демонстрирующая поддержку на уровне библиотек для каждой из четырех программных платформ. Под «поддержкой на уровне библиотек» подразумевается учебный материал или программа (T), пример в документации (D), встроенная функция (B) для языка или поддерживаемой подключаемой библиотеки (P).

C. Квантовые компиляторы

Платформы, которые обеспечивают подключение к реальным квантовым устройствам, обязательно должны иметь средство перевода данной схемы в операции, которые компьютер может понять. Этот процесс известен как трансляция или более подробнее трансляция квантовой схемы / квантовая трансляция. Каждый компьютер имеет базовый набор гейтов и определенную связанность — задача компилятора заключается в том, чтобы получить заданную схему и возвратить эквивалентную схему, подчиняющуюся требованиям базиса и требованиям к связанности. В этом разделе мы обсудим только QISKit и Rigetti, поскольку это платформы с реальными квантовыми компьютерами.

Основой IBMQX5 являются $inline$u_1$inline$, $inline$u_2$inline$, $inline$u_3$inline$ и $inline$textsf{CNOT}$inline$, где

Обзор и сравнение квантовых программных платформ гейтового уровня - 4

Заметим, что $inline$ u_1 $inline$ эквивалентно изменению гейта $inline$ R_z(θ) $inline$ до глобальной фазы, а $inline$u_2$inline$ и $inline$u_3$inline$ — последовательность изменений гейтов и импульсов $inline$R_x (pi / 2)$inline$

Обзор и сравнение квантовых программных платформ гейтового уровня - 5

с гейтами поворота, являющимися стандартными.

Обзор и сравнение квантовых программных платформ гейтового уровня - 6

где $inline$X$inline$ и $inline$Z$inline$ — обычные матрицы Паули. На квантовых компьютерах IBM $inline$R_{z}(θ)$inline$ является «виртуальным гейтом», что означает, что физически ничего не происходит с кубитом. Вместо этого, поскольку кубиты естественным образом вращаются вокруг оси $inline$z$inline$, выполнение вращения $inline$z$inline$ просто сводится к изменению часов или кадров внутреннего (классического) программного обеспечения, отслеживающего кубит.

Топология IBMQX5 показана на Фигуре 3. Данная связность определяет, над какими кубитами можно изначально выполнить операцию $inline$textsf{CNOT}$inline$, где матричное представление $inline$textsf{CNOT}$inline$ задается формулой

Обзор и сравнение квантовых программных платформ гейтового уровня - 7

Обратите внимание, что возможно выполнение $inline$textsf{CNOT}$inline$ между любыми кубитами в QISKit, но, когда программа скомпилирована до уровня аппаратного обеспечения, компилятор QISKit преобразует это в последовательность гейтов CNOT, удовлетворяющих связанности. Компилятор QISKit позволяет указать произвольный набор базовых гейтов и топологию, а также предоставить набор параметров, таких как зашумление.

Для 8-ми кубитного процессора Agave от Rigetti базовые блоки $inline$R_x(kpi / 2)$inline$ для $inline$k in mathbb{Z}$inline$, $inline$R_z (θ)$inline$ и Controlled-$inline$Z$inline$. Однокубитовые гейты поворота, как и выше, и два кубита Controlled-$inline$Z$inline$ ($inline$textsf{CZ}$inline$) задаются формулой

Обзор и сравнение квантовых программных платформ гейтового уровня - 8

Топология Agave показана на Фигуре 2. Как и QISKit, компилятор pyQuil также позволяет указать архитектуру набора целевых команд (набор базовых гейтов и компьютерную топологию).

Пример одинаковой квантовой схемы, компилированной обеими платформами, показан на Фигуре 5. Здесь, используя pyQuil, транслируется программа под характеристики Agave, а с QISKit — IBMQX5. Как видно, QISKit создает длиннее схему (т. е. имеет большую глубину), чем pyQuil. Нецелесообразно утверждать, что один из компиляторов является превосходящим из-за этого примера. Схемы на языке, который понимает IBMQX5 естественнее, приведут к более короткой схеме, чем те же на pyQuil, и наоборот. Известно, что любая квантовая схема (унитарная матрица) может быть разложена на последовательность одно- и двух-кубитных гейтов (смотрите, например, [32]), но в целом для этого необходимо значительное количество гейтов. Сейчас значительный интерес представляет собой вопрос [46], заключающийся в поиске оптимального компилятора для заданной топологии.

Обзор и сравнение квантовых программных платформ гейтового уровня - 9

Фигура 5. Пример квантовой схемы (вверху слева), скомпилированной pyQuil для 8-ми кубитного процессора Agave от Rigetti (верхний правый) и той же схемы, скомпилированной QISKit для IBM компьютера IBMQX5 с 16-тью кубитами. Кубиты, используемые в Agave, равны 0, 1 и 2 (смотрите Фигуру 2), а кубиты, используемые в IBMQX5, равны 0, 1 и 2. Обратите внимание, что ни один компилятор не может непосредственно реализовать гейт Адамара $inline$H$inline$, но производит их через последовательность гейтов поворота $inline$R_x$inline$ и $inline$R_z$inline$. Гейт $inline$textsf{CNOT}$inline$ можно реализовать на IBMQX5, но не на Agave — здесь pyQuil должен выразить $inline$textsf{CNOT}$inline$ с помошью гейтов Controlled-$inline$Z$inline$ и вращений. Эти схемы были сделаны с помощью ProjectQ.

D. Производительность симулятора

Не все программные платформы обеспечивают связь с реальными квантовыми компьютерами, но любая целесообразная программа включает в себя симулятор квантовой схемы. Это программа, которая работает на классическом процессоре, который моделирует (т. е. симулирует) процесс изменения квантового компьютера. Как и в случае с квантовым оборудованием, важно рассмотреть не только количество кубитов, которые может обрабатывать симулятор, но и как быстро он может обрабатывать их, в дополнение к другим параметрам, таким как добавление шума для моделирования квантовых компьютеров и т. д. В этом разделе мы оцениним производительность локального симулятора векторного состояния QISKit и локального симулятора, написанного на C++, ProjectQ с использованием программы, указанной в Приложении B. Сначала упомяним о производительности симулятора QVM pyQuil.

a. pyQuil

Симулятор Rigetti, называемый Quantum Virtual Machine (QVM), не запускается на локальном компьютере пользователя, а скорее за счет использования вычислительных ресурсов в облаке. Как уже упоминалось, для этого требуется ключ API. Большинство ключей API дают доступ к 30-ти кубитам изначально, и может быть запрошен доступ на большее количество. Автор может имитировать 16-ти кубитную схему и глубиной 10 в среднем за 2,61 секунды. Размер схемы в 23 кубита и глубиной 10 была промоделирована за 56,33 секунды, но никакие более крупные схемы не могли быть смоделированы, потому что QVM завершает работу после одной минуты вычисления с помощью текущего ключа доступа автора к API. Из-за ограниченного времени и из-за того, что QVM не запускается на локальном компьютере пользователя, мы не проверяем производительность QVM так же, как тестируем симуляторы ProjectQ и QISKit.

QVM содержит сложные и гибкие модели шума для эмуляции процесса работы реального квантового компьютера. Это является ключом к разработке алгоритмов малой глубины на квантовых компьютерах в ближайшем будущем, а также для теоретического оценивания результатов вычислений для конкретного квантового чипа. Пользователи могут определять произвольные модели шума для тестирования программ, в частности определять зашумленные гейты, добавлять шум декогеренции и шум считывания модели. Подробные сведения и полезные примеры программ смотрите в разделе Noise and Quantum Computation документации pyQuil.

b. QISKit

QISKit имеет несколько квантовых симуляторов, доступных в качестве бэкенда: $inline$textsf{local_qasm_simulator}$inline$, $inline$textsf{local_state_vector_simulator}$inline$, $inline$textsf{ibmq_qasm_simulator}$inline$, $inline$textsf{local_unitary_simulator}$inline$ и $inline$textsf{local_clifford_simulator}$inline$. Отличительной особенностью этих симуляторов является принцип моделирования квантовых схем. Унитарный симулятор реализует базовое (унитарное) матричное умножение и резко ограничивается оперативной памятью. В симуляторе векторного состояния не хранится полная унитарная матрица, а загружается только вектор состояния и один/несколько кубитный гейт. Оба метода обсуждаются в [33], а [34-36] содержат подробную информацию о других методах. Подобно рассуждению о $inline$textsf{ClassicalSimulator}$inline$ в ProjectQ, $inline$textsf{local_clifford_simulator}$inline$ способен эффективно имитировать групповых схем (stabilizer circuits), которые не являются универсальными.

Используя локальный унитарный симулятор, схема на 10 кубитов и глубиной 10 моделируется за 23,55 секунды. Добавление еще одного кубита увеличивает время примерно в десять раз — 239,97 секунды, а при 12 кубитах симулятор превышает время ожидания через 1000 секунд (около 17 минут). Этот симулятор быстро достигает длительных времен моделирования и ограничения памяти, поскольку для $inline$n$inline$ кубитов должна храниться в памяти унитарная матрица размера $inline$2^{n} times 2^{n}$inline$.

Cимулятор векторного состояния значительно превосходит унитарный симулятор. Мы можем смоделировать схемы из 25 кубитов всего за три минуты. Все схемы до 20 кубит с глубиной до тридцати моделируются менее чем за пять секунд. Подробные сведения смотрите на Фигурах 6 и 7.

с. ProjectQ

ProjectQ поставляется с высокопроизводительным симулятором на C++, который показал лучшие результаты в нашем частном тестировании. Схема максимального размера, которую мы смогли успешно имитировать, составила 28 кубитов, что заняло чуть меньше десяти минут (569,71 секунды) с глубиной схемы равной 20-ти. Подробности реализации смотрите в [18]. Полную производительность и тестирование смотрите на Фигурах 6 и 7.

Обзор и сравнение квантовых программных платформ гейтового уровня - 10

Фигура 6. Графики характеристик локального симулятора векторного состояния QISKit (сверху) и симулятора ProjectQ на C++ (внизу), показывающего время выполнения в секундах для заданного количества кубитов (горизонтальная ось) и глубины схемы (вертикальная ось). Темно зеленый цвет показывает наименьшее время, а ярко желтый цвет показывает наибольшее время (цветовые шкалы не совпадают для обоих графиков). Подробнее о тестировании смотрите Приложение **B**.

Обзор и сравнение квантовых программных платформ гейтового уровня - 11

Фигура 7. Схема, используемая для тестирования симулятора ProjectQ на C++ и локального симулятора векторного состояния QISKit, продемонстрирована здесь на четырех кубитах. При фактическом тестировании комбинацию из гейта Адамара, гейта $inline$sqrt{X}$inline$, затем последовательность гейтов CNOT, определяемая одним уровнем в схеме. Эта комбинация повторяется до тех пор, пока не будет достигнута желаемая глубина. Это изображение было создано с использованием ProjectQ.

E. Особенности

Хорошей особенностью pyQuil является Grove, расположенный в отдельном репозитории на GitHub, который может быть установлен с учебными пособиями и примерами алгоритмов с использованием pyQuil. Rigetti также создает солидное сообщество пользователей, примером которого является их выделенный канал в Slack для Rigetti Forest. Также полезен компилятор Quil и возможность компиляции для любого заданного набора инструкций архитектуры (топология и базовые гейты). Наконец, pyQuil совместим с OpenFermion [37], с открытым исходным кодом Python для компиляции и анализа квантовых алгоритмов для моделирования фермионных систем, включая квантовую химию.

QISKit также доступен пользователям с опытом работы на языках JavaScript и Swift. Для начинающих язык Python является очень хорошим стартовым языком программирования из-за его легкого и интуитивного синтаксиса. Подобно Grove, QISKit также содержит специальный репозиторий примеров алгоритмов и руководств. Кроме того, библиотека ACQUA в QISKit содержит многочисленные алгоритмы для квантовой химии и искусственного интеллекта. Эта библиотека может быть запущена через графический пользовательский интерфейс или из интерфейса командной строки. IBM не имеет себе равных для создания активного сообщества студентов и исследователей, использующих их платформу. Компания может похвастаться более чем 3 миллионами удаленными запусками облачных квантовых вычислительных ресурсах, используя QISKit, которыми управляют более 80000 зарегистрированных пользователей, и было написано более 60 научных публикаций, написанных с использованием технологии от IBM [31]. QISKit также имеет выделенный канал в Slack с возможностью просмотра задания в очереди, что является полезной функцией для определения того, как долго будет выполняться отправленное задание. Кроме того, новейшая версия QISKit содержит встроенный рисователь схем.

Аналогично, ProjectQ содержит рисователь схем. Добавив всего несколько строк кода в программу, можно создать код на TikZ для создания высококачественных изображений в $inline$TeX$inline$. Все квантовые схемы в этой статье были сделаны с использованием ProjectQ. Локальный симулятор ProjectQ также является отличной особенностью, так как он обладает очень высокой производительностью. Хотя ProjectQ не имеет собственного квантового оборудования, пользователи могут подключаться к квантовому оборудованию от IBM. Кроме того, ProjectQ имеет несколько библиотек, включая OpenFermion, как упоминалось выше.

QDK был доступен исключительно в Windows до тех пор, пока в феврале 2018 года он не получил поддержку в macOS и Linux. Возможность реализации квантовых алгоритмов без явного программирования схемы является приятной особенностью QDK, а также есть много хороших руководств в документации и папке примеров для квантовых алгоритмов. Также примечательно, что Q# обеспечивает функции автоматического генерации для, например, сопряженной или управляемой версии квантовой операции. В более общем смысле QDK выделяет и предлагает важные инструменты для разработки производительного квантового алгоритма, включая тестирование квантовых программ, оценку потребностей в ресурсах, программирование на различных моделях квантовых вычислений, ориентированных на различные аппаратные средства, и обеспечение правильности квантовых программ на стадии компилирования. Эти особенности имеют ключевое значение для перехода к высокоуровневым языкам квантового программирования.

IV. Обсуждение и выводы

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

Для тех, кто еще не определился, предлагаются следующие субъективные рекомендации:

  • Для тех, чья основная цель является использование квантовых компьютеров, QISKit (или ProjectQ) или pyQuil — очевидный выбор.
  • Для тех, кто новичок в квантовых вычислениях, QISKit, pyQuil или QDK — хороший выбор.
  • Для тех, у кого мало опыта в программировании, одна из платформ на Python — хороший выбор.
  • Для тех, кто знаком или предпочитает синтаксис стиля C/C#, QDK — хороший выбор.
  • Для тех, кто хочет разработать, прототип и тестовые алгоритмы, ProjectQ — хороший выбор.
  • Для тех, кто хочет использовать гибридные квантово-классические алгоритмы, pyQuil — отличный выбор для выделенного запланированного использования аппаратного времени.
  • Для тех, кто интересуется непрерывными переменными в квантовом вычислении, смотрите Strawberry Fields в Приложении А.

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

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

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

  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

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 году в Ванкувере, Канада, создает специальные типы адиабатических квантовых компьютеров, известных как квантовые отжиги, которые решают для основного состояния энергии модели Изинга поперечного поля

Обзор и сравнение квантовых программных платформ гейтового уровня - 12

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

Приложение B

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

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

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

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

Обзор и сравнение квантовых программных платформ гейтового уровня - 13

Фигура 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;
    }
}

Автор: rstm-sf

Источник

Поделиться

* - обязательные к заполнению поля