QA para Computación Cuántica: Probando lo Improbable

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):
        """Probar que el circuito cuántico produce distribución de probabilidad esperada"""

        # Circuito cuántico simple: puerta Hadamard crea superposición
        qc = QuantumCircuit(1, 1)
        qc.h(0)  # Hadamard en qubit 0
        qc.measure(0, 0)

        # Ejecutar circuito múltiples veces
        job = execute(qc, self.simulator, shots=self.shots)
        result = job.result()
        counts = result.get_counts(qc)

        # Esperado: 50% |0⟩, 50% |1⟩ (dentro de varianza estadística)
        total = sum(counts.values())
        prob_0 = counts.get('0', 0) / total
        prob_1 = counts.get('1', 0) / total

        # Prueba estadística con intervalo de confianza
        expected_prob = 0.5
        std_error = np.sqrt(expected_prob * (1 - expected_prob) / self.shots)
        confidence_interval = 3 * std_error  # 99.7% confianza

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

    def test_bell_state_entanglement(self):
        """Validar entrelazamiento cuántico en estado de Bell"""

        # Crear estado de Bell: (|00⟩ + |11⟩) / √2
        qc = QuantumCircuit(2, 2)
        qc.h(0)           # Superposición en qubit 0
        qc.cx(0, 1)       # CNOT: entrelazar qubit 0 y 1
        qc.measure([0, 1], [0, 1])

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

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

        # Verificar entrelazamiento: solo estados correlacionados aparecen
        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):
        """Probar que el algoritmo de Grover encuentra elemento marcado con alta probabilidad"""

        num_qubits = 2
        marked_state = '11'

        # Oráculo: marca el estado objetivo
        oracle = QuantumCircuit(num_qubits)
        oracle.cz(0, 1)  # Marcar estado |11⟩

        # Operador de Grover
        grover_op = GroverOperator(oracle)

        # Circuito completo de Grover
        qc = QuantumCircuit(num_qubits, num_qubits)
        qc.h(range(num_qubits))  # Superposición inicial

        # Iteraciones óptimas para 4 elementos: π/4 * √4 ≈ 1
        qc.append(grover_op, range(num_qubits))
        qc.measure(range(num_qubits), range(num_qubits))

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

        # Grover debería encontrar |11⟩ con >90% probabilidad
        prob_marked = counts.get(marked_state, 0) / sum(counts.values())
        assert prob_marked > 0.90, \
            f"Grover encontró estado marcado con solo {prob_marked:.2%} probabilidad"

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

class TestNoiseResilience:
    def test_algorithm_under_noise(self):
        """Validar que el rendimiento del algoritmo se degrada con gracia con ruido"""

        # Crear modelo de ruido
        noise_model = NoiseModel()
        error_1q = depolarizing_error(0.01, 1)  # 1% error en puertas de un qubit
        error_2q = depolarizing_error(0.05, 2)  # 5% error en puertas de dos qubits

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

        # Probar circuito simple con y sin ruido
        qc = QuantumCircuit(2, 2)
        qc.h(0)
        qc.cx(0, 1)
        qc.measure([0, 1], [0, 1])

        simulator = Aer.get_backend('qasm_simulator')

        # Ejecución sin ruido
        ideal_counts = execute(qc, simulator, shots=10000).result().get_counts()

        # Ejecución con ruido
        noisy_counts = execute(
            qc, simulator,
            noise_model=noise_model,
            shots=10000
        ).result().get_counts()

        # Analizar degradación
        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

        # El algoritmo debería degradarse pero permanecer por encima del umbral
        assert noisy_fidelity > 0.85, "Degradación excesiva por ruido"
        assert ideal_fidelity - noisy_fidelity < 0.15