5 квантовых языков программирования: как они устроены и где их учить

Если вы знакомы с квантовыми компьютерами, вы знаете, что кубит — это частица.

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

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

Как работают квантовые языки программирования

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

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

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

1. Операция применения единичного преобразования (Unitary operations). Например, оператор Хадамара (H) создает суперпозицию состояний |0⟩ и |1⟩, а оператор Ши (S) применяет фазовый сдвиг к состоянию.
2. Операция измерения (Measurement). Измерение кубита приводит к коллапсу состояния в одно из базисных состояний |0⟩ или |1⟩. Измерение позволяет получить информацию о состоянии кубита и использовать её в дальнейших вычислениях.
3. Операция запутывания (Entanglement). Она позволяет создавать состояния, в которых два или более кубита становятся коррелированными таким образом, что изменение состояния одного кубита немедленно отражается на другом. Используется для передачи информации и решения задач на квантовое шифрование и квантовую телепортацию.
4. Операция управляемого вращения (Controlled rotations). Позволяет применять унитарные операции к кубитам при выполнении определенных условий. Например, оператор CNOT (управляемое НЕ) применяет операцию NOT к целевому кубиту только в том случае, если управляющий кубит находится в состоянии |1⟩.
5. Операция декогеренции и исправление ошибок (Decoherence and error correction). Декогеренция — это разрушение квантового состояния, которое является неотъемлемой частью квантовых систем. Квантовые языки программирования позволяют находить и исправлять ошибки, чтобы повысить точность вычислений.

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

1. Q# (Q sharp)

Это высокоуровневый квантовый язык программирования, разработанный Microsoft. У Q# есть несколько весомых преимуществ перед остальными квантовыми языками: на нём можно писать программы с использованием неквантового языка программирования C#, а ещё Q# поддерживается Microsoft Quantum Development Kit.

Полезные ссылки:

1. Документация
2. Компилятор от Microsoft
3. Учебник по Q# от Microsoft

Вот, как выглядит программа на Q#:

			namespace Quantum.Examples {
    open Microsoft.Quantum.Primitive;

    // Определение операции для создания суперпозиции и измерения кубита
    operation SuperpositionExample() : Result {
        // Использование конструкции using для создания кубита и автоматического освобождения ресурсов после использования
        using (qubit = Qubit()) {
            H(qubit); // Применение операции Хадамара к кубиту для создания суперпозиции
            return M(qubit); // Измерение кубита и возврат результата
        }
    }
}
		

Читаем код:

1. namespace Quantum.Examples – это определение пространства имен. Все операции и типы данных для квантовых вычислений будут находиться в пространстве имен Quantum.Examples.
2. open Microsoft.Quantum.Primitive – оператор open импортирует пространство имен Microsoft.Quantum.Primitive. Оно содержит основные операции и функции, необходимые для работы с квантовыми вычислениями.
3. operation SuperpositionExample() : Result – определение операции с именем SuperpositionExample. Операция не принимает никаких аргументов и возвращает значения Result. Тип Result представляет результат измерения кубита и может принимать значения 0 или 1.
4. using (qubit = Qubit()) – конструкция using используется для создания кубита и автоматического освобождения ресурсов после использования. Кубит помещается в переменную qubit.
5. H(qubit) – вызов операции H, которая применяет операцию Хадамара к кубиту qubit. Операция Хадамара создает суперпозицию состояний |0⟩ и |1⟩, что означает, что кубит может находиться в обоих состояниях одновременно.
6. return M(qubit) – измеряет кубит qubit и возвращает результат измерения. Операция M измеряет состояние кубита и возвращает 0 или 1 в зависимости от того, в каком положении кубит был измерен.

2. Quantum

Quantum – это квантовый язык программирования, разработанный для IBM Quantum и платформы Qiskit. По сравнению с другими языками, Quantum предлагает простой синтаксис для разработки квантовых алгоритмов.

