Квантовое будущее для разработчиков: Что необходимо знать сегодня

from qiskit import QuantumCircuit, Aer, execute
 
# Создаём схему с двумя кубитами
qc = QuantumCircuit(2, 2)
 
# Создаём суперпозицию на первом кубите
qc.h(0)
 
# Создаём запутаность между кубитами
qc.cx(0, 1)
 
# Измеряем оба кубита
qc.measure([0, 1], [0, 1])
 
# Запускаем на симуляторе
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator, shots=1000).result()
counts = result.get_counts()
print(counts)  # Типичный результат: {'00': ~500, '11': ~500}

from qiskit import Aer
from qiskit.circuit.library import EfficientSU2
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import X, Z, I
 
# Создаём простой гамильтониан (энергетический оператор)
H = Z ^ Z + X ^ X
 
# Создаём параметризованную квантовую схему
ansatz = EfficientSU2(2)
 
# Классический оптимизатор
optimizer = COBYLA(maxiter=100)
 
# Настраиваем VQE с нашей схемой и оптимизатором
vqe = VQE(ansatz, optimizer, quantum_instance=Aer.get_backend('statevector_simulator'))
 
# Запускаем алгоритм для нахождения минимального собственного значения
result = vqe.compute_minimum_eigenvalue(operator=H)
print(f"Минимальное собственное значение: {result.eigenvalue.real}")

from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector
 
# Создаём схему для квантового телепортации
qc = QuantumCircuit(3, 2)
 
# Создаём состояние, которое хотим телепортировать
qc.h(0)
qc.rz(0.5, 0)
 
# Создаём запутанную пару, которую разделят Алиса и Боб
qc.h(1)
qc.cx(1, 2)
 
# Алиса получает кубит 0 и свою часть запутанной пары (кубит 1)
qc.cx(0, 1)
qc.h(0)
 
# Алиса измеряет свои кубиты и отправляет результаты Бобу
qc.measure([0, 1], [0, 1])
 
# Боб применяет корректирующие операции на основе классической информации
qc.cx(1, 2).c_if(1, 1)
qc.cz(0, 2).c_if(0, 1)
 
# Симулируем схему
simulator = Aer.get_backend('statevector_simulator')
qc_final = transpile(qc, simulator)
result = simulator.run(assemble(qc_final)).result()
statevector = result.get_statevector()
 
# Визуализируем конечное состояние кубита Боба
plot_bloch_multivector(statevector)

# Типичная ошибка: повторное измерение состояния
from qiskit import QuantumCircuit, Aer, execute
 
qc = QuantumCircuit(1, 2)
qc.h(0)  # Создаём суперпозицию
qc.measure(0, 0)  # Первое измерение
qc.measure(0, 1)  # Второе измерение - всегда даст такой же результат как первое!
 
simulator = Aer.get_backend('qasm_simulator')
counts = execute(qc, simulator, shots=1000).result().get_counts()
print(counts)  # Результаты всегда будут коррелированными: {'00': x, '11': y}

# Использование Mitiq для смягчения шума
from mitiq import zne
from qiskit import QuantumCircuit, Aer, execute
 
def execute_circuit(circuit):
    """Функция-исполнитель для квантовой схемы"""
    simulator = Aer.get_backend('qasm_simulator')
    # Добавляем искусственный шум для демонстрации
    simulator.set_options(noise_model=some_noise_model)
    result = execute(circuit, simulator).result()
    return result.get_counts()['0'] / 1000  # Вероятность результата |0⟩
 
# Создаём простую схему
circuit = QuantumCircuit(1, 1)
circuit.h(0)  # Суперпозиция
circuit.rz(0.1, 0)  # Поворот вокруг оси Z
circuit.h(0)  # Вернуть в вычислительный базис
circuit.measure(0, 0)
 
# Вычисление с компенсацией шума
zne_value = zne.execute_with_zne(circuit, execute_circuit)
raw_value = execute_circuit(circuit)
 
print(f"Значение без коррекции шума: {raw_value}")
print(f"Значение с ZNE-коррекцией: {zne_value}")

# Пример использования D-Wave Ocean SDK для задачи оптимизации
from dwave.system import DWaveSampler, EmbeddingComposite
import dimod
 
# Определяем простую задачу минимизации: f(x) = x1*x2 + x2*x3 + x1*x3
bqm = dimod.BinaryQuadraticModel({1: 0, 2: 0, 3: 0}, 
                                {(1, 2): 1, (2, 3): 1, (1, 3): 1}, 
                                0, 'BINARY')
 
