Quantum Computing QA: Testing the Untestable

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):
        """Test quantum circuit produces expected probability distribution"""

        # Simple quantum circuit: Hadamard gate creates superposition
        qc = QuantumCircuit(1, 1)
        qc.h(0)  # Hadamard on qubit 0
        qc.measure(0, 0)

        # Execute circuit multiple times
        job = execute(qc, self.simulator, shots=self.shots)
        result = job.result()
        counts = result.get_counts(qc)

        # Expected: 50% |0⟩, 50% |1⟩ (within statistical variance)
        total = sum(counts.values())
        prob_0 = counts.get('0', 0) / total
        prob_1 = counts.get('1', 0) / total

        # Statistical test with confidence interval
        expected_prob = 0.5
        std_error = np.sqrt(expected_prob * (1 - expected_prob) / self.shots)
        confidence_interval = 3 * std_error  # 99.7% confidence

        assert abs(prob_0 - expected_prob) < confidence_interval, \
            f"Probability deviation too large: {prob_0} vs {expected_prob}"
        assert abs(prob_1 - expected_prob) < confidence_interval

    def test_bell_state_entanglement(self):
        """Validate quantum entanglement in Bell state"""

        # Create Bell state: (|00⟩ + |11⟩) / √2
        qc = QuantumCircuit(2, 2)
        qc.h(0)           # Superposition on qubit 0
        qc.cx(0, 1)       # CNOT: entangle qubit 0 and 1
        qc.measure([0, 1], [0, 1])

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

        # Expected: 50% |00⟩, 50% |11⟩, 0% |01⟩ or |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

        # Verify entanglement: only correlated states appear
        assert prob_00 > 0.45 and prob_00 < 0.55, "Bell state |00⟩ probability incorrect"
        assert prob_11 > 0.45 and prob_11 < 0.55, "Bell state |11⟩ probability incorrect"
        assert prob_01 < 0.05, "Unexpected |01⟩ state (should be entangled)"
        assert prob_10 < 0.05, "Unexpected |10⟩ state (should be entangled)"

from qiskit import QuantumCircuit, Aer

class StateVectorTester:
    def __init__(self):
        self.simulator = Aer.get_backend('statevector_simulator')

    def test_superposition_amplitudes(self):
        """Verify quantum state amplitudes before measurement"""

        qc = QuantumCircuit(2)
        qc.h(0)  # Qubit 0 in superposition
        qc.h(1)  # Qubit 1 in superposition

        # Get state vector (without measuring - only possible in simulator)
        job = execute(qc, self.simulator)
        statevector = job.result().get_statevector()

        # Expected: equal superposition |00⟩ + |01⟩ + |10⟩ + |11⟩
        # Each amplitude should be 1/2
        expected_amplitude = 0.5
        tolerance = 1e-6

        for amplitude in statevector:
            assert abs(abs(amplitude) - expected_amplitude) < tolerance, \
                f"Amplitude {amplitude} deviates from expected {expected_amplitude}"

    def test_phase_relationships(self):
        """Validate relative phases between quantum states"""

        qc = QuantumCircuit(1)
        qc.h(0)    # Superposition
        qc.z(0)    # Phase flip: |0⟩ - |1⟩

        statevector = execute(qc, self.simulator).result().get_statevector()

        # Expected: (|0⟩ - |1⟩) / √2
        # statevector[0] = 1/√2, statevector[1] = -1/√2
        assert abs(statevector[0] - 1/np.sqrt(2)) < 1e-6
        assert abs(statevector[1] - (-1/np.sqrt(2))) < 1e-6

        # Verify relative phase is π (180 degrees)
        phase_diff = np.angle(statevector[0]) - np.angle(statevector[1])
        assert abs(abs(phase_diff) - np.pi) < 1e-6

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

class TestGroverAlgorithm:
    def test_grover_search_amplification(self):
        """Test Grover's algorithm finds marked item with high probability"""

        # Search space: 4 items (2 qubits), marked item: |11⟩
        num_qubits = 2
        marked_state = '11'

        # Oracle: marks the target state
        oracle = QuantumCircuit(num_qubits)
        oracle.cz(0, 1)  # Mark |11⟩ state

        # Grover operator
        grover_op = GroverOperator(oracle)

        # Complete Grover circuit
        qc = QuantumCircuit(num_qubits, num_qubits)
        qc.h(range(num_qubits))  # Initial superposition

        # Optimal iterations for 4 items: π/4 * √4 ≈ 1
        qc.append(grover_op, range(num_qubits))

        qc.measure(range(num_qubits), range(num_qubits))

        # Execute
        simulator = Aer.get_backend('qasm_simulator')
        result = execute(qc, simulator, shots=1000).result()
        counts = result.get_counts()

        # Grover's algorithm should find |11⟩ with >90% probability
        prob_marked = counts.get(marked_state, 0) / sum(counts.values())
        assert prob_marked > 0.90, \
            f"Grover's algorithm found marked state with only {prob_marked:.2%} probability"

