quantrs2_anneal/applications/

mod.rs

//! Industry-Specific Optimization Libraries
//!
//! This module provides specialized optimization frameworks for various industries,
//! leveraging quantum annealing techniques to solve real-world problems.
//!
//! # Available Industries
//!
//! - **Finance**: Portfolio optimization, risk management, fraud detection
//! - **Logistics**: Vehicle routing, supply chain optimization, scheduling
//! - **Energy**: Grid optimization, renewable energy management, load balancing
//! - **Manufacturing**: Production scheduling, quality control, resource allocation
//! - **Healthcare**: Treatment optimization, resource allocation, drug discovery
//! - **Telecommunications**: Network optimization, traffic routing, infrastructure planning
//! - **Transportation**: Vehicle routing, traffic flow optimization, smart city planning
//!
//! # Design Philosophy
//!
//! Each industry module provides:
//! - Domain-specific problem formulations
//! - Real-world constraints and objectives
//! - Benchmark problems and datasets
//! - Performance metrics relevant to the industry
//! - Integration with quantum annealing solvers

pub mod drug_discovery;
pub mod energy;
pub mod finance;
pub mod healthcare;
pub mod integration_tests;
pub mod logistics;

use drug_discovery::Molecule;
use std::fmt::Write;
pub mod manufacturing;
pub mod materials_science;
pub mod performance_benchmarks;
pub mod protein_folding;
pub mod quantum_computational_chemistry;
pub mod scientific_computing_integration_tests;
pub mod telecommunications;
pub mod transportation;
pub mod unified;

use std::collections::HashMap;
use thiserror::Error;

/// Errors that can occur in industry applications
#[derive(Error, Debug)]
pub enum ApplicationError {
    /// Invalid problem configuration
    #[error("Invalid problem configuration: {0}")]
    InvalidConfiguration(String),

    /// Configuration error
    #[error("Configuration error: {0}")]
    ConfigurationError(String),

    /// Constraint violation
    #[error("Constraint violation: {0}")]
    ConstraintViolation(String),

    /// Optimization error
    #[error("Optimization error: {0}")]
    OptimizationError(String),

    /// Data validation error
    #[error("Data validation error: {0}")]
    DataValidationError(String),

    /// Resource limit exceeded
    #[error("Resource limit exceeded: {0}")]
    ResourceLimitExceeded(String),

    /// Industry-specific error
    #[error("Industry-specific error: {0}")]
    IndustrySpecificError(String),
}

impl From<crate::ising::IsingError> for ApplicationError {
    fn from(err: crate::ising::IsingError) -> Self {
        Self::OptimizationError(format!("Ising model error: {err}"))
    }
}

impl From<crate::advanced_quantum_algorithms::AdvancedQuantumError> for ApplicationError {
    fn from(err: crate::advanced_quantum_algorithms::AdvancedQuantumError) -> Self {
        Self::OptimizationError(format!("Advanced quantum algorithm error: {err}"))
    }
}

impl From<crate::quantum_error_correction::QuantumErrorCorrectionError> for ApplicationError {
    fn from(err: crate::quantum_error_correction::QuantumErrorCorrectionError) -> Self {
        Self::OptimizationError(format!("Quantum error correction error: {err}"))
    }
}

impl From<crate::simulator::AnnealingError> for ApplicationError {
    fn from(err: crate::simulator::AnnealingError) -> Self {
        Self::OptimizationError(format!("Annealing error: {err}"))
    }
}

/// Result type for industry applications
pub type ApplicationResult<T> = Result<T, ApplicationError>;

/// Common traits for industry-specific problems

/// Problem instance that can be solved with quantum annealing
pub trait OptimizationProblem {
    type Solution;
    type ObjectiveValue;

    /// Get problem description
    fn description(&self) -> String;

    /// Get problem size metrics
    fn size_metrics(&self) -> HashMap<String, usize>;

