simulator/algorithms/tests/integration_tests.rs

//! Integration Tests for Phase 4 Quantum Algorithms
//!
//! End-to-end tests showing full pipeline: preparation → algorithm → measurement

#[cfg(test)]
mod tests {
    use qataaum_algorithms::*;
    use std::f64::consts::PI;

    #[test]
    fn test_h2_vqe_convergence() {
        // H2 molecule ground state via VQE
        let hamiltonian = hamiltonian::h2_hamiltonian();
        assert_eq!(hamiltonian.n_qubits, 2);
        assert!(hamiltonian.n_terms() > 0);

        // Create VQE circuit
        let circuit = vqe::ParametrizedCircuit::simple_ansatz(2, 2);
        assert_eq!(circuit.n_qubits, 2);

        // Create optimizer
        let optimizer = vqe::VQEOptimizer::new();

        // Note: full optimization would require quantum simulator
        // This tests the structural integration
        assert!(optimizer.learning_rate > 0.0);
    }

    #[test]
    fn test_maxcut_qaoa_small_graph() {
        // QAOA for MaxCut on 3-vertex triangle
        let edges = vec![(0, 1), (1, 2), (0, 2)];
        let qaoa = qaoa::MaxCutQAOA::new(3, edges, 1);

        assert!(qaoa.is_ok());
        let qaoa = qaoa.unwrap();
        assert_eq!(qaoa.edge_count(), 3);
        assert_eq!(qaoa.max_cut(), 3);
    }

    #[test]
    fn test_hamiltonian_simulation_trotter() {
        // Time evolution of H2 via Trotter-Suzuki
        let hamiltonian = hamiltonian::h2_hamiltonian();
        let config = hamiltonian_sim::HamiltonianSimConfig::new(0.1, 5)
            .with_second_order();

        let mut sim = hamiltonian_sim::TrotterSimulator::new(hamiltonian, config);
        let gates = sim.simulate();

        assert!(gates.is_ok());
        let gate_seq = gates.unwrap();
        assert!(!gate_seq.is_empty());

        // Check energy conservation
        let conservation = sim.energy_conservation();
        assert!(conservation > 0.99);
    }

    #[test]
    fn test_amplitude_estimation_simple() {
        // Amplitude estimation for 50% marked state
        let register = amplitude_est::AmplitudeRegister::uniform_marked(2, 0.5);
        assert!(register.is_ok());

        let mut estimator = amplitude_est::AmplitudeEstimator::new(5);
        assert!(estimator.is_ok());
    }

    #[test]
    fn test_quantum_walk_mixing() {
        // Quantum walk mixing on 4-cycle
        let walk = walks::CycleQuantumWalk::new(4);
        assert!(walk.is_ok());

        let walk = walk.unwrap();
        let gap = walk.spectral_gap();
        assert!(gap > 0.0 && gap < 4.0);
    }

    #[test]
    fn test_shor_factor_15() {
        // Factor 15 = 3 × 5
        let mut shor = shor::ShorFactoring::new(15);
        assert!(shor.is_ok());

        let mut shor = shor.unwrap();
        let factors = shor.factor();

        assert!(factors.is_ok());
        let factors = factors.unwrap();
        assert!(!factors.is_empty());
    }

    // Full pipeline tests

    #[test]
    fn test_vqe_h2_pipeline() {
        // Full VQE pipeline for H2
        let hamiltonian = hamiltonian::h2_hamiltonian();
        let (e_min, e_max) = hamiltonian.eigenvalue_bounds();

        // Ground state should be in bounds
        let ground_truth = vqe::molecules::h2_ground_state_energy();
        assert!(ground_truth >= e_min && ground_truth <= e_max);
    }

    #[test]
    fn test_qaoa_approximation_ratio_scaling() {
        // QAOA approximation ratio improves with layers
        let ratio_p1 = qaoa::MaxCutQAOA::expected_approx_ratio(1);
        let ratio_p2 = qaoa::MaxCutQAOA::expected_approx_ratio(2);
        let ratio_p3 = qaoa::MaxCutQAOA::expected_approx_ratio(3);

        assert!(ratio_p2 >= ratio_p1);
        assert!(ratio_p3 >= ratio_p2);
        assert!(ratio_p1 > 0.6 && ratio_p1 < 0.8);
    }