from qiskit.circuit.library import QFT
import numpy as np

class TestQFT:
    def test_qft_inverse_property(self):
        """Validate QFT and inverse QFT restore original state"""

        num_qubits = 3
        qc = QuantumCircuit(num_qubits)

        # Prepare arbitrary state
        qc.x(0)
        qc.h(1)

        # Apply QFT then inverse QFT
        qc.append(QFT(num_qubits), range(num_qubits))
        qc.append(QFT(num_qubits).inverse(), range(num_qubits))

        # Measure final state
        simulator = Aer.get_backend('statevector_simulator')
        final_state = execute(qc, simulator).result().get_statevector()

        # Should match original state preparation
        # |001⟩ + (|010⟩ + |011⟩)/√2
        expected = np.zeros(2**num_qubits, dtype=complex)
        expected[1] = 1  # |001⟩
        expected[2] = 1/np.sqrt(2)  # |010⟩
        expected[3] = 1/np.sqrt(2)  # |011⟩

        for i, (actual, exp) in enumerate(zip(final_state, expected)):
            assert abs(actual - exp) < 1e-6, \
                f"State {i}: QFT inverse failed to restore original"

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

class TestNoiseResilience:
    def test_algorithm_under_noise(self):
        """Validate algorithm performance degrades gracefully with noise"""

        # Create noise model
        noise_model = NoiseModel()
        error_1q = depolarizing_error(0.01, 1)  # 1% error on single-qubit gates
        error_2q = depolarizing_error(0.05, 2)  # 5% error on two-qubit gates

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

        # Test simple circuit with and without noise
        qc = QuantumCircuit(2, 2)
        qc.h(0)
        qc.cx(0, 1)
        qc.measure([0, 1], [0, 1])

        simulator = Aer.get_backend('qasm_simulator')

        # Noiseless execution
        ideal_counts = execute(qc, simulator, shots=10000).result().get_counts()

        # Noisy execution
        noisy_counts = execute(
            qc, simulator,
            noise_model=noise_model,
            shots=10000
        ).result().get_counts()

        # Analyze degradation
        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

        print(f"Ideal fidelity: {ideal_fidelity:.2%}")
        print(f"Noisy fidelity: {noisy_fidelity:.2%}")

        # Algorithm should degrade but remain above threshold
        assert noisy_fidelity > 0.85, "Excessive noise degradation"
        assert ideal_fidelity - noisy_fidelity < 0.15, "Algorithm not noise-resilient"

class QuantumTestStatistics:
    @staticmethod
    def chi_squared_test(observed_counts, expected_distribution, shots):
        """Chi-squared test for quantum measurement distributions"""
        chi_squared = 0
        for state, expected_prob in expected_distribution.items():
            observed = observed_counts.get(state, 0)
            expected = expected_prob * shots
            chi_squared += (observed - expected)**2 / expected

        # Degrees of freedom = number of states - 1
        dof = len(expected_distribution) - 1

        # Critical value for 95% confidence (dof=3): 7.815
        critical_value = 7.815
        return chi_squared < critical_value

from qiskit_machine_learning.algorithms import VQC
from qiskit.circuit.library import RealAmplitudes

class TestQuantumML:
    def test_vqc_training_convergence(self):
        """Test Variational Quantum Classifier converges"""

        # Simple dataset
        X_train = [[0, 0], [0, 1], [1, 0], [1, 1]]
        y_train = [0, 1, 1, 0]  # XOR problem

        # Quantum feature map and ansatz
        feature_map = RealAmplitudes(num_qubits=2, reps=1)
        ansatz = RealAmplitudes(num_qubits=2, reps=2)

        vqc = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer='COBYLA'
        )

        # Train
        vqc.fit(X_train, y_train)

        # Test convergence
        score = vqc.score(X_train, y_train)
        assert score > 0.80, "VQC failed to learn XOR pattern"

        # Test prediction stability (probabilistic)
        predictions = [vqc.predict([[0, 0]])[0] for _ in range(100)]
        stability = sum(predictions) / len(predictions)

        # Should consistently predict 0 for [0,0]
        assert stability < 0.2, "Predictions unstable"