Квантовое программирование на Python: как создать первые алгоритмы

# Создание виртуального окружения
python -m venv quantum_env

# Активация в Windows
quantum_env\Scripts\activate

# Активация в macOS/Linux
source quantum_env/bin/activate

# Установка Qiskit (IBM)
pip install qiskit

# Установка Cirq (Google)
pip install cirq

# Установка PennyLane (для квантового машинного обучения)
pip install pennylane

# Дополнительные полезные библиотеки
pip install matplotlib numpy jupyter

# Запуск Jupyter Notebook
jupyter notebook

# Тестирование установки Qiskit
import qiskit
print("Qiskit version:", qiskit.__version__)

# Тестирование установки Cirq
import cirq
print("Cirq version:", cirq.__version__)

# Проверка доступности симуляторов
from qiskit.providers.aer import Aer
backend = Aer.get_backend('qasm_simulator')
print("Simulator ready:", backend.name())

# Импортируем необходимые модули
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram

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

# Устанавливаем первый кубит в суперпозицию
circuit.h(0)

# Выполняем операцию CNOT, чтобы запутать кубиты
circuit.cx(0, 1)

# Измеряем оба кубита
circuit.measure([0, 1], [0, 1])

# Визуализируем схему
print(circuit.draw())

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

# Получаем результаты и отображаем их
counts = result.get_counts(circuit)
print("Результаты:", counts)

# Импортируем необходимые модули
import cirq
import matplotlib.pyplot as plt

# Создаем два кубита
q0, q1 = cirq.LineQubit.range(2)

# Создаем схему
circuit = cirq.Circuit()

# Добавляем операции в схему
circuit.append(cirq.H(q0)) # Адамаров гейт для суперпозиции
circuit.append(cirq.CNOT(q0, q1)) # CNOT для запутывания
circuit.append(cirq.measure(q0, q1)) # Измерение обоих кубитов

# Выводим схему
print("Квантовая схема:")
print(circuit)

# Симулируем выполнение
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1000)

# Выводим результаты
print("Результаты:")
print(result.histogram(key='q(0),q(1)'))

# Импортируем необходимые модули
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute

# Создаем регистры для телепортации
qr = QuantumRegister(3, 'q') # 3 кубита
crz = ClassicalRegister(1, 'crz') # 1 классический бит для коррекции Z
crx = ClassicalRegister(1, 'crx') # 1 классический бит для коррекции X
circuit = QuantumCircuit(qr, crz, crx)

# Готовим состояние для телепортации (можно изменить)
circuit.x(qr[0]) # Состояние |1⟩
circuit.h(qr[0]) # Создаем суперпозицию (|0⟩ + |1⟩)/sqrt(2)

# Создаем запутанную пару (кубиты 1 и 2)
circuit.h(qr[1])
circuit.cx(qr[1], qr[2])

# Телепортация: запутываем кубит 0 с кубитом 1
circuit.cx(qr[0], qr[1])
circuit.h(qr[0])

# Измеряем кубиты 0 и 1
circuit.measure(qr[0], crz[0])
circuit.measure(qr[1], crx[0])

# Применяем коррекции к кубиту 2 на основе измерений
circuit.z(qr[2]).c_if(crz, 1) # Применяем Z, если crz=1
circuit.x(qr[2]).c_if(crx, 1) # Применяем X, если crx=1

# Визуализируем схему
print(circuit.draw())

# Симулируем выполнение
simulator = Aer.get_backend('statevector_simulator')
job = execute(circuit, simulator)
result = job.result()
statevector = result.get_statevector()

# Выводим конечное состояние (должно соответствовать начальному состоянию кубита 0)
print("Конечное состояние системы:", statevector)

# Реализация алгоритма Гровера в Qiskit
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
import numpy as np

# Создаем функцию для Oracle (черного ящика)
def create_oracle(marked_state, n_qubits):
oracle = QuantumCircuit(n_qubits)
# Отмечаем искомый элемент инверсией фазы
# Для простоты отметим состояние |11...1⟩
if marked_state == '1' * n_qubits:
oracle.z(n_qubits – 1)
else:
# Для других состояний потребуется более сложная логика
bit_str = marked_state
for qubit, bit in enumerate(reversed(bit_str)):
if bit == '0':
oracle.x(qubit)
oracle.h(n_qubits – 1)
oracle.mcx(list(range(n_qubits – 1)), n_qubits – 1)
oracle.h(n_qubits – 1)
for qubit, bit in enumerate(reversed(bit_str)):
if bit == '0':
oracle.x(qubit)
return oracle