# Настраиваем решатель
sampler = EmbeddingComposite(DWaveSampler())
 
# Запускаем квантовый отжиг
sampleset = sampler.sample(bqm, num_reads=100)
 
# Анализируем результаты
print("Энергии и конфигурации:")
for sample, energy, num_occurrences in sampleset.data(['sample', 'energy', 'num_occurrences']):
    print(sample, energy, num_occurrences)

# Пример квантовой нейронной сети с PennyLane
import pennylane as qml
from pennylane import numpy as np
 
# Определяем квантовое устройство
dev = qml.device("default.qubit", wires=4)
 
# Определяем параметризованную квантовую схему
@qml.qnode(dev)
def quantum_neural_net(inputs, weights):
    # Кодируем входные данные в квантовое состояние
    for i in range(4):
        qml.RY(inputs[i], wires=i)
    
    # Применяем параметризованные квантовые вентили
    for i in range(4):
        qml.RZ(weights[0, i], wires=i)
    
    qml.CNOT(wires=[0, 1])
    qml.CNOT(wires=[1, 2])
    qml.CNOT(wires=[2, 3])
    qml.CNOT(wires=[3, 0])
    
    for i in range(4):
        qml.RY(weights[1, i], wires=i)
    
    # Возвращаем ожидаемое значение оператора
    return qml.expval(qml.PauliZ(0))
 
# Генерируем случайные входные данные и веса
inputs = np.random.uniform(0, np.pi, size=4)
weights = np.random.uniform(-np.pi, np.pi, size=(2, 4))
 
# Вычисляем выход квантовой нейронной сети
result = quantum_neural_net(inputs, weights)
print(f"Результат: {result}")

# Упрощенная симуляция BB84 - протокола квантового распределения ключей
import numpy as np
import random
 
def bb84_simulation(n_bits=100, eavesdropping=False):
    # Алиса генерирует случайные биты и базисы
    alice_bits = [random.randint(0, 1) for _ in range(n_bits)]
    alice_bases = [random.randint(0, 1) for _ in range(n_bits)]  # 0: X-базис, 1: Z-базис
    
    # Алиса готовит кубиты в соответствующих состояниях
    # В реальности это квантовые состояния, здесь просто для симуляции
    qubits = []
    for bit, basis in zip(alice_bits, alice_bases):
        if basis == 0:  # X-базис
            if bit == 0:
                qubits.append('+')  # |+⟩ состояние
            else:
                qubits.append('-')  # |-⟩ состояние
        else:  # Z-базис
            if bit == 0:
                qubits.append('0')  # |0⟩ состояние
            else:
                qubits.append('1')  # |1⟩ состояние
    
    # Ева перехватывает и измеряет некоторые кубиты (если включено)
    if eavesdropping:
        for i in range(n_bits):
            if random.random() < 0.3:  # Ева перехватывает 30% кубитов
                # Ева выбирает случайный базис
                eve_basis = random.randint(0, 1)
                # Измерение разрушает исходное состояние
                if eve_basis != alice_bases[i]:
                    # Если базисы не совпадают, результат случаен
                    qubits[i] = random.choice(['0', '1']) if eve_basis == 1 else random.choice(['+', '-'])
    
    # Боб измеряет полученные кубиты в случайных базисах
    bob_bases = [random.randint(0, 1) for _ in range(n_bits)]
    bob_results = []
    
    for i, (qubit, basis) in enumerate(zip(qubits, bob_bases)):
        if basis == 0:  # X-базис
            if qubit in ['+', '-']:
                bob_results.append(0 if qubit == '+' else 1)
            else:
                bob_results.append(random.randint(0, 1))  # Случайный результат при несовпадении базисов
        else:  # Z-базис
            if qubit in ['0', '1']:
                bob_results.append(int(qubit))
            else:
                bob_results.append(random.randint(0, 1))  # Случайный результат
    
    # Алиса и Боб сравнивают базисы и оставляют только совпадающие
    shared_key = []
    matching_positions = []
    
    for i in range(n_bits):
        if alice_bases[i] == bob_bases[i]:
            matching_positions.append(i)
            if alice_bits[i] == bob_results[i]:
                shared_key.append(alice_bits[i])
    
    # Проверка наличия подслушивания (QBER - Quantum Bit Error Rate)
    sample_size = min(len(matching_positions) // 4, 20)
    sample_positions = random.sample(matching_positions, sample_size)
    
    error_count = 0
    for pos in sample_positions:
        if alice_bits[pos] != bob_results[pos]:
            error_count += 1
    
    error_rate = error_count / sample_size if sample_size > 0 else 0
    is_secure = error_rate < 0.15  # Допустимый уровень ошибок
    
    return {
        'key_length': len(shared_key) - sample_size,
        'error_rate': error_rate,
        'is_secure': is_secure
    }
 
# Демонстрация
result_without_eve = bb84_simulation(eavesdropping=False)
result_with_eve = bb84_simulation(eavesdropping=True)
 
print(f"Без перехвата: длина ключа={result_without_eve['key_length']}, ошибки={result_without_eve['error_rate']:.1%}, безопасно={result_without_eve['is_secure']}")
print(f"С перехватом: длина ключа={result_with_eve['key_length']}, ошибки={result_with_eve['error_rate']:.1%}, безопасно={result_with_eve['is_secure']}")

# Представление кубита в состоянии |0⟩ как вектора
import numpy as np
 
# |0⟩ в векторном представлении
ket_0 = np.array([1+0j, 0+0j])
 
# |1⟩ в векторном представлении
ket_1 = np.array([0+0j, 1+0j])
 
# Вентиль Адамара как унитарная матрица
H = (1/np.sqrt(2)) * np.array([[1+0j, 1+0j], 
                               [1+0j, -1+0j]])
 
# Применение вентиля Адамара к состоянию |0⟩ создает суперпозицию
superposition = np.dot(H, ket_0)
 
print("Суперпозиция:", superposition)
# Результат: [0.7071+0j 0.7071+0j] - это состояние (|0⟩ + |1⟩)/√2

# Пример вариационного квантового алгоритма для задачи максимальной 2-SAT
from qiskit import Aer
from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.utils import QuantumInstance
from qiskit_optimization.applications import MaxCut
 
# Определяем граф для задачи MaxCut (эквивалентной Max-2-SAT)
edges = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]
max_cut = MaxCut(edges)
qubo = max_cut.to_quadratic_program()
 