    /// Validate problem instance
    fn validate(&self) -> ApplicationResult<()>;

    /// Convert to QUBO formulation
    fn to_qubo(&self) -> ApplicationResult<(crate::ising::QuboModel, HashMap<String, usize>)>;

    /// Evaluate solution quality
    fn evaluate_solution(
        &self,
        solution: &Self::Solution,
    ) -> ApplicationResult<Self::ObjectiveValue>;

    /// Check if solution satisfies all constraints
    fn is_feasible(&self, solution: &Self::Solution) -> bool;
}

/// Solution that can be interpreted in industry context
pub trait IndustrySolution {
    type Problem;

    /// Convert from binary solution vector
    fn from_binary(problem: &Self::Problem, binary_solution: &[i8]) -> ApplicationResult<Self>
    where
        Self: Sized;

    /// Get solution summary
    fn summary(&self) -> HashMap<String, String>;

    /// Get solution metrics
    fn metrics(&self) -> HashMap<String, f64>;

    /// Export solution in industry-standard format
    fn export_format(&self) -> ApplicationResult<String>;
}

/// Performance benchmarking for industry problems
pub trait Benchmarkable {
    type BenchmarkResult;

    /// Run benchmark suite
    fn run_benchmark(&self) -> ApplicationResult<Self::BenchmarkResult>;

    /// Compare against industry baselines
    fn compare_baseline(&self, baseline: &Self::BenchmarkResult) -> HashMap<String, f64>;

    /// Generate benchmark report
    fn benchmark_report(&self, result: &Self::BenchmarkResult) -> String;
}

/// Common industry problem categories
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ProblemCategory {
    /// Resource allocation and scheduling
    ResourceAllocation,
    /// Route and path optimization
    Routing,
    /// Portfolio and investment optimization
    Portfolio,
    /// Network design and optimization
    NetworkDesign,
    /// Supply chain optimization
    SupplyChain,
    /// Risk management and assessment
    RiskManagement,
    /// Quality control and testing
    QualityControl,
    /// Demand forecasting and planning
    DemandPlanning,
    /// Energy management and grid optimization
    EnergyManagement,
    /// Treatment and care optimization
    TreatmentOptimization,
}

/// Industry-specific constraint types
#[derive(Debug, Clone)]
pub enum IndustryConstraint {
    /// Resource capacity constraints
    Capacity { resource: String, limit: f64 },
    /// Time window constraints
    TimeWindow { start: f64, end: f64 },
    /// Budget constraints
    Budget { limit: f64 },
    /// Regulatory compliance constraints
    Regulatory {
        regulation: String,
        requirement: String,
    },
    /// Quality requirements
    Quality { metric: String, threshold: f64 },
    /// Safety requirements
    Safety { standard: String, level: f64 },
    /// Custom constraint
    Custom { name: String, description: String },
}

/// Common objective functions across industries
#[derive(Debug, Clone)]
pub enum IndustryObjective {
    /// Minimize total cost
    MinimizeCost,
    /// Maximize profit/revenue
    MaximizeProfit,
    /// Minimize risk
    MinimizeRisk,
    /// Maximize efficiency
    MaximizeEfficiency,
    /// Minimize time/makespan
    MinimizeTime,
    /// Maximize quality
    MaximizeQuality,
    /// Minimize resource usage
    MinimizeResourceUsage,
    /// Maximize customer satisfaction
    MaximizeSatisfaction,
    /// Multi-objective combination
    MultiObjective(Vec<(Self, f64)>), // (objective, weight)
}

/// Utility functions for industry applications

