QA для Квантовых Вычислений: Тестирование Нетестируемого

from qiskit import QuantumCircuit, execute, Aer
import numpy as np

class QuantumCircuitTester:
    def __init__(self, shots=10000):
        self.simulator = Aer.get_backend('qasm_simulator')
        self.shots = shots

    def test_quantum_circuit_distribution(self):
        """Тест, что квантовая схема производит ожидаемое распределение вероятностей"""

        # Простая квантовая схема: вентиль Адамара создает суперпозицию
        qc = QuantumCircuit(1, 1)
        qc.h(0)  # Адамар на кубите 0
        qc.measure(0, 0)

        # Выполнить схему несколько раз
        job = execute(qc, self.simulator, shots=self.shots)
        result = job.result()
        counts = result.get_counts(qc)

        # Ожидается: 50% |0⟩, 50% |1⟩ (в пределах статистической дисперсии)
        total = sum(counts.values())
        prob_0 = counts.get('0', 0) / total
        prob_1 = counts.get('1', 0) / total

        # Статистический тест с доверительным интервалом
        expected_prob = 0.5
        std_error = np.sqrt(expected_prob * (1 - expected_prob) / self.shots)
        confidence_interval = 3 * std_error  # 99.7% уверенность

        assert abs(prob_0 - expected_prob) < confidence_interval
        assert abs(prob_1 - expected_prob) < confidence_interval

    def test_bell_state_entanglement(self):
        """Валидация квантовой запутанности в состоянии Белла"""

        # Создать состояние Белла: (|00⟩ + |11⟩) / √2
        qc = QuantumCircuit(2, 2)
        qc.h(0)           # Суперпозиция на кубите 0
        qc.cx(0, 1)       # CNOT: запутать кубиты 0 и 1
        qc.measure([0, 1], [0, 1])

        job = execute(qc, self.simulator, shots=self.shots)
        counts = job.result().get_counts(qc)

        # Ожидается: 50% |00⟩, 50% |11⟩, 0% |01⟩ или |10⟩
        total = sum(counts.values())
        prob_00 = counts.get('00', 0) / total
        prob_11 = counts.get('11', 0) / total
        prob_01 = counts.get('01', 0) / total
        prob_10 = counts.get('10', 0) / total

        # Проверить запутанность: появляются только коррелированные состояния
        assert prob_00 > 0.45 and prob_00 < 0.55
        assert prob_11 > 0.45 and prob_11 < 0.55
        assert prob_01 < 0.05
        assert prob_10 < 0.05

from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit.library import GroverOperator

class TestGroverAlgorithm:
    def test_grover_search_amplification(self):
        """Тест, что алгоритм Гровера находит помеченный элемент с высокой вероятностью"""

        num_qubits = 2
        marked_state = '11'

        # Оракул: помечает целевое состояние
        oracle = QuantumCircuit(num_qubits)
        oracle.cz(0, 1)  # Пометить состояние |11⟩

        # Оператор Гровера
        grover_op = GroverOperator(oracle)

        # Полная схема Гровера
        qc = QuantumCircuit(num_qubits, num_qubits)
        qc.h(range(num_qubits))  # Начальная суперпозиция

        # Оптимальные итерации для 4 элементов: π/4 * √4 ≈ 1
        qc.append(grover_op, range(num_qubits))
        qc.measure(range(num_qubits), range(num_qubits))

        # Выполнить
        simulator = Aer.get_backend('qasm_simulator')
        result = execute(qc, simulator, shots=1000).result()
        counts = result.get_counts()

        # Гровер должен найти |11⟩ с вероятностью >90%
        prob_marked = counts.get(marked_state, 0) / sum(counts.values())
        assert prob_marked > 0.90, \
            f"Гровер нашел помеченное состояние с вероятностью только {prob_marked:.2%}"

from qiskit.providers.aer.noise import NoiseModel, depolarizing_error

class TestNoiseResilience:
    def test_algorithm_under_noise(self):
        """Валидация, что производительность алгоритма деградирует корректно с шумом"""

        # Создать модель шума
        noise_model = NoiseModel()
        error_1q = depolarizing_error(0.01, 1)  # 1% ошибка на одно-кубитных вентилях
        error_2q = depolarizing_error(0.05, 2)  # 5% ошибка на двух-кубитных вентилях

        noise_model.add_all_qubit_quantum_error(error_1q, ['h', 'x', 'z'])
        noise_model.add_all_qubit_quantum_error(error_2q, ['cx'])

        # Тестировать простую схему с шумом и без
        qc = QuantumCircuit(2, 2)
        qc.h(0)
        qc.cx(0, 1)
        qc.measure([0, 1], [0, 1])

        simulator = Aer.get_backend('qasm_simulator')

        # Выполнение без шума
        ideal_counts = execute(qc, simulator, shots=10000).result().get_counts()

        # Выполнение с шумом
        noisy_counts = execute(
            qc, simulator,
            noise_model=noise_model,
            shots=10000
        ).result().get_counts()

        # Анализ деградации
        ideal_fidelity = (ideal_counts.get('00', 0) + ideal_counts.get('11', 0)) / 10000
        noisy_fidelity = (noisy_counts.get('00', 0) + noisy_counts.get('11', 0)) / 10000

        # Алгоритм должен деградировать, но оставаться выше порога
        assert noisy_fidelity > 0.85, "Чрезмерная деградация от шума"
        assert ideal_fidelity - noisy_fidelity < 0.15