quantrs2_sim/quantum_algorithms/

functions.rs

//! Auto-generated module
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::error::{Result, SimulatorError};
use crate::statevector::StateVectorSimulator;
use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::Complex64;
use std::collections::HashMap;

use super::types::{
    AlgorithmResourceStats, EnhancedPhaseEstimation, OptimizationLevel, OptimizedGroverAlgorithm,
    OptimizedShorAlgorithm, QuantumAlgorithmConfig,
};

/// Benchmark quantum algorithms
pub fn benchmark_quantum_algorithms() -> Result<HashMap<String, f64>> {
    let mut results = HashMap::new();
    let shor_start = std::time::Instant::now();
    let config = QuantumAlgorithmConfig::default();
    let mut shor = OptimizedShorAlgorithm::new(config)?;
    let _shor_result = shor.factor(15)?;
    results.insert(
        "shor_15".to_string(),
        shor_start.elapsed().as_secs_f64() * 1000.0,
    );
    let grover_start = std::time::Instant::now();
    let config = QuantumAlgorithmConfig::default();
    let mut grover = OptimizedGroverAlgorithm::new(config)?;
    let oracle = |x: usize| x == 5 || x == 10;
    let _grover_result = grover.search(4, oracle, 2)?;
    results.insert(
        "grover_4qubits".to_string(),
        grover_start.elapsed().as_secs_f64() * 1000.0,
    );
    let qpe_start = std::time::Instant::now();
    let config = QuantumAlgorithmConfig::default();
    let mut qpe = EnhancedPhaseEstimation::new(config)?;
    let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
    let unitary = |sim: &mut StateVectorSimulator, target_qubit: usize| -> Result<()> {
        sim.apply_z_public(target_qubit)?;
        Ok(())
    };
    let _qpe_result = qpe.estimate_eigenvalues(unitary, &eigenstate, 1e-3)?;
    results.insert(
        "phase_estimation".to_string(),
        qpe_start.elapsed().as_secs_f64() * 1000.0,
    );
    Ok(results)
}
#[cfg(test)]
mod tests {
    use super::*;

    /// `dense_system_unitary` must recover the operator's actual matrix from the opaque
    /// closure, since raising it to the `2^i` powers a phase estimation needs depends on
    /// having the matrix rather than on re-applying the closure.
    #[test]
    fn dense_system_unitary_recovers_the_operator_matrix() {
        let z_operator = |sim: &mut StateVectorSimulator, target: usize| -> Result<()> {
            sim.apply_z_public(target)?;
            Ok(())
        };
        let matrix = EnhancedPhaseEstimation::dense_system_unitary(&z_operator, 1)
            .expect("dense unitary should be constructible");

        assert_eq!(matrix.dim(), (2, 2));
        let expected = [
            ((0, 0), Complex64::new(1.0, 0.0)),
            ((0, 1), Complex64::new(0.0, 0.0)),
            ((1, 0), Complex64::new(0.0, 0.0)),
            ((1, 1), Complex64::new(-1.0, 0.0)),
        ];
        for ((row, column), value) in expected {
            assert!(
                (matrix[[row, column]] - value).norm() < 1e-12,
                "Z matrix entry ({row},{column}) was {}, expected {value}",
                matrix[[row, column]]
            );
        }

        // Z^2 = I, so squaring (the operation used to build U^(2^i)) must return identity.
        let squared = matrix.dot(&matrix);
        assert!((squared[[0, 0]] - Complex64::new(1.0, 0.0)).norm() < 1e-12);
        assert!((squared[[1, 1]] - Complex64::new(1.0, 0.0)).norm() < 1e-12);
    }