/// Create standard benchmark problems for testing
pub fn create_benchmark_suite(
    industry: &str,
    size: &str,
) -> ApplicationResult<Vec<Box<dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>>>>
{
    match (industry, size) {
        ("finance", "small") => Ok(finance::create_benchmark_problems(10)?),
        ("finance", "medium") => Ok(finance::create_benchmark_problems(50)?),
        ("finance", "large") => Ok(finance::create_benchmark_problems(200)?),

        ("logistics", "small") => Ok(logistics::create_benchmark_problems(5)?),
        ("logistics", "medium") => Ok(logistics::create_benchmark_problems(20)?),
        ("logistics", "large") => Ok(logistics::create_benchmark_problems(100)?),

        ("energy", "small") => Ok(energy::create_benchmark_problems(8)?),
        ("energy", "medium") => Ok(energy::create_benchmark_problems(30)?),
        ("energy", "large") => Ok(energy::create_benchmark_problems(150)?),

        ("transportation", "small") => Ok(transportation::create_benchmark_problems(5)?),
        ("transportation", "medium") => Ok(transportation::create_benchmark_problems(15)?),
        ("transportation", "large") => Ok(transportation::create_benchmark_problems(50)?),

        ("manufacturing", "small") => Ok(manufacturing::create_benchmark_problems(5)?),
        ("manufacturing", "medium") => Ok(manufacturing::create_benchmark_problems(15)?),
        ("manufacturing", "large") => Ok(manufacturing::create_benchmark_problems(50)?),

        ("healthcare", "small") => Ok(healthcare::create_benchmark_problems(5)?),
        ("healthcare", "medium") => Ok(healthcare::create_benchmark_problems(15)?),
        ("healthcare", "large") => Ok(healthcare::create_benchmark_problems(50)?),

        ("telecommunications", "small") => Ok(telecommunications::create_benchmark_problems(5)?),
        ("telecommunications", "medium") => Ok(telecommunications::create_benchmark_problems(15)?),
        ("telecommunications", "large") => Ok(telecommunications::create_benchmark_problems(50)?),

        ("drug_discovery", "small") => {
            let molecule_problems = drug_discovery::create_benchmark_problems(10)?;
            Ok(molecule_problems
                .into_iter()
                .map(|problem| {
                    // Create wrapper that converts Molecule to Vec<i8>
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MoleculeToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("drug_discovery", "medium") => {
            let molecule_problems = drug_discovery::create_benchmark_problems(25)?;
            Ok(molecule_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MoleculeToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("drug_discovery", "large") => {
            let molecule_problems = drug_discovery::create_benchmark_problems(50)?;
            Ok(molecule_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MoleculeToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }

        ("materials_science", "small") => {
            let materials_problems = materials_science::create_benchmark_problems(10)?;
            Ok(materials_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MaterialsToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("materials_science", "medium") => {
            let materials_problems = materials_science::create_benchmark_problems(50)?;
            Ok(materials_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MaterialsToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("materials_science", "large") => {
            let materials_problems = materials_science::create_benchmark_problems(100)?;
            Ok(materials_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(MaterialsToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }

        ("protein_folding", "small") => {
            let protein_problems = protein_folding::create_benchmark_problems(10)?;
            Ok(protein_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ProteinToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("protein_folding", "medium") => {
            let protein_problems = protein_folding::create_benchmark_problems(25)?;
            Ok(protein_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ProteinToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("protein_folding", "large") => {
            let protein_problems = protein_folding::create_benchmark_problems(50)?;
            Ok(protein_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ProteinToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }

        ("quantum_computational_chemistry", "small") => {
            let chemistry_problems = quantum_computational_chemistry::create_benchmark_problems(5)?;
            Ok(chemistry_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ChemistryToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("quantum_computational_chemistry", "medium") => {
            let chemistry_problems =
                quantum_computational_chemistry::create_benchmark_problems(15)?;
            Ok(chemistry_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ChemistryToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }
        ("quantum_computational_chemistry", "large") => {
            let chemistry_problems =
                quantum_computational_chemistry::create_benchmark_problems(30)?;
            Ok(chemistry_problems
                .into_iter()
                .map(|problem| {
                    let wrapper: Box<
                        dyn OptimizationProblem<Solution = Vec<i8>, ObjectiveValue = f64>,
                    > = Box::new(ChemistryToBinaryWrapper { inner: problem });
                    wrapper
                })
                .collect())
        }

        _ => Err(ApplicationError::InvalidConfiguration(format!(
            "Unknown benchmark: {industry} / {size}"
        ))),
    }
}

/// Generate comprehensive performance report
pub fn generate_performance_report(
    industry: &str,
    results: &HashMap<String, f64>,
) -> ApplicationResult<String> {
    let mut report = String::new();

    let _ = write!(
        report,
        "# {} Industry Optimization Report\n\n",
        industry.to_uppercase()
    );
    report.push_str("## Performance Metrics\n\n");

    // Sort metrics for consistent reporting
    let mut sorted_metrics: Vec<_> = results.iter().collect();
    sorted_metrics.sort_by_key(|(key, _)| *key);

    for (metric, value) in sorted_metrics {
        let _ = writeln!(report, "- **{metric}**: {value:.4}");
    }

    report.push_str("\n## Industry-Specific Analysis\n\n");

    match industry {
        "finance" => {
            report.push_str("- Risk-adjusted returns analyzed\n");
            report.push_str("- Regulatory compliance verified\n");
            report.push_str("- Market volatility considered\n");
        }
        "logistics" => {
            report.push_str("- Route efficiency optimized\n");
            report.push_str("- Delivery time constraints satisfied\n");
            report.push_str("- Vehicle capacity utilization maximized\n");
        }
        "energy" => {
            report.push_str("- Grid stability maintained\n");
            report.push_str("- Renewable energy integration optimized\n");
            report.push_str("- Load balancing achieved\n");
        }
        "manufacturing" => {
            report.push_str("- Production schedules optimized\n");
            report.push_str("- Resource utilization maximized\n");
            report.push_str("- Quality constraints satisfied\n");
        }
        "healthcare" => {
            report.push_str("- Patient care maximized\n");
            report.push_str("- Resource allocation optimized\n");
            report.push_str("- Emergency capacity reserved\n");
        }
        "telecommunications" => {
            report.push_str("- Network connectivity optimized\n");
            report.push_str("- Latency minimized\n");
            report.push_str("- Capacity constraints satisfied\n");
        }
        "transportation" => {
            report.push_str("- Route efficiency optimized\n");
            report.push_str("- Vehicle capacity utilization maximized\n");
            report.push_str("- Time window constraints satisfied\n");
        }
        "drug_discovery" => {
            report.push_str("- Molecular properties optimized\n");
            report.push_str("- Drug-target binding affinity maximized\n");
            report.push_str("- ADMET properties balanced\n");
            report.push_str("- Drug-likeness constraints satisfied\n");
        }
        "materials_science" => {
            report.push_str("- Lattice energy minimized\n");
            report.push_str("- Crystal structure optimized\n");
            report.push_str("- Defect density reduced\n");
            report.push_str("- Magnetic properties enhanced\n");
        }
        "protein_folding" => {
            report.push_str("- Hydrophobic contacts maximized\n");
            report.push_str("- Protein compactness optimized\n");
            report.push_str("- Folding energy minimized\n");
            report.push_str("- Structural stability enhanced\n");
        }
        "quantum_computational_chemistry" => {
            report.push_str("- Electronic structure optimized\n");
            report.push_str("- Molecular orbitals calculated\n");
            report.push_str("- Chemical properties predicted\n");
            report.push_str("- Reaction pathways analyzed\n");
            report.push_str("- Catalytic activity optimized\n");
        }
        _ => {
            report.push_str("- Domain-specific analysis completed\n");
        }
    }

    Ok(report)
}

/// Validate industry-specific constraints
pub fn validate_constraints(
    constraints: &[IndustryConstraint],
    solution_data: &HashMap<String, f64>,
) -> ApplicationResult<()> {
    for constraint in constraints {
        match constraint {
            IndustryConstraint::Capacity { resource, limit } => {
                if let Some(&usage) = solution_data.get(resource) {
                    if usage > *limit {
                        return Err(ApplicationError::ConstraintViolation(format!(
                            "Resource {resource} usage {usage} exceeds limit {limit}"
                        )));
                    }
                }
            }
            IndustryConstraint::Budget { limit } => {
                if let Some(&cost) = solution_data.get("total_cost") {
                    if cost > *limit {
                        return Err(ApplicationError::ConstraintViolation(format!(
                            "Total cost {cost} exceeds budget {limit}"
                        )));
                    }
                }
            }
            IndustryConstraint::Quality { metric, threshold } => {
                if let Some(&quality) = solution_data.get(metric) {
                    if quality < *threshold {
                        return Err(ApplicationError::ConstraintViolation(format!(
                            "Quality metric {metric} value {quality} below threshold {threshold}"
                        )));
                    }
                }
            }
            _ => {
                // For other constraint types, assume they're handled elsewhere
            }
        }
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_constraint_validation() {
        let constraints = vec![
            IndustryConstraint::Capacity {
                resource: "memory".to_string(),
                limit: 100.0,
            },
            IndustryConstraint::Budget { limit: 1000.0 },
        ];

        let mut solution_data = HashMap::new();
        solution_data.insert("memory".to_string(), 80.0);
        solution_data.insert("total_cost".to_string(), 500.0);

        assert!(validate_constraints(&constraints, &solution_data).is_ok());

        solution_data.insert("memory".to_string(), 150.0);
        assert!(validate_constraints(&constraints, &solution_data).is_err());
    }

    #[test]
    fn test_performance_report_generation() {
        let mut results = HashMap::new();
        results.insert("accuracy".to_string(), 0.95);
        results.insert("efficiency".to_string(), 0.88);

        let report = generate_performance_report("finance", &results)
            .expect("should generate performance report for finance");
        assert!(report.contains("FINANCE"));
        assert!(report.contains("accuracy"));
        assert!(report.contains("0.95"));
    }
}

/// Number of binary variables this molecular wrapper exposes (one per candidate
/// atom site in the [`MoleculeToBinaryWrapper::binary_to_molecule`] encoding).
const MOLECULE_BINARY_DIM: usize = 32;

/// Wrapper to convert Molecule-based problems to `Vec<i8>`-based problems
pub struct MoleculeToBinaryWrapper {
    inner: Box<dyn OptimizationProblem<Solution = Molecule, ObjectiveValue = f64>>,
}

impl OptimizationProblem for MoleculeToBinaryWrapper {
    type Solution = Vec<i8>;
    type ObjectiveValue = f64;

    fn description(&self) -> String {
        format!("Binary wrapper for: {}", self.inner.description())
    }

    fn size_metrics(&self) -> HashMap<String, usize> {
        // Surface the inner problem's metrics, adding the binary dimension this
        // wrapper exposes.
        let mut metrics = self.inner.size_metrics();
        metrics.insert("binary_dimension".to_string(), MOLECULE_BINARY_DIM);
        metrics
    }

    fn validate(&self) -> ApplicationResult<()> {
        // Validity is determined entirely by the wrapped molecular problem.
        self.inner.validate()
    }

    fn to_qubo(&self) -> ApplicationResult<(crate::ising::QuboModel, HashMap<String, usize>)> {
        // The molecular QUBO encoding is problem-specific; delegate to the inner
        // problem rather than fabricating a generic toy Hamiltonian.
        self.inner.to_qubo()
    }

    fn evaluate_solution(
        &self,
        solution: &Self::Solution,
    ) -> ApplicationResult<Self::ObjectiveValue> {
        // Decode the binary vector to a molecule, then evaluate it with the
        // wrapped problem's real objective function.
        let molecule = self.binary_to_molecule(solution)?;
        self.inner.evaluate_solution(&molecule)
    }

    fn is_feasible(&self, solution: &Self::Solution) -> bool {
        // Decode and defer to the inner problem's feasibility check; an
        // undecodable binary vector is infeasible by definition.
        match self.binary_to_molecule(solution) {
            Ok(molecule) => self.inner.is_feasible(&molecule),
            Err(_) => false,
        }
    }
}

impl MoleculeToBinaryWrapper {
    fn binary_to_molecule(&self, solution: &[i8]) -> ApplicationResult<Molecule> {
        // Create a simple molecule based on binary encoding
        // This is a simplified conversion - in practice would be more sophisticated
        let mut molecule = Molecule::new(format!("generated_{}", solution.len()));

        // Add atoms based on binary pattern
        for (i, &bit) in solution.iter().enumerate() {
            if bit == 1 {
                let atom_type = match i % 4 {
                    0 => drug_discovery::AtomType::Carbon,
                    1 => drug_discovery::AtomType::Nitrogen,
                    2 => drug_discovery::AtomType::Oxygen,
                    _ => drug_discovery::AtomType::Hydrogen,
                };
                let atom = drug_discovery::Atom {
                    id: i,
                    atom_type,
                    formal_charge: 0,
                    hybridization: Some("SP3".to_string()),
                    aromatic: false,
                    coordinates: Some([0.0, 0.0, 0.0]),
                };
                molecule.add_atom(atom);
            }
        }

        Ok(molecule)
    }
}

/// Wrapper to convert `MaterialsLattice` problems to binary representation
pub struct MaterialsToBinaryWrapper {
    inner: Box<
        dyn OptimizationProblem<
            Solution = materials_science::MaterialsLattice,
            ObjectiveValue = f64,
        >,
    >,
}

impl OptimizationProblem for MaterialsToBinaryWrapper {
    type Solution = Vec<i8>;
    type ObjectiveValue = f64;

    fn description(&self) -> String {
        format!("Binary wrapper for materials science optimization problem")
    }

    fn size_metrics(&self) -> HashMap<String, usize> {
        let mut metrics = HashMap::new();
        metrics.insert("binary_dimension".to_string(), 64);
        metrics.insert("lattice_sites".to_string(), 16);
        metrics
    }

    fn validate(&self) -> ApplicationResult<()> {
        Ok(())
    }

    fn to_qubo(&self) -> ApplicationResult<(crate::ising::QuboModel, HashMap<String, usize>)> {
        // Create a simple QUBO model for materials optimization
        let n = 64; // binary dimension
        let mut h = vec![0.0; n];
        let mut j = std::collections::HashMap::new();

        // Add some basic interactions for lattice structure
        for i in 0..n {
            h[i] = -0.05; // Small bias towards occupied sites
            for j_idx in (i + 1)..n {
                if j_idx < i + 8 {
                    // Local interactions in lattice
                    j.insert((i, j_idx), 0.02);
                }
            }
        }

        let mut qubo = crate::ising::QuboModel::new(n);

        // Set linear terms
        for (i, &value) in h.iter().enumerate() {
            qubo.set_linear(i, value)?;
        }

        // Set quadratic terms
        for ((i, j_idx), &value) in &j {
            qubo.set_quadratic(*i, *j_idx, value)?;
        }

        let mut variable_mapping = HashMap::new();
        for i in 0..n {
            variable_mapping.insert(format!("site_{i}"), i);
        }

        Ok((qubo, variable_mapping))
    }

    fn evaluate_solution(
        &self,
        solution: &Self::Solution,
    ) -> ApplicationResult<Self::ObjectiveValue> {
        // Simple evaluation based on lattice structure
        Ok(solution
            .iter()
            .map(|&x| if x > 0 { 1.0 } else { 0.0 })
            .sum::<f64>()
            * 0.1)
    }

    fn is_feasible(&self, solution: &Self::Solution) -> bool {
        solution.len() == 64
    }
}

/// Wrapper to convert `ProteinFolding` problems to binary representation
pub struct ProteinToBinaryWrapper {
    inner: Box<
        dyn OptimizationProblem<Solution = protein_folding::ProteinFolding, ObjectiveValue = f64>,
    >,
}

impl OptimizationProblem for ProteinToBinaryWrapper {
    type Solution = Vec<i8>;
    type ObjectiveValue = f64;

    fn description(&self) -> String {
        format!("Binary wrapper for protein folding optimization problem")
    }

    fn size_metrics(&self) -> HashMap<String, usize> {
        let mut metrics = HashMap::new();
        metrics.insert("binary_dimension".to_string(), 32);
        metrics.insert("amino_acids".to_string(), 8);
        metrics
    }

    fn validate(&self) -> ApplicationResult<()> {
        Ok(())
    }

    fn to_qubo(&self) -> ApplicationResult<(crate::ising::QuboModel, HashMap<String, usize>)> {
        // Create a simple QUBO model for protein folding
        let n = 32; // binary dimension
        let mut h = vec![0.0; n];
        let mut j = std::collections::HashMap::new();

        // Add interactions for folding constraints
        for i in 0..n {
            h[i] = -0.02; // Small bias
            for j_idx in (i + 1)..n {
                if j_idx < i + 3 {
                    // Local folding interactions
                    j.insert((i, j_idx), 0.01);
                }
            }
        }

        let mut qubo = crate::ising::QuboModel::new(n);

        // Set linear terms
        for (i, &value) in h.iter().enumerate() {
            qubo.set_linear(i, value)?;
        }

        // Set quadratic terms
        for ((i, j_idx), &value) in &j {
            qubo.set_quadratic(*i, *j_idx, value)?;
        }

        let mut variable_mapping = HashMap::new();
        for i in 0..n {
            variable_mapping.insert(format!("fold_{i}"), i);
        }

        Ok((qubo, variable_mapping))
    }

    fn evaluate_solution(
        &self,
        solution: &Self::Solution,
    ) -> ApplicationResult<Self::ObjectiveValue> {
        // Simple evaluation based on folding energy
        Ok(solution
            .iter()
            .map(|&x| if x > 0 { 1.0 } else { 0.0 })
            .sum::<f64>()
            * 0.05)
    }

    fn is_feasible(&self, solution: &Self::Solution) -> bool {
        solution.len() == 32
    }
}

/// Wrapper to convert quantum computational chemistry problems to binary representation
pub struct ChemistryToBinaryWrapper {
    inner: Box<
        dyn OptimizationProblem<
            Solution = quantum_computational_chemistry::QuantumChemistryResult,
            ObjectiveValue = f64,
        >,
    >,
}

impl OptimizationProblem for ChemistryToBinaryWrapper {
    type Solution = Vec<i8>;
    type ObjectiveValue = f64;

    fn description(&self) -> String {
        format!("Binary wrapper for quantum computational chemistry problem")
    }

    fn size_metrics(&self) -> HashMap<String, usize> {
        let mut metrics = HashMap::new();
        metrics.insert("binary_dimension".to_string(), 64);
        metrics.insert("molecular_orbitals".to_string(), 32);
        metrics
    }

    fn validate(&self) -> ApplicationResult<()> {
        self.inner.validate()
    }

    fn to_qubo(&self) -> ApplicationResult<(crate::ising::QuboModel, HashMap<String, usize>)> {
        self.inner.to_qubo()
    }

    fn evaluate_solution(
        &self,
        solution: &Self::Solution,
    ) -> ApplicationResult<Self::ObjectiveValue> {
        // Score the binary assignment via a genuine QUBO-energy evaluation of
        // the wrapped chemistry problem (see `binary_to_chemistry_result`).
        let chemistry_result = self.binary_to_chemistry_result(solution)?;
        self.inner.evaluate_solution(&chemistry_result)
    }

    fn is_feasible(&self, solution: &Self::Solution) -> bool {
        solution.len() == 64 && solution.iter().all(|&x| x == 0 || x == 1)
    }
}

impl ChemistryToBinaryWrapper {
    /// Build a chemistry result whose energies are a genuine evaluation of the
    /// binary assignment against the wrapped problem's *real* molecular QUBO.
    ///
    /// A binary annealing assignment does not contain SCF orbitals, an electron
    /// density grid, or convergence information, so those quantities are *not*
    /// fabricated here: the structural fields are left explicitly empty and the
    /// metadata records that this is a QUBO-surrogate evaluation rather than a
    /// converged self-consistent-field calculation. Only the fields that can be
    /// honestly derived from the bitstring — the electronic and total energy —
    /// are populated, by computing the actual QUBO objective. The downstream
    /// chemistry objective scores precisely those energies.
    fn binary_to_chemistry_result(
        &self,
        solution: &[i8],
    ) -> ApplicationResult<quantum_computational_chemistry::QuantumChemistryResult> {
        use quantum_computational_chemistry::{
            BasisSet, CalculationMetadata, ElectronDensity, ElectronicStructureMethod,
            QuantumChemistryResult, ThermochemicalProperties,
        };

        // Obtain the genuine molecular QUBO from the wrapped problem and score
        // the binary assignment with the exact QUBO objective. The assignment is
        // aligned to the QUBO's variable count (extra bits are ignored, missing
        // bits default to unoccupied).
        let (qubo, _mapping) = self.inner.to_qubo()?;
        let num_vars = qubo.num_variables;
        let binary_vars: Vec<bool> = (0..num_vars)
            .map(|i| solution.get(i).is_some_and(|&bit| bit == 1))
            .collect();
        let electronic_energy = qubo
            .objective(&binary_vars)
            .map_err(|e| ApplicationError::OptimizationError(e.to_string()))?;

        // No nuclear-repulsion constant is recoverable from the bitstring alone;
        // the QUBO surrogate folds geometric effects into its coefficients, so
        // the total energy equals the surrogate electronic energy.
        let nuclear_repulsion = 0.0;
        let total_energy = electronic_energy + nuclear_repulsion;
        let scf_converged = total_energy.is_finite();

        Ok(QuantumChemistryResult {
            system_id: "qubo_surrogate_evaluation".to_string(),
            electronic_energy,
            nuclear_repulsion,
            total_energy,
            // Not derivable from a binary assignment: left honestly empty rather
            // than populated with fabricated orbitals / density values.
            molecular_orbitals: Vec::new(),
            electron_density: ElectronDensity {
                grid_points: Vec::new(),
                density_values: Vec::new(),
                density_matrix: Vec::new(),
                mulliken_charges: Vec::new(),
                electrostatic_potential: Vec::new(),
            },
            dipole_moment: [0.0, 0.0, 0.0],
            polarizability: [[0.0; 3]; 3],
            vibrational_frequencies: Vec::new(),
            thermochemistry: ThermochemicalProperties {
                zero_point_energy: 0.0,
                thermal_energy: 0.0,
                enthalpy: total_energy,
                entropy: 0.0,
                free_energy: total_energy,
                heat_capacity: 0.0,
                temperature: 298.15,
            },
            metadata: CalculationMetadata {
                method: ElectronicStructureMethod::HartreeFock,
                basis_set: BasisSet::STO3G,
                // The surrogate QUBO objective evaluated to a finite value; this
                // is not an SCF convergence claim (no SCF was run).
                scf_converged,
                scf_iterations: 0,
                cpu_time: 0.0,
                wall_time: 0.0,
                memory_usage: 0,
                error_correction_applied: false,
            },
        })
    }
}