# Настраиваем квантовый экземпляр для симуляции
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'), 
                                   shots=1024)
 
# Создаём и запускаем QAOA
qaoa = QAOA(optimizer=COBYLA(maxiter=100), 
            quantum_instance=quantum_instance,
            reps=3)  # Количество повторений схемы
 
result = qaoa.compute_minimum_eigenvalue(qubo)
 
# Получаем и интерпретируем результаты
x = max_cut.sample_most_likely(result.eigenstate)
print(f"Максимальное разбиение: {x}")
print(f"Значение разреза: {max_cut.max_cut_value(x)}")

# Практический пример - поиск периода функции 
# (базовый элемент алгоритма Шора)
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
import numpy as np
 
# Функция с известным периодом для демонстрации
def f(x, period):
    return x % period
 
# Квантовая схема для поиска периода
def period_finding(period, n_qubits):
    # Создаём схему с n_qubits в входном регистре
    # и достаточным количеством кубитов в выходном регистре
    qc = QuantumCircuit(n_qubits * 2, n_qubits)
    
    # Создаём суперпозицию всех возможных входных значений
    for i in range(n_qubits):
        qc.h(i)
    
    # Применяем оракул функции f
    # В реальности это было бы сложное квантовое преобразование
    # Здесь мы упрощаем для демонстрации
    for x in range(2**n_qubits):
        y = f(x, period)
        # Условное преобразование, активируемое только если
        # входной регистр в состоянии |x⟩
        binary_x = format(x, f'0{n_qubits}b')
        for i, bit in enumerate(binary_x):
            if bit == '0':
                qc.x(i)
        
        # Контролируемая операция, устанавливающая выходной регистр в |f(x)⟩
        binary_y = format(y, f'0{n_qubits}b')
        for i, bit in enumerate(binary_y):
            if bit == '1':
                qc.cx(0, n_qubits + i)  # Упрощение для демонстрации
        
        # Восстанавливаем входной регистр
        for i, bit in enumerate(binary_x):
            if bit == '0':
                qc.x(i)
    
    # Обратное преобразование Фурье для выявления периодичности
    for i in range(n_qubits):
        qc.h(i)
    
    # Измерение
    qc.measure(range(n_qubits), range(n_qubits))
    
    return qc
 
# Запускаем для периода 4
simulator = QasmSimulator()
n_qubits = 3
circuit = period_finding(4, n_qubits)
compiled_circuit = transpile(circuit, simulator)
job = simulator.run(compiled_circuit, shots=2048)
result = job.result()
counts = result.get_counts(compiled_circuit)
 
# Анализируем результаты для выявления периода
print("Распределение измерений:", counts)