КВАНТОВЫЕ ВЫЧИСЛЕНИЯ И Q ДЛЯ НАЧИНАЮЩИХ

Что такое квантовые вычисления?

Квантовые вычисления следует рассматривать как ASIC – «специальную интегральную схему, имеющую узкий круг применения, обусловленную определенным набором функций. Чтобы производить такие вычисления нужны специальные устройства – квантовые компьютеры. Это специализированный вычислительный ресурс, на который мы отправляем определенные задачи. Квантовые компьютеры обрабатывают информацию совершенно иначе, чем стандартные бинарные процессы в обычном компьютере. Они используют такие свойства, как «интерференция» , «суперпозиция» и «запутанность» и имеют преимущество при решении определенных видов задач.

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

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

При проведении измерений в квантовой системе мы манипулируем кубитами. Это наименьшая единица информации в квантовой машине, похожая на бит в обычном ПК. Но между ними есть существенная разница: бит может быть только в определенном состоянии, то есть промежуточных значений между 0 и 1 у него нет. Кубит также принимает стандартные значения 0 и 1, однако, в отличие от бита, он ими не ограничивается.

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

Что нужно знать о квантовых компьютерах

Квантовые ПК напоминают архаичные громоздкие вычислительные системы, поставляемые в огромных шкафах высотой около 3 м, занимающих по объему порядка 20 кубометров. При относительно небольших размерах главного квантового процессора, похожего на среднюю монету, 90% всего внутреннего пространства такого ящика составляют элементы систем охлаждения, использующие жидкий гелий для охлаждения квантового чипа до −273 °C и экранирования для защиты от внешних факторов.

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

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

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

Что нужно знать, чтобы стать программистом квантовых компьютеров

QCL (Quantum computing language)

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

QMASM (Quantum macro assembler)

Квантовый макроассемблер был создан в 2016 году. Это своего рода низкоуровневый язык, специально используемый для квантового отжига. Q MASM избавляет программиста от необходимости знать детали аппаратного обеспечения, специфичные для системы и в то же время позволяет разрабатывать программы на низком уровне абстракции.

Silq

Silq был создан в 2020 году и в отличие от QCL и QMASM – это язык программирования высокого уровня. Он написан на D, имеет 550 звезд на github и регулярно обновляется.

QML

Этот квантовый язык программирования, разработанный в 2007 году, очень похож на Haskell, ведь в его основе лежит строгая линейная логика. Он имеет возможность интегрировать обратимые и необратимые квантовые вычисления. С его помощью можно создавать высокопроизводительные, плавно анимированные и визуально привлекательные приложения.

Quantum Lambda Calculus

Язык основан на классическом лямбда-исчислении, которое начали применять для цифровых вычислений еще с 1996 года. По сравнению с уже рассмотренными, он определенно более сложный и работает с такими моделями, как квантовая машина Тьюринга или технологиями, использующими модель квантовой цепи.

QFC и QPL

Семантически эти языки квантового программирования эквивалентны. Однако в QFC квантовые программы представляются с использованием синтаксиса блок-схем, а в синтаксической структуре QPL программы представлены с помощью текста.

Всем хороши эти языки, однако у них все же есть два главных недостатка:

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

Комплекты для разработки квантового программного обеспечения

Также стоит отметить, что независимо от того, использует ли разработчик императивные, функциональные или
мультипарадигменные языки для написания квантового алгоритма, любому такому ПО для создания, запуска и управления приложением требуется программная среда (SDK), которая обычно имеет открытый исходный код и написана в большинстве случаев на Python.

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

1. Программирование квантовых компьютеров. Базовые алгоритмы и примеры кода, Джонстон, Химено-Сеговиа, Хэрриган 2020 г.
2. Разработка с использованием квантовых компьютеров, Владимир Силва 2019 г.
3. Танец с кубитами. Как на самом деле работают квантовые вычисления, Роберт Сатор 2022 г.
4. Квантовые вычисления для настоящих айтишников, Крис Бернхард 2019 г.

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

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

Материалы по теме

Языки программирования для квантового компьютера

Прототип ядра ионного квантового компьютера. Ion Quantum Technology Group
, Сассекский университет

Квантовые компьютеры время от времени попадают в СМИ. Вы слышите о том, как человек шаг за шагом приближается к их созданию, хотя для большинства развитие квантовых вычислений остается странным и таинственным искусством.