    #[test]
    fn test_trotter_error_convergence() {
        // Trotter error decreases with more steps
        let config1 = hamiltonian_sim::HamiltonianSimConfig::new(1.0, 5);
        let config2 = hamiltonian_sim::HamiltonianSimConfig::new(1.0, 10);
        let config4 = hamiltonian_sim::HamiltonianSimConfig::new(1.0, 20);

        let err1 = config1.error_bound();
        let err2 = config2.error_bound();
        let err4 = config4.error_bound();

        assert!(err2 < err1);
        assert!(err4 < err2);
    }

    #[test]
    fn test_amplitude_grover_amplification() {
        // Grover amplification increases amplitude
        let initial = 0.25;
        let amplified = amplitude_est::AmplitudeEstimator::grover_amplification(initial, 1);

        assert!(amplified.is_ok());
        let amplified = amplified.unwrap();
        assert!(amplified > initial);
    }

    #[test]
    fn test_walks_line_probability_distribution() {
        // Line walk probability distribution
        let walk = walks::LineQuantumWalk::new(5);
        let dist = walk.distribution();

        // Should be normalized
        let sum: f64 = dist.iter().sum();
        assert!((sum - 1.0).abs() < 1e-10);
    }

    #[test]
    fn test_shor_modpow_correctness() {
        // Verify modular exponentiation
        // 2^10 mod 1000 = 1024 mod 1000 = 24
        let exp = shor::ModularExponentiation::new(2, 1000).unwrap();
        assert_eq!(exp.compute(10), 24);
    }

    // Cross-algorithm tests

    #[test]
    fn test_pauli_hamiltonian_consistency() {
        // Pauli algebra consistency
        let p1 = hamiltonian::PauliString::new(vec![hamiltonian::PauliOp::X]);
        let p2 = hamiltonian::PauliString::new(vec![hamiltonian::PauliOp::X]);

        let result = p1.multiply(&p2).unwrap();
        assert_eq!(result.ops[0], hamiltonian::PauliOp::I);
    }

    #[test]
    fn test_vqe_optimizer_structure() {
        // VQE optimizer properly structured
        let opt = vqe::VQEOptimizer::new();
        assert!(opt.learning_rate > 0.0);
        assert!(opt.max_iterations > 0);
        assert!(opt.convergence_threshold > 0.0);
    }

    #[test]
    fn test_qaoa_circuit_parameters() {
        // QAOA circuit parameter management
        let params = qaoa::QAOAParams::new(2);
        assert_eq!(params.n_params(), 4);

        let vec = params.to_vec();
        let params2 = qaoa::QAOAParams::from_vec(&vec).unwrap();
        assert_eq!(params2.p, 2);
    }

    #[test]
    fn test_hamiltonian_simulation_config_scaling() {
        // Hamiltonian simulation configuration scales properly
        let steps_opt = hamiltonian_sim::HamiltonianSimConfig::optimal_steps(1.0, 1e-3);
        assert!(steps_opt > 0);

        let bound = hamiltonian_sim::HamiltonianSimConfig::new(1.0, steps_opt)
            .error_bound();
        assert!(bound < 1e-2);
    }

    #[test]
    fn test_amplitude_precision_scaling() {
        // Amplitude estimation precision requirements
        let shots = amplitude_est::AmplitudeEstimator::precision_scaling(0.5, 0.01);
        assert!(shots.is_ok());
        assert!(shots.unwrap() > 0);
    }

    #[test]
    fn test_walk_cycle_regularity() {
        // Cycle walk on regular graph
        let walk = walks::CycleQuantumWalk::new(6).unwrap();
        let gap = walk.spectral_gap();
        assert!(gap > 0.0);
    }

    #[test]
    fn test_shor_success_rate() {
        // Shor's algorithm success probability
        let prob = shor::ShorFactoring::success_probability();
        assert!(prob > 0.4 && prob < 0.42); // 4/π² ≈ 0.405
    }
}

// Made with Bob