# Создаем диффузор для амплификации амплитуды
def diffuser(n_qubits):
diffuser = QuantumCircuit(n_qubits)
# Применяем H-гейты ко всем кубитам
for qubit in range(n_qubits):
diffuser.h(qubit)
# Применяем X-гейты ко всем кубитам
for qubit in range(n_qubits):
diffuser.x(qubit)
# Многокубитный управляемый Z-гейт
diffuser.h(n_qubits-1)
diffuser.mcx(list(range(n_qubits-1)), n_qubits-1)
diffuser.h(n_qubits-1)
# Отменяем X-гейты
for qubit in range(n_qubits):
diffuser.x(qubit)
# Отменяем H-гейты
for qubit in range(n_qubits):
diffuser.h(qubit)
return diffuser

# Основная функция алгоритма Гровера
def grover(marked_state, n_qubits, n_iterations):
# Создаем схему
grover_circuit = QuantumCircuit(n_qubits, n_qubits)

# Инициализация: суперпозиция всех состояний
for qubit in range(n_qubits):
grover_circuit.h(qubit)

# Итерации Гровера
oracle_gate = create_oracle(marked_state, n_qubits)
diffuser_gate = diffuser(n_qubits)

for _ in range(n_iterations):
grover_circuit.append(oracle_gate, range(n_qubits))
grover_circuit.append(diffuser_gate, range(n_qubits))

# Измерение
grover_circuit.measure(range(n_qubits), range(n_qubits))

return grover_circuit

# Параметры поиска
n_qubits = 3 # Используем 3 кубита (пространство поиска размером 2^3 = 8)
marked_state = '101' # Состояние, которое мы ищем

# Оптимальное число итераций: π/4 * √N
n_iterations = int(np.round(np.pi/4 * np.sqrt(2**n_qubits)))
print(f"Оптимальное количество итераций: {n_iterations}")

# Создаем и запускаем схему
circuit = grover(marked_state, n_qubits, n_iterations)
print(circuit.draw())

# Симуляция
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, simulator, shots=1024).result()
counts = result.get_counts()
print(f"Результаты: {counts}")

# Реализация алгоритма Дойча-Йожи в Cirq
import cirq
import numpy as np

# Количество кубитов (помимо целевого)
n_qubits = 3

# Создаем кубиты
input_qubits = [cirq.LineQubit(i) for i in range(n_qubits)]
output_qubit = cirq.LineQubit(n_qubits)

# Функция для создания оракула
def oracle_function(qubits, output, function_type='constant'):
"""Создает оракул для алгоритма Дойча-Йожи.

Args:
qubits: Входные кубиты
output: Выходной кубит
function_type: 'constant' или 'balanced'
"""
if function_type == 'constant':
# Для постоянной функции не делаем ничего (f(x) = 0 для всех x)
# Или можно инвертировать выход для f(x) = 1
return []
else: # balanced
# Для сбалансированной функции используем CNOT гейты
# Например, f(x) = x_0 XOR x_1 XOR ... XOR x_{n-1}
return [cirq.CNOT(q, output) for q in qubits]

# Создаем схему для алгоритма Дойча-Йожи
def deutsch_jozsa_circuit(qubits, output, function_type):
circuit = cirq.Circuit()

# Подготовка состояния
circuit.append(cirq.X(output))
circuit.append([cirq.H(q) for q in qubits + [output]])

# Применяем оракул
circuit.append(oracle_function(qubits, output, function_type))

# Финальные преобразования
circuit.append([cirq.H(q) for q in qubits])
circuit.append([cirq.measure(q) for q in qubits])

return circuit

# Создаем схему с постоянной функцией
constant_circuit = deutsch_jozsa_circuit(
input_qubits, output_qubit, 'constant')
print("Схема для постоянной функции:")
print(constant_circuit)