К счастью, для решения этой проблемы появляются отличные проекты, привлекающие внимание широкой аудитории. Например, несколько лет назад IBM дала возможность любому подключиться к 5-кубитному компьютеру. В проекте зарегистрировались 70 000 человек.

Однако индустрия квантовых вычислений по-прежнему остается в зачаточном состоянии. Хотя уже создано немало прототипов, они не могут сделать то, с чем не справится обычный ноутбук. Необходимое аппаратное обеспечение еще не существует, но для изучения у нас есть кое-что еще — языки квантового программирования.

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

Квантовые вычисления

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

Прежде чем заняться программами, давайте вспомним базовые вещи о квантовых вычислениях. И здесь нам поможет статья Брайана Хейса « Programming Your Quantum Computer
».

Обычный компьютер основан на битах: речь идет переменных, которые имеют только два возможных значения. Мы часто называем их 0 и 1, хотя в контексте булевой алгебры мы можем назвать их «Истинные» и «Ложные».

С битами можно выполнять простые булевы операции, такие как NOT, AND и OR. Любая переменная, более сложная, чем бит (например, int или float), представляет собой просто набор из множества бит.

Квантовые компьютеры основаны на квантовых битах или кубитах. Они также имеют два возможных значения, которые мы можем назвать 0 и 1. Но законы квантовой механики также допускают другие значения, которые мы называем состояниями суперпозиций.

В каком-то смысле состояния суперпозиции представляют собой значения, которые существуют между крайностями 0 и 1. Мы можем представить кубит как сферу, причем 0 и 1 расположены на противоположных полюсах. Состояния суперпозиции — все остальные возможные точки на поверхности.

Дело не в том, что кубит может иметь промежуточное значение, например 0,63; когда измеряется состояние кубита, результат всегда равен 0 или 1. Но в ходе вычисления кубит может действовать так, как если бы он представлял собой смесь состояний — например, 63% нуля и 37% единицы.

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

Подобно волнам, состояния 0 и 1 кубита имеют амплитуды, которые могут быть либо положительными, либо отрицательными. В зависимости от знаков амплитуд квантовая интерференция может либо увеличивать, либо уменьшать вероятность того, что определенное состояние будет наблюдаться, когда мы измеряем состояние кубита.

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

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

Каждая функция должна иметь одинаковое количество входов и выходов. Одним махом это правило запрещает большую часть арифметики. Обычный алгоритм сложения, например, необратим. Вы можете добавить 3 и 4, чтобы получить 7, но вы не можете «отсоединить» 7, чтобы восстановить исходные 3 и 4.

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

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

Ответ на эти сложности находят в языках квантового программирования. Фактически, квантовые компьютеры представляют собой гибридные устройства: частично квантовые и частично классические компьютеры. Использование элементов обычного компьютера необходимо для обработки входов и выходов, чтобы взаимодействовать с внешними приложениями. Таким образом, в одной программе можно комбинировать классический код и квантовый код.

Open Quantum Assembly Language (OpenQASM)

Исходный код OpenQASM был выпущен как часть программного обеспечения IBM Quantum Information Software Kit
(QISKit) для использования с квантовой вычислительной платформой Quantum Experience
. OpenQASM имеет общие черты со специализированными языками программирования (такими, как Verilog), используемыми для описания структуры и поведения электронных схем.

Программы QASM фактически всегда начинаются одинаково: мы определяем все биты, которые нам понадобятся — как квантовые, так и нормальные. Ниже приведен пример исходного кода OpenQASM. Программа добавляет два четырехбитовых номера.

 OPENQASM 2.0;