    /// The controlled application must touch only the amplitudes whose control bit is set,
    /// and must apply the operator to the low-order system register within each block.
    #[test]
    fn apply_controlled_system_unitary_respects_the_control_qubit() {
        let z_operator = |sim: &mut StateVectorSimulator, target: usize| -> Result<()> {
            sim.apply_z_public(target)?;
            Ok(())
        };
        let z_matrix = EnhancedPhaseEstimation::dense_system_unitary(&z_operator, 1)
            .expect("dense unitary should be constructible");

        // Layout: system qubit is bit 0, control qubit is bit 1, so index = control<<1 | system.
        // |control=1, system=1> must pick up Z's -1 phase.
        let mut simulator = StateVectorSimulator::new();
        simulator
            .set_state(vec![
                Complex64::new(0.0, 0.0),
                Complex64::new(0.0, 0.0),
                Complex64::new(0.0, 0.0),
                Complex64::new(1.0, 0.0),
            ])
            .expect("state should be settable");
        EnhancedPhaseEstimation::apply_controlled_system_unitary(&mut simulator, &z_matrix, 1, 1)
            .expect("controlled application should succeed");
        let state = simulator.get_state();
        assert!((state[3] - Complex64::new(-1.0, 0.0)).norm() < 1e-12);

        // |control=0, system=1> must be left untouched.
        let mut simulator = StateVectorSimulator::new();
        simulator
            .set_state(vec![
                Complex64::new(0.0, 0.0),
                Complex64::new(1.0, 0.0),
                Complex64::new(0.0, 0.0),
                Complex64::new(0.0, 0.0),
            ])
            .expect("state should be settable");
        EnhancedPhaseEstimation::apply_controlled_system_unitary(&mut simulator, &z_matrix, 1, 1)
            .expect("controlled application should succeed");
        let state = simulator.get_state();
        assert!((state[1] - Complex64::new(1.0, 0.0)).norm() < 1e-12);
    }