Ещё Quantum использует открытый доступ к платформе IBM Quantum Experience и поддерживает OpenQASM — язык для описания квантовых схем.

Полезные ссылки:

1. Документация от Microsoft
2. Development Kit
3. Туториалы и упражнения от Microsoft

Пример кода:

			open quantum;

operation SuperpositionExample() : Result {
    using (qubit = Qubit()) {
        H(qubit);
        let result = M(qubit);
        return result;
    }
}
		

Описание кода:

1. open quantum; – открывает пространство имен quantum с основными операциями и функциями для работы с квантовыми вычислениями.
2. operation SuperpositionExample() : Result – определяет операцию SuperpositionExample. Операция не принимает аргументов и возвращает значение Result. Тип Result представляет результат измерения кубита и может принимать значения 0 или 1.
3. using (qubit = Qubit()) – конструкция using используется для создания кубита (переменная qubit) на основе типа данных Qubit. После вычислений в блоке using, конструкция автоматически освобождает ресурсы, связанные с кубитом.
4. H(qubit); – применяет операцию Хадамара (H) к кубиту qubit, создавая суперпозицию кубита, что означает, что кубит может находиться в состояниях 0 и 1 одновременно.
5. let result = M(qubit); – выполняет измерение кубита qubit и сохраняет результат измерения в переменную result в виде 0 или 1.
6. return result; – возвращает результат измерения кубита после выполнения операции SuperpositionExample.

3. Cirq

Cirq – фреймворк и язык программирования от Google, предназначенный для разработки на квантовых процессорах.

У Cirq простой синтаксис, он поддерживает симуляции и может выполняться на реальных квантовых устройствах. Интегрируется с другими инструментами Google вроде TensorFlow.

Полезные ссылки:

1. Официальный репозиторий на GitHub
2. Документация
3. Туториалы по Cirq

Пример кода:

			import cirq

def superposition_example():
    # Создание квантового регистра
    qubit = cirq.LineQubit(0)
    
    # Создание цепочки операций
    circuit = cirq.Circuit()
    circuit.append(cirq.H(qubit))  # Применение операции H (Хадамара) к кубиту

    # Измерение состояния кубита
    circuit.append(cirq.measure(qubit, key='result'))

    # Запуск симулятора для выполнения программы
    simulator = cirq.Simulator()
    result = simulator.run(circuit)
    
    # Получение результатов измерений
    measurement_result = result.measurements['result']
    return measurement_result[0]

result = superposition_example()
print(result)
		

Вот, что делает этот код:

1. import cirq – импортирует модуль cirq, который предоставляет функционал для создания квантовых цепочек, операций и симуляции квантовых вычислений.
2. def superposition_example(): – определяет функцию superposition_example, которая содержит код для создания квантовой цепочки.
3. qubit = cirq.LineQubit(0) – создает объект qubit на нулевой позиции.
4. circuit = cirq.Circuit() – создает квантовую цепочку, в которую будут добавлены операции.
5. circuit.append(cirq.H(qubit)) – добавляет операцию Хадамара (H) к кубиту qubit в квантовую цепочку. Создает суперпозицию состояний кубита.
6. circuit.append(cirq.measure(qubit, key='result')) – добавляет операцию измерения qubit в квантовую цепочку. Результат измерений будет сохранен под ключом 'result'.
7. simulator = cirq.Simulator() – создает объект simulator для симуляции квантовой цепочки.
8. result = simulator.run(circuit) – запускает simulator для выполнения квантовой цепочки circuit и сохраняет результаты выполнения.
9. measurement_result = result.measurements['result'] – получает результаты измерений из объекта result для ключа 'result'.
10. return measurement_result[0] – возвращает первый элемент из результатов измерений, представляющий значение измерения кубита.
11. result = superposition_example() – вызывает функцию superposition_example и сохраняет результат измерения в переменную result.
12. print(result) – выводит значение измерения кубита на экран.

4. pyQuil

