Главная » Хабрахабр » [Из песочницы] Обзор и сравнение квантовых программных платформ гейтового уровня

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

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

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

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

Квантовые компьютеры теперь являются реальностью, и существуют квантовые языки программирования, которые позволят любому, у кого есть доступ к Интернету, использовать их. Квантовые языки программирования были рассмотрены как минимум два десятилетия назад [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 A, квантовая аппаратная поддержка в III B, компиляторы квантовых схем в III C и квантовые компьютерные симуляторы III D. В разделе III предлагается подробное сравнение платформ. Приложение A содержит информацию о других квантовых программных обеспечениях, Приложение B содержит подробную информацию о тестировании симуляторов квантовой схемы, а в Приложении C показан код для схемы квантовой телепортации на каждом из четырех языков для сравнения бок о бок. В разделе IV обсуждаются и некоторые субъективные замечания о каждой платформе.

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

Фигура 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]. Были добавлены ссылки на документацию и источники учебных пособий для каждого программного пакета.

04 LTS, полные спецификации которого перечислены в [23]. Все фрагменты кода и программы, включенные в этот документ, были протестированы и запущены на ноутбуке Dell XPS 13 Developer Edition под управлением Linux Ubuntu 16. В среде 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

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

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

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

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

pip install pyquil

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

conda install −c rigetti pyquil

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

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

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

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

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

c. Синтаксис

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

# 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 для генератора случайных чисел.

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

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

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

print(qprog)

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

H 0
MEASURE 0 [0]

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

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

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

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

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

g. Симулятор

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

pyquil−config−setup

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

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

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

pip install referenceqvm

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

import referenceapi.api as api

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

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

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

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

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

pip install qiskit

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

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

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

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

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

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

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

c. Синтаксис

Здесь, в отличие от pyQuil, нужно явно выделить квантовые и классические регистры. На синтаксис QISKit можно посмотреть в следующей примерной программе. Ниже показана программа для схемы случайных чисел в 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 для генератора случайных чисел.

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

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

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

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

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

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

f. Симулятор

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

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

ProjectQ

C. ProjectQ

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

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

7 или 3. Для установки ProjectQ требуется текущая версия Python (2. Документация содержит подробную информацию об установке для каждой операционной системы. 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 для генератора случайных чисел.

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

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

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

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

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

f. Симулятор

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

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

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

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

Quantum Development Kit

D. Quantum Development Kit

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

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

(В этой статье мы используем только VS Code, но Visual Studio также является особой средой. Несмотря на то, что в документации Visual Studio Code указана как дополнительная, установка настоятельно рекомендуется для всех платформ. Мы по-прежнему платформенно-независимо относимся к тому, что лучше, и нам предпочтительно использовать 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. Синтаксис

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

// 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$, содержащий метаданные. Заметим, однако, что это один из трех файлов, необходимых для запуска этого кода. Поскольку этот пример можно найти в онлайн-документации, мы эти программы добавляются, но тем не менее заинтересованный читатель направляется к учебному пособию «Quickstart» в документации. В общем, этот пример насчитывает около 65 строк кода.

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

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

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

e. Симулятор

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

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

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

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

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

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

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

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

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

a. IBMQX5

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

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

b. Agave

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

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

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

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

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

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

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

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

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

Фигура 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. Производительность симулятора

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

a. pyQuil

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

Это является ключом к разработке алгоритмов малой глубины на квантовых компьютерах в ближайшем будущем, а также для теоретического оценивания результатов вычислений для конкретного квантового чипа. 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$. В симуляторе векторного состояния не хранится полная унитарная матрица, а загружается только вектор состояния и один/несколько кубитный гейт. Унитарный симулятор реализует базовое (унитарное) матричное умножение и резко ограничивается оперативной памятью. Подобно рассуждению о $inline$\textsf{ClassicalSimulator}$inline$ в ProjectQ, $inline$\textsf{local\_clifford\_simulator}$inline$ способен эффективно имитировать групповых схем (stabilizer circuits), которые не являются универсальными. Оба метода обсуждаются в [33], а [34-36] содержат подробную информацию о других методах.

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

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

с. ProjectQ

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

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

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

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

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

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

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

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

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

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

  • Для тех, чья основная цель является использование квантовых компьютеров, 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

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

a. Strawberry Fields

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

b. IonQ

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

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

c. D-Wave Systems

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

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

Приложение B

Эти тесты были выполнены на Dell XPS 13 Developer Edition с 64-разрядным Ubuntu 16. Ниже приведен список программ для тестирования производительности локального симулятора ProjectQ на C++. 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)

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

Приложение 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; }
}


Оставить комментарий

Ваш email нигде не будет показан
Обязательные для заполнения поля помечены *

*

x

Ещё Hi-Tech Интересное!

ENOG’15: «Почему Интернет до сих пор онлайн?»

Это — одновременно транскрипция и частичный перевод часовой сессии под названием «Почему Интернет до сих пор онлайн?» с пятнадцатой встречи «Евразийской группы сетевых операторов». Здравствуй, Хабр! Леви, Cloudflare; Александра Азимова, Qrator Labs и модератора Алексея Учакина из команды подкаста LinkmeUp ...

[Перевод] Учёные смущённо признают, что до сих пор не знают точной величины гравитационного взаимодействия

По легенде, первый эксперимент, показавший, что все объекты падают с одной скоростью, вне зависимости от массы, провёл Галилео Галилей, стоя на вершине Пизанской башни. Два любых объекта, брошенных вниз в гравитационном поле, в отсутствии сопротивления воздуха (или при пренебрежении им) ...