include "qelib1.inc";
gate majority a,b,c
{ cx c,b; cx c,a; ccx a,b,c;
}
gate unmaj a,b,c
{ ccx a,b,c; cx c,a; cx a,b;
}
qreg cin[1];
qreg a[4];
qreg b[4];
qreg cout[1];
creg ans[5];
// устанавливаем входящие значения
x a[0]; // a = 0001
x b; // b = 1111
// добавляем a к b, сохраняем результаты в b
majority cin[0],b[0],a[0];
majority a[0],b[1],a[1];
majority a[1],b[2],a[2];
majority a[2],b[3],a[3];
cx a[3],cout[0];
unmaj a[2],b[3],a[3];
unmaj a[1],b[2],a[2];
unmaj a[0],b[1],a[1];
unmaj cin[0],b[0],a[0];
measure b[0] -> ans[0];
measure b[1] -> ans[1];
measure b[2] -> ans[2];
measure b[3] -> ans[3];
measure cout[0] -> ans[4]; 

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

 operation Teleport(msg : Qubit, there : Qubit) : () { body { using (register = Qubit[1]) { let here = register[0]; H(here); CNOT(here, there); CNOT(msg, here); H(msg); if (M(msg) == One) { Z(there); } if (M(here) == One) { X(there); } } } } 

Скрипт Teleportation.qs из учебника по Q#. Учебник доступен здесь

Q# выглядит не так, как большинство других языков программирования, и несколько похож на C#.

Quantum Development Kit предоставляется бесплатно с подробными инструкциями по его установке и вводным учебным программам. Q# компилируется на квантовом симуляторе Visual Studio, имитируя квантовый процессор на 32 кубита. Симулятор может имитировать до 40 кубитов.

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

LIQUi (Language-Integrated Quantum Operations)

Платформа LIQUi, созданная командой Quantum Architectures and Computation Group в Microsoft Research, включает язык программирования, алгоритмы оптимизации и планирования, а также несколько квантовых симуляторов. L IQUi может использоваться для перевода квантового алгоритма, написанного в виде программы высокого уровня на языке F# из семейства . NET Framework, в низкоуровневые команды для квантового компьютера.