pyQuil – это библиотека на Python, разработанная компанией Rigetti Computing.

pyQuil позволяет создавать, симулировать и выполнять квантовые программы на кубитах суперпроводников. Он интегрирован с другими научными библиотеками Python.

Полезные ссылки:

1. Документация
2. Forest SDK для pyQuil
3. Интерактивные туториалы

Пример кода:

			from pyquil import Program
from pyquil.gates import H, CNOT
from pyquil.api import WavefunctionSimulator

# Создаем квантовую программу
p = Program()

# Применяем операцию Хадамара на первом кубите
p += H(0)

# Применяем операцию CNOT на обоих кубитах
p += CNOT(0, 1)

# Создаем симулятор
simulator = WavefunctionSimulator()

# Получаем волновую функцию после выполнения программы
wavefunction = simulator.simulate(p)

# Выводим результаты
print(wavefunction)
		

Объясняем код:

1. from ... import ... – импортируем необходимые модули из pyQuil.
2. p = Program() – создаем объект Program, который представляет квантовую программу.
3. p += H(0) – Применяем операцию Хадамара (H) на первом кубите. Операция Хадамара создает суперпозицию кубита, превращая его из начального состояния |0> в состояние (|0> + |1>)/sqrt(2).
4. p += CNOT(0, 1) – применяем операцию CNOT на обоих кубитах. Операция CNOT инвертирует второй кубит только тогда, когда первый кубит находится в состоянии |1>.
5. simulator = WavefunctionSimulator() – создаем объект WavefunctionSimulator, который позволяет симулировать выполнение программы.
6. wavefunction = simulator.simulate(p) – симулируем выполнение программы и получаем волновую функцию (wavefunction) после выполнения.
7. print(wavefunction) – выводим волновую функцию.

5. Qiskit

Qiskit – это открытая библиотека программного обеспечения, разработанная IBM для разработки и исполнения квантовых алгоритмов.

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

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

Полезные ссылки:

1. Документация
2. Учебник по машинному обучению от Qiskit
3. Официальный репозиторий на GitHub

Пример программы на Qiskit:

			from qiskit import QuantumCircuit, execute, Aer

# Создаем квантовую схему с 2 кубитами и 2 классическими битами
qc = QuantumCircuit(2, 2)

# Применяем операции на кубитах
qc.h(0)   # Применяем операцию Хадамара на первом кубите
qc.cx(0, 1)  # Применяем операцию CNOT на обоих кубитах

# Измеряем состояние кубитов в классические биты
qc.measure([0,1], [0,1])

# Выполняем схему на симуляторе
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=1000)
result = job.result()

# Выводим результаты
counts = result.get_counts(qc)
print(counts)
		

Что делает программа:

1. from ... import ... – импортируем необходимые модули из Qiskit.
2. qc = QuantumCircuit(2, 2) – создаем объект QuantumCircuit с двумя кубитами и двумя классическими битами.
3. qc.h(0) – применяем операцию Хадамара (H) на первом кубите. Операция Хадамара создает суперпозицию изначально |0> состояния кубита, превращая его в (|0> + |1>)/sqrt(2).
4. qc.cx(0, 1) – применяем операцию CNOT (cx) на обоих кубитах. Операция CNOT применяет преобразование, которое инвертирует второй кубит, только если первый кубит находится в состоянии |1>.
5. qc.measure([0,1], [0,1]) – измеряем состояния кубитов и сохраняем результаты в классические биты.
6. simulator = Aer.get_backend('qasm_simulator') – запускаем квантовый симулятор.
7. job = execute(qc, simulator, shots=1000) – выполняем схему на симуляторе, указывая количество повторений (shots) равным 1000.
8. result = job.result() – сохраняем результаты симуляции.
9. counts = result.get_counts(qc) // print(counts) – получаем результаты выполнения симуляции и выводим их.

Заключение

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

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

До встречи в квантовом будущем! ?