# Создаем схему со сбалансированной функцией
balanced_circuit = deutsch_jozsa_circuit(
input_qubits, output_qubit, 'balanced')
print("\nСхема для сбалансированной функции:")
print(balanced_circuit)

# Симулируем и получаем результаты
simulator = cirq.Simulator()

# Симуляция постоянной функции
constant_result = simulator.run(constant_circuit, repetitions=100)
constant_counts = constant_result.histogram(key='m')
print("\nРезультаты для постоянной функции:")
print(constant_counts)

# Симуляция сбалансированной функции
balanced_result = simulator.run(balanced_circuit, repetitions=100)
balanced_counts = balanced_result.histogram(key='m')
print("\nРезультаты для сбалансированной функции:")
print(balanced_counts)

# Анализ результатов
def analyze_results(counts):
"""Определяет, постоянная функция или сбалансированная."""
# Если все измерения дают 0, функция постоянная
if counts.get(0, 0) == sum(counts.values()):
return "constant"
else:
return "balanced"

print("\nАнализ функции 1:", analyze_results(constant_counts))
print("Анализ функции 2:", analyze_results(balanced_counts))

# Запуск на реальном квантовом устройстве IBM
from qiskit import IBMQ, QuantumCircuit, transpile
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram

# Подготовка к работе с IBM Quantum Experience
# Необходимо зарегистрироваться на quantum-computing.ibm.com и получить API-ключ
IBMQ.save_account('YOUR_API_KEY', overwrite=True)
IBMQ.load_account()

# Создаем простую схему для запуска на реальном устройстве
# Используем меньше кубитов для реальных устройств из-за ограничений и шума
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])

# Получаем доступ к провайдеру и выбираем устройство
provider = IBMQ.get_provider(hub='ibm-q')

# Получаем список доступных устройств
available_backends = provider.backends()
print("Доступные устройства:")
for backend in available_backends:
if backend.configuration().n_qubits >= 2 and not backend.configuration().simulator:
print(f"- {backend.name()}: {backend.configuration().n_qubits} кубитов")

# Выбираем устройство с наименьшей очередью
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(
filters=lambda x: x.configuration().n_qubits >= 2 and 
not x.configuration().simulator and
x.status().operational==True))
print(f"Выбрано устройство: {backend.name()}")

# Оптимизируем схему для выбранного устройства
transpiled_circuit = transpile(circuit, backend, optimization_level=3)
print("Оптимизированная схема для устройства:")
print(transpiled_circuit.draw())

# Отправляем задание на выполнение
job = backend.run(transpiled_circuit, shots=1024)
job_id = job.job_id()
print(f"Задание отправлено. ID: {job_id}")

# Мониторинг прогресса
job_monitor(job)

# Получаем и анализируем результаты
result = job.result()
counts = result.get_counts()
print(f"Результаты: {counts}")

# Визуализация результатов и анализ ошибок
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# Теоретические ожидаемые результаты (для сравнения)
expected_counts = {'00': 512, '11': 512}

# Сравниваем результаты с симулятором
simulator = provider.get_backend('ibmq_qasm_simulator')
sim_job = simulator.run(transpiled_circuit, shots=1024)
sim_result = sim_job.result()
sim_counts = sim_result.get_counts()

# Вычисляем различия между симуляцией и реальным устройством
plot_histogram([counts, sim_counts, expected_counts], 
legend=['Реальное устройство', 'Симулятор', 'Теория'])

# Пример использования техник смягчения ошибок в Qiskit
from qiskit import QuantumCircuit
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter

# Создаем схему для калибровки измерений
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Готовим калибровочные схемы
meas_calibs, state_labels = complete_meas_cal(qr=qc.qregs[0], circlabel='mcal')

# Запускаем калибровочные схемы
job = backend.run(meas_calibs, shots=1024)
cal_results = job.result()

# Создаем объект "фиттер" для коррекции результатов
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
print(meas_fitter.cal_matrix)

# Запускаем основную схему
job = backend.run(qc, shots=1024)
results = job.result()

# Применяем коррекцию к результатам
mitigated_results = meas_fitter.filter.apply(results)
mitigated_counts = mitigated_results.get_counts(0)
print("Скорректированные результаты:", mitigated_counts)