LIQUi позволяет моделировать до 30 кубитов на одной машине с 32 ГБ оперативной памяти. Платформу можно использовать для определения, выполнения и отображения в различных графических форматах квантовых схем. С помощью LIQUi можно имитировать простую квантовую телепортацию, алгоритм факторизации Шора, квантовую ассоциативную память, квантовую линейную алгебру.

 operation TeleportClassicalMessage(message : Bool) : Bool { body { mutable measurement = false; using (register = Qubit[2]) { // Запросим несколько кубитов, которые можно использовать для телепортации. let msg = register[0]; let there = register[1]; // Кодируем сообщение, которое мы хотим отправить. if (message) { X(msg); } Teleport(msg, there); // Проверяем сообщение. if (M(there) == One) { set measurement = true; } ResetAll(register); } return measurement; } } 

Как можно заметить по примеру выше, LIQUi очень похож на Q#.

Quantum Computation Language (QCL)

QCL, или Quantum Computation Language создан Бернхардом Омером в 1998 году. Развитие языка продолжается и сейчас: существует эмулятор
, который позволяет запускать квантовые программы на классическом компьютере. Конечно, эмулятор не может обеспечить ускорение квантового параллелизма; с другой стороны, он предлагает программисту некоторые полезные функции, такие как команды для проверки внутреннего состояния кубитов (что крайне трудно сделать на реальном квантовом оборудовании).

QCL заимствует синтаксис C и Java, которые иногда описываются как «императивные» языки, потому что они полагаются на прямые команды для установки и сброса значений переменных. Такие команды обычно запрещены в квантовом вычислении, поэтому основные части программы QCL работают только на классическом оборудовании. Квантовая система служит «оракулом», отвечающим на вопросы, которые могут быть заданы в формате, подходящем для вычислений кубитов. Каждый запрос к оракулу должен иметь требуемую архитектуру дымоходной трубы, но он может быть встроен в цикл во внешнем классическом контексте.

Фрагмент кода
, созданного в QCL (дискретное преобразование Фурье):

 operator dft(qureg q) {
const n=#q; int i; int j;
for i=1 to n {
for j=1 to i-1 { V(pi/2^(i-j),q[n-i] & q[n-j]);
}
H(q[n-i]);
}
flip(q);
} 

Дискретное преобразование Фурье является решающим шагом в алгоритме факторизации Шора. В алгоритме Шора число, подлежащее факторизации, рассматривается как волнообразный, периодический сигнал. Если N имеет коэффициенты u и v, то N состоит из u повторений v или v повторений u. Алгоритм Шора использует квантовый параллелизм для поиска периода таких повторений, хотя процесс не такой простой и прямой, как может показаться в примере выше.

Quipper

Язык был создан
коллективом авторов под руководством Питера Селингера. Quipper предназначен для тех же задач программирования, что и QCL, но имеет другую структуру и внешний вид. Язык реализован как расширение Haskell, которое использует функциональный, а не императивный способ выражения.

Рассмотрим классическую квантовую телепортацию. Она включает в себя две стороны — Алису и Боба. Целью Алисы является телепортация кубита q к Бобу. У Алисы и Боба должен быть доступ к кубитам из запутанной пары (a, b). Мы можем думать о роли Алисы в терминах функции, которая вводит два кубита q и a. На выходе функции будет пара классических бит, созданных Алисой:

 alice :: Qubit -> Qubit -> Circ (Bit,Bit)
alice q a = do
a <- qnot a ‘controlled‘ q
q <- hadamard q
(x,y) <- measure (q,a)
return (x,y)  

Более подробно можно познакомиться в документе « An Introduction to Quantum Programming in Quipper
».

А вот интересный пример возведения в 17 степень, путем возведения x в 16 степень встроенной процедурой возведения в квадрат и перемножением x и x^16:

 o4_POW17 :: QIntTF -> Circ (QIntTF,QIntTF)
o4_POW17 = box "o4" $ \x -> do
comment_with_label "ENTER: o4_POW17" x "x"
(x, x17) <- with_computed_fun x
(\x -> do
(x,x2) <- square x
(x2,x4) <- square x2
(x4,x8) <- square x4
(x8,x16) <- square x8
return (x,x2,x4,x8,x16))
(\(x,x2,x4,x8,x16) -> do
(x,x16,x17) <- o8_MUL x x16
return ((x,x2,x4,x8,x16),x17))
comment_with_label "EXIT: o4_POW17" (x,x17) ("x","x17")
return (x, x17) 

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

Quipper, как и QCL, автоматически генерирует схемы из высокоуровневых исходных смысловых конструкций.

Другие подходы

Разноцветные квадраты говорят пяти квантовым битам IBM, что нужно делать. Перетаскиванием вы можете создавать свои собственные квантовые вычисления

Проект IBM Quantum Experience
предоставляет возможность каждому запустить экспериментальную программу на реальном квантовом компьютере. Работа с языком программирования IBM похожа на процесс написания музыки с помощью приложения. Программист может просто перетащить квантовые объекты в определенную область, чтобы написать программу.

Quantum Computing Playground
— эксперимент WebGL Chrome, позволяющий смоделировать работу с квантовым компьютером в окошке браузера. Имеется собственный язык сценариев Qscript с функциями отладки и 3D-квантовой визуализации. Квантовая вычислительная площадка может эффективно имитировать квантовые регистры до 22 кубитов.

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

Qbsolv
— open source проект для работы с кубитами квантового процессора D-Wave (подходит только для компьютеров этой компании).

Языков квантового программирования (и симуляторов) уже десятки
, но все они работают на виртуальной машине. Вероятно, IBM Q — это единственный проект, который предлагает доступ к реальному квантовому компьютеру. Однако для того, чтобы начать заниматься «квантовым программированием», вовсе не обязательно иметь доступ к реальному передовому устройству. Уже сейчас можно не только изучать работу перспективных квантовых алгоритмов, но и создавать работающие приложения, например игры. Но это уже совсем другая история.

Even You Can Help Build a Quantum Computer

Quipper: The First High-Level Scalable Programming Language for Quantum Computers

Quantum Programming Language

How to program a quantum computer

Structured Quantum Programming

QCL — A Programming Language for Quantum Computers

Статьи из цикла:

Франчес — выпускница Имперского колледжа Лондона с научной степенью в области вычислительных технологий. Она написала свой дипломный проект, работая в подразделении Microsoft Research. Сейчас Франчес работает в Microsoft на должности инженера программных решений. Основные направления ее деятельности — машинное обучение, большие данные и квантовые вычисления.

Содержание статьи

• Повторим основы
• Измеряем кубит
• Квантовые вентили
• Важные вентили
• Несколько кубитов
• Еще один важный вентиль
• Состояние Белла
• Пишем квантовую программу
• Что дальше?
• Приложение
• Дополнительные материалы

Повторим основы

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

Классический бит может принимать только одно из двух состояний — «включено» или «выключено», как обычная лампа накаливания. Кубиты, основа квантовых компьютеров, больше похожи на светильник с регулировкой яркости.

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

Величины α и β связаны с вероятностями (с одним небольшим отличием — эти коэффициенты могут выражаться комплексными числами). Можно считать их действительными числами, но в этом случае помните, что они могут принимать отрицательные значения. Однако сумма их квадратов всегда равна 1.

Измеряем кубит

Если мы будем измерять его состояние, то в 50 % случаев будем получать значение 0, потому что:

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

Квантовые вентили

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

Я постараюсь объяснить, что означает математическое понятие унитарности. Если прочитать его достаточно быстро, вы просто окажетесь на следующем предложении. Вентиль называется унитарным, если
получена путем транспонирования и комплексного сопряжения
и является единичной матрицей ранга 2. Если говорить человеческим языком, это означает, что преобразование не меняет длину вектора. Если длина вектора не меняется со временем, то сумма всех вероятностей неизменно равна единице, или 100 % (как и должно быть). Выкладки, в результате которых сумма всех вероятностей оказывается равной 200 % или 25 %, были бы лишены смысла. Унитарные матрицы защищают по крайней мере от такого безумия (хотя в квантовом мире его остается предостаточно).

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

Вентиль Z и вентиль Адамара

что соответствует следующим преобразованиям состояний кубитов:
,

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

Несколько кубитов

Как и раньше, вероятность получить в результате измерения величину 00 равна
,

для 01 вероятность равна
и т. д.

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

Обратите внимание на числитель: мы убрали все слагаемые, для которых первый бит равен 1 (поскольку по условию результат измерения равен 0). Для того чтобы вектор описывал допустимое квантовое состояние, необходимо, чтобы квадрат сумм амплитуд был равен единице (как до, так и после преобразования). Чтобы это условие выполнялось, мы добавляем нормировочный множитель — величину, обратную квадратному корню из определителя.

Еще один важный вентиль

Операцию CNOT можно интерпретировать несколькими способами. Подобно вентилям X, Z и H, ее можно записать в матричной форме, которая обозначается буквой U.

Также для этого вентиля используется следующее обозначение (верхняя часть соответствует управляющему кубиту, нижняя — управляемому):

Выглядит как экспонат выставки современного искусства.

Состояния Белла

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

Чтобы узнать подробнее, как работает каждое из этих преобразований, обратитесь к дополнительным материалам (список приводится ниже). Мы уже знаем о состояниях кубитов, квантовых вентилях и состояниях Белла достаточно, чтобы написать нашу первую программу с использованием кубитов.

Пишем квантовую программу

Мы будем следовать инструкциям из документации
.

Это учебное руководство поможет вам выполнить следующие действия: установить пакет разработки квантовых программ (этапы 1–2), выделить кубит и выполнить над ним ряд простых манипуляций — например, установить его в некоторое состояние и измерить его (этапы 3–5), затем перевести кубит в состояние суперпозиции (этап 6), а после этого преобразовать два кубита в запутанное состояние — состояние Белла, или пару ЭПР (этап 7).

Рекомендуется следовать инструкциям из руководства, ссылка на которое приведена выше, и возвращаться к этому материалу, если вам нужны советы или дополнительные пояснения.

Этап 1. Создание проекта и решения

Q# находится в нижней части этого списка.

Этап 2 (необязательный). Обновление пакетов NuGet

Мы последовали этому совету, но делать это необязательно, особенно если вы любите рисковать.

Этап 3. Ввод кода Q#

 namespace Quantum.Bell
{ open Microsoft.Quantum.Primitive; open Microsoft.Quantum.Canon; operation Set (desired: Result, q1: Qubit) : () { body { let current = M(q1); if (desired != current) { X(q1); } } }
} 

Эта операция переводит наш кубит в выбранное (нами) состояние — 0 или 1. Вначале мы измеряем кубит (эта операция обозначается буквой M), и он коллапсирует в состояние 0 или 1. Если измеренное состояние не соответствует желаемому, мы меняем его с помощью вентиля NOT, X. В противном случае ничего делать не надо.

 operation BellTest (count : Int, initial: Result) : (Int,Int) { body { mutable numOnes = 0; using (qubits = Qubit[1]) { for (test in 1..count) { Set (initial, qubits[0]); let res = M (qubits[0]); // Count the number of ones we saw: if (res == One) { set numOnes = numOnes + 1; } } Set(Zero, qubits[0]); } // Return number of times we saw a |0> and number of times we saw a |1> return (count-numOnes, numOnes); } } 

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

Для этого она в цикле проводит измерение и подсчитывает количество результатов 1 с помощью переменной numOnes.

В цикле for мы устанавливаем кубит, выделенный для определенного начального состояния, — One или Zero (в файле Driver.cs
, к которому мы скоро перейдем, это делается в явном виде). Мы измеряем это состояние, и если это One, увеличиваем значение счетчика на единицу. Затем функция возвращает количество наблюдаемых состояний One и Zero. В конце кубит переводится в состояние Zero (просто чтобы оставить его в некотором известном состоянии).

Этап 4. Ввод кода драйвера C#

  using (var sim = new QuantumSimulator()) { // Try initial values Result[] initials = new Result[] { Result.Zero, Result.One }; foreach (Result initial in initials) { var res = BellTest.Run(sim, 1000, initial).Result; var (numZeros, numOnes) = res; System.Console.WriteLine( $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}"); } } System.Console.WriteLine("Press any key to continue..."); System.Console.ReadKey(); 

В этом драйвере создается квантовый симулятор и массив начальных значений, которые нужно проверить (Zero и One). Затем симуляция повторяется 1000 раз, а результат для отладки выводится на экран с помощью функции System. Console. WriteLine.

Этап 6. Создание суперпозиции

Попробуем нечто более интересное. Здесь мы меняем состояние кубита с помощью вентиля NOT.

  X(qubits[0]); let res = M (qubits[0]); 

Затем запускаем программу заново и видим, что результаты стали обратными.

Init:Zero 0s=0 1s=1000
Init:One 0s=1000 1s=0


  H(qubits[0]); let res = M (qubits[0]); 

Шаг 7. Подготовка запутанного состояния

 operation BellTest (count : Int, initial: Result) : (Int,Int) { body { mutable numOnes = 0; using (qubits = Qubit[2]) { for (test in 1..count) { Set (initial, qubits[0]); Set (Zero, qubits[1]); H(qubits[0]); CNOT(qubits[0],qubits[1]); let res = M (qubits[0]); // Count the number of ones we saw: if (res == One) { set numOnes = numOnes + 1; } } Set(Zero, qubits[0]); Set(Zero, qubits[1]); } // Return number of times we saw a |0> and number of times we saw a |1> return (count-numOnes, numOnes); } } 

 operation BellTest (count : Int, initial: Result) : (Int,Int,Int) { body { mutable numOnes = 0; mutable agree = 0; using (qubits = Qubit[2]) { for (test in 1..count) { Set (initial, qubits[0]); Set (Zero, qubits[1]); H(qubits[0]); CNOT(qubits[0],qubits[1]); let res = M (qubits[0]); if (M (qubits[1]) == res) { set agree = agree + 1; } // Count the number of ones we saw: if (res == One) { set numOnes = numOnes + 1; } } Set(Zero, qubits[0]); Set(Zero, qubits[1]); } // Return number of times we saw a |0> and number of times we saw a |1> return (count-numOnes, numOnes, agree); } } 

Перед тем как проверить результаты, нужно внести в файл Driver.cs еще одно изменение: добавить переменную agree.

 using (var sim = new QuantumSimulator()) { // Try initial values Result[] initials = new Result[] { Result.Zero, Result.One }; foreach (Result initial in initials) { var res = BellTest.Run(sim, 1000, initial).Result; var (numZeros, numOnes, agree) = res; System.Console.WriteLine( $"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}"); } } System.Console.WriteLine("Press any key to continue..."); System.Console.ReadKey(); 

Что дальше?

В репозитории GitHub
доступно множество примеров.

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

Квантовые вентили рассматриваются подробнее в блоге Аниты
(примечание: Анита просто потрясающая).

Дополнительные материалы

Если вы хотите углубиться в рассмотренные темы, ниже приводится список ресурсов, которые были для нас очень полезными. Первый из них — книга «Квантовые вычисления и квантовая информация» (М. Нильсен, И. Чанг). Второй — документация
к пакету SDK от Microsoft.

Приложение. Состояния Белла

Готово, мы разобрали все случаи.