    #[test]
    fn test_shor_algorithm_creation() {
        let config = QuantumAlgorithmConfig::default();
        let shor = OptimizedShorAlgorithm::new(config);
        assert!(shor.is_ok());
    }
    #[test]
    fn test_shor_trivial_cases() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(14).expect("Factoring 14 should succeed");
        assert!(result.factors.contains(&2));
        assert!(result.factors.contains(&7));
    }
    #[test]
    fn test_grover_algorithm_creation() {
        let config = QuantumAlgorithmConfig::default();
        let grover = OptimizedGroverAlgorithm::new(config);
        assert!(grover.is_ok());
    }
    #[test]
    fn test_grover_optimal_iterations() {
        let config = QuantumAlgorithmConfig::default();
        let grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let num_items = 16;
        let num_targets = 1;
        let iterations = grover.calculate_optimal_iterations(num_items, num_targets);
        assert!((3..=4).contains(&iterations));
    }
    #[test]
    fn test_phase_estimation_creation() {
        let config = QuantumAlgorithmConfig::default();
        let qpe = EnhancedPhaseEstimation::new(config);
        assert!(qpe.is_ok());
    }
    #[test]
    fn test_continued_fractions() {
        let config = QuantumAlgorithmConfig::default();
        let _shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let convergents = OptimizedShorAlgorithm::continued_fractions(0.375, 100);
        assert!(!convergents.is_empty());
        assert!(convergents.iter().any(|&(num, den)| num == 3 && den == 8));
    }
    #[test]
    fn test_modular_exponentiation() {
        let config = QuantumAlgorithmConfig::default();
        let _shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 3, 5), 3);
        assert_eq!(OptimizedShorAlgorithm::mod_exp(3, 4, 7), 4);
    }
    #[test]
    fn test_phase_estimation_simple() {
        let config = QuantumAlgorithmConfig::default();
        let mut qpe =
            EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
        let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0), Complex64::new(0.0, 0.0)]);
        let z_unitary =
            |sim: &mut StateVectorSimulator, _target_qubit: usize| -> Result<()> { Ok(()) };
        let result = qpe.estimate_eigenvalues(z_unitary, &eigenstate, 1e-2);
        assert!(result.is_ok());
        let qpe_result = result.expect("Phase estimation should succeed");
        assert!(!qpe_result.eigenvalues.is_empty());
        assert_eq!(qpe_result.eigenvalues.len(), qpe_result.precisions.len());
    }
    #[test]
    fn test_grover_search_functionality() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 3;
        let result = grover.search(3, oracle, 1);
        if let Err(e) = &result {
            eprintln!("Grover search failed: {e:?}");
        }
        assert!(result.is_ok());
        let grover_result = result.expect("Grover search should succeed");
        assert_eq!(grover_result.iterations, grover_result.optimal_iterations);
        assert!(grover_result.success_probability >= 0.0);
        assert!(grover_result.success_probability <= 1.0);
    }
    #[test]
    fn test_shor_algorithm_classical_cases() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(10).expect("Factoring 10 should succeed");
        assert!(!result.factors.is_empty());
        assert!(result.factors.contains(&2) || result.factors.contains(&5));
        let result = shor.factor(7).expect("Factoring 7 should succeed");
        if !result.factors.is_empty() {
            let product: u64 = result.factors.iter().product();
            assert_eq!(product, 7);
        }
    }
    #[test]
    fn test_quantum_algorithm_benchmarks() {
        let benchmarks = benchmark_quantum_algorithms();
        assert!(benchmarks.is_ok());
        let results = benchmarks.expect("Benchmarks should succeed");
        assert!(results.contains_key("shor_15"));
        assert!(results.contains_key("grover_4qubits"));
        assert!(results.contains_key("phase_estimation"));
        for (algorithm, time) in results {
            assert!(
                time >= 0.0,
                "Algorithm {algorithm} had negative execution time"
            );
        }
    }
    #[test]
    fn test_grover_optimal_iterations_calculation() {
        let config = QuantumAlgorithmConfig::default();
        let grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        assert_eq!(grover.calculate_optimal_iterations(4, 1), 1);
        assert_eq!(grover.calculate_optimal_iterations(16, 1), 3);
        let iterations_64_1 = grover.calculate_optimal_iterations(64, 1);
        assert!((6..=8).contains(&iterations_64_1));
    }
    #[test]
    fn test_phase_estimation_precision_control() {
        let config = QuantumAlgorithmConfig {
            precision_tolerance: 1e-3,
            ..Default::default()
        };
        let mut qpe =
            EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
        let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
        let identity_op =
            |_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
        let result = qpe.estimate_eigenvalues(identity_op, &eigenstate, 1e-3);
        assert!(result.is_ok());
        let qpe_result = result.expect("Phase estimation should succeed");
        assert!(qpe_result.precisions[0] <= 1e-3);
        assert!(qpe_result.phase_qubits >= 3);
    }
    #[test]
    fn test_grover_multiple_targets() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 2 || x == 5;
        let result = grover.search(3, oracle, 2);
        assert!(result.is_ok());
        let grover_result = result.expect("Grover search should succeed");
        assert!(grover_result.success_probability >= 0.0);
        assert!(grover_result.success_probability <= 1.0);
        assert!(grover_result.iterations > 0);
    }
    #[test]
    fn test_grover_four_qubits() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 7;
        let result = grover.search(4, oracle, 1);
        assert!(result.is_ok());
        let grover_result = result.expect("Grover search should succeed");
        assert!(grover_result.resource_stats.qubits_used >= 4);
        assert!(grover_result.iterations >= 2 && grover_result.iterations <= 5);
    }
    #[test]
    fn test_shor_perfect_square() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(16).expect("Factoring 16 should succeed");
        assert!(result.factors.contains(&4) || result.factors.contains(&2));
    }
    #[test]
    fn test_shor_semiprime() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(15).expect("Factoring 15 should succeed");
        assert!(result.execution_time_ms >= 0.0);
        if !result.factors.is_empty() {
            for &factor in &result.factors {
                assert!(15 % factor == 0 || factor == 15);
            }
        }
    }
    #[test]
    fn test_optimization_levels() {
        let levels = vec![
            OptimizationLevel::Basic,
            OptimizationLevel::Memory,
            OptimizationLevel::Speed,
            OptimizationLevel::Hardware,
            OptimizationLevel::Maximum,
        ];
        for level in levels {
            let config = QuantumAlgorithmConfig {
                optimization_level: level,
                ..Default::default()
            };
            let grover = OptimizedGroverAlgorithm::new(config.clone());
            assert!(grover.is_ok());
            let shor = OptimizedShorAlgorithm::new(config.clone());
            assert!(shor.is_ok());
            let qpe = EnhancedPhaseEstimation::new(config);
            assert!(qpe.is_ok());
        }
    }
    #[test]
    fn test_resource_stats() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(6).expect("Factoring 6 should succeed");
        let stats = &result.resource_stats;
        assert!(!result.factors.is_empty() || stats.qubits_used == 0);
    }
    #[test]
    fn test_grover_resource_stats() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 1;
        let result = grover
            .search(2, oracle, 1)
            .expect("Grover search should succeed");
        assert!(result.resource_stats.qubits_used > 0);
        assert!(result.resource_stats.gate_count > 0);
    }
    #[test]
    fn test_phase_estimation_resource_stats() {
        let config = QuantumAlgorithmConfig::default();
        let mut qpe =
            EnhancedPhaseEstimation::new(config).expect("Phase estimation creation should succeed");
        let eigenstate = Array1::from_vec(vec![Complex64::new(1.0, 0.0)]);
        let identity_op =
            |_sim: &mut StateVectorSimulator, _target: usize| -> Result<()> { Ok(()) };
        let result = qpe
            .estimate_eigenvalues(identity_op, &eigenstate, 1e-2)
            .expect("Phase estimation should succeed");
        assert!(result.resource_stats.qubits_used > 0);
    }
    #[test]
    fn test_config_defaults() {
        let config = QuantumAlgorithmConfig::default();
        assert_eq!(config.optimization_level, OptimizationLevel::Maximum);
        assert!(config.use_classical_preprocessing);
        assert!(config.enable_error_mitigation);
        assert_eq!(config.max_circuit_depth, 1000);
        assert!((config.precision_tolerance - 1e-10).abs() < 1e-15);
        assert!(config.enable_parallel);
    }
    #[test]
    fn test_shor_result_structure() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(6).expect("Factoring 6 should succeed");
        assert_eq!(result.n, 6);
        assert!(result.execution_time_ms >= 0.0);
        assert!(result.classical_preprocessing_ms >= 0.0);
        assert!(result.quantum_computation_ms >= 0.0);
        assert!(result.success_probability >= 0.0);
        assert!(result.success_probability <= 1.0);
    }
    #[test]
    fn test_grover_result_structure() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 0;
        let result = grover
            .search(2, oracle, 1)
            .expect("Grover search should succeed");
        assert!(result.resource_stats.qubits_used > 0);
        assert!(result.success_probability >= 0.0);
        assert!(result.success_probability <= 1.0);
        assert!(result.execution_time_ms >= 0.0);
    }
    #[test]
    fn test_modular_exponentiation_edge_cases() {
        let config = QuantumAlgorithmConfig::default();
        let _shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        assert_eq!(OptimizedShorAlgorithm::mod_exp(1, 100, 7), 1);
        assert_eq!(OptimizedShorAlgorithm::mod_exp(5, 0, 7), 1);
        assert_eq!(OptimizedShorAlgorithm::mod_exp(2, 10, 1024), 0);
    }
    #[test]
    fn test_continued_fractions_edge_cases() {
        let config = QuantumAlgorithmConfig::default();
        let _shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let convergents = OptimizedShorAlgorithm::continued_fractions(0.5, 10);
        assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 2));
        let convergents = OptimizedShorAlgorithm::continued_fractions(1.0 / 3.0, 20);
        assert!(convergents.iter().any(|&(num, den)| num == 1 && den == 3));
    }
    #[test]
    fn test_grover_iterations_scaling() {
        let config = QuantumAlgorithmConfig::default();
        let grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let iter_8 = grover.calculate_optimal_iterations(8, 1);
        let iter_32 = grover.calculate_optimal_iterations(32, 1);
        let ratio = iter_32 as f64 / iter_8 as f64;
        assert!((1.5..=2.5).contains(&ratio));
    }
    #[test]
    fn test_error_mitigation_disabled() {
        let config = QuantumAlgorithmConfig {
            enable_error_mitigation: false,
            ..Default::default()
        };
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 1;
        let result = grover.search(2, oracle, 1);
        assert!(result.is_ok());
    }
    #[test]
    fn test_parallel_disabled() {
        let config = QuantumAlgorithmConfig {
            enable_parallel: false,
            ..Default::default()
        };
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        let result = shor.factor(6);
        assert!(result.is_ok());
    }
    #[test]
    fn test_algorithm_resource_stats_default() {
        let stats = AlgorithmResourceStats::default();
        assert_eq!(stats.qubits_used, 0);
        assert_eq!(stats.gate_count, 0);
        assert_eq!(stats.circuit_depth, 0);
        assert_eq!(stats.cnot_count, 0);
        assert_eq!(stats.t_gate_count, 0);
        assert_eq!(stats.memory_usage_bytes, 0);
        assert_eq!(stats.measurement_count, 0);
    }
    #[test]
    fn test_shor_small_numbers() {
        let config = QuantumAlgorithmConfig::default();
        let mut shor =
            OptimizedShorAlgorithm::new(config).expect("Shor algorithm creation should succeed");
        for n in [4, 6, 8, 9, 10, 12] {
            let result = shor.factor(n);
            assert!(result.is_ok(), "Failed to factor {n}");
        }
    }
    #[test]
    fn test_grover_single_qubit() {
        let config = QuantumAlgorithmConfig::default();
        let mut grover = OptimizedGroverAlgorithm::new(config)
            .expect("Grover algorithm creation should succeed");
        let oracle = |x: usize| x == 1;
        let result = grover.search(1, oracle, 1);
        assert!(result.is_ok());
    }
}