quantrs2_anneal/hardware_compilation/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::embedding::{EmbeddingError, EmbeddingResult};
6use crate::ising::{IsingError, IsingModel};
7use crate::qubo::{QuboError, QuboFormulation};
8use crate::simulator::{AnnealingParams, AnnealingSolution};
9use scirs2_core::random::{ChaCha8Rng, Rng, SeedableRng};
10use scirs2_core::RngExt;
11use std::collections::{HashMap, HashSet, VecDeque};
12use std::time::{Duration, Instant};
13use thiserror::Error;
14
15use super::functions::{HardwareCompilationResult, PerformanceModel};
16
17/// Compilation metadata
18#[derive(Debug, Clone)]
19pub struct CompilationMetadata {
20    /// Compilation time
21    pub compilation_time: Duration,
22    /// Optimization iterations performed
23    pub optimization_iterations: usize,
24    /// Compilation algorithm used
25    pub compilation_algorithm: String,
26    /// Resource usage during compilation
27    pub compilation_resources: HashMap<String, f64>,
28    /// Warnings and diagnostics
29    pub warnings: Vec<String>,
30    /// Optimization trace
31    pub optimization_trace: Vec<OptimizationStep>,
32}
33/// Compilation constraints
34#[derive(Debug, Clone)]
35pub enum CompilationConstraint {
36    /// Maximum compilation time
37    MaxCompilationTime(Duration),
38    /// Maximum problem size
39    MaxProblemSize(usize),
40    /// Required solution quality threshold
41    MinQualityThreshold(f64),
42    /// Resource usage limits
43    ResourceUsageLimits(HashMap<String, f64>),
44    /// Embedding constraints
45    EmbeddingConstraints(EmbeddingConstraints),
46}
47/// Embedding algorithms
48#[derive(Debug, Clone, PartialEq)]
49pub enum EmbeddingAlgorithm {
50    /// Minorminer-style algorithm
51    MinorMiner,
52    /// Clique-based embedding
53    Clique,
54    /// Layered embedding
55    Layered,
56    /// Spectral embedding
57    Spectral,
58    /// Machine learning guided embedding
59    MLGuided,
60    /// Hybrid approach
61    Hybrid(Vec<Self>),
62}
63/// Types of quantum annealing hardware
64#[derive(Debug, Clone, PartialEq)]
65pub enum HardwareType {
66    /// D-Wave systems with Chimera topology
67    DWaveChimera {
68        unit_cells: (usize, usize),
69        cell_size: usize,
70    },
71    /// D-Wave systems with Pegasus topology
72    DWavePegasus {
73        layers: usize,
74        nodes_per_layer: usize,
75    },
76    /// D-Wave systems with Zephyr topology
77    DWaveZephyr {
78        layers: usize,
79        tiles_per_layer: usize,
80    },
81    /// Neutral atom quantum annealing systems
82    NeutralAtom {
83        grid_size: (usize, usize),
84        connectivity: ConnectivityPattern,
85    },
86    /// Superconducting flux qubit systems
87    SuperconductingFlux {
88        topology: TopologyType,
89        num_qubits: usize,
90    },
91    /// Photonic quantum annealing systems
92    Photonic {
93        mode_count: usize,
94        coupling_graph: Vec<Vec<bool>>,
95    },
96    /// Custom hardware topology
97    Custom {
98        adjacency_matrix: Vec<Vec<bool>>,
99        characteristics: HardwareCharacteristics,
100    },
101    /// Simulated ideal hardware
102    Ideal { num_qubits: usize },
103}
104/// Resource utilization information
105#[derive(Debug, Clone)]
106pub struct ResourceUtilization {
107    /// Fraction of qubits used
108    pub qubit_utilization: f64,
109    /// Fraction of couplings used
110    pub coupling_utilization: f64,
111    /// Control resource usage
112    pub control_resource_usage: HashMap<String, f64>,
113    /// Estimated energy consumption
114    pub estimated_energy: f64,
115}
116/// Problem structure types
117#[derive(Debug, Clone, PartialEq, Eq)]
118pub enum ProblemStructure {
119    /// Sparse connectivity
120    Sparse,
121    /// Dense connectivity
122    Dense,
123    /// Structured (e.g., grid, tree)
124    Structured,
125    /// Random
126    Random,
127}
128/// Optimization objectives for compilation
129#[derive(Debug, Clone, PartialEq)]
130pub enum OptimizationObjective {
131    /// Minimize time to solution
132    MinimizeTime { weight: f64 },
133    /// Maximize solution quality
134    MaximizeQuality { weight: f64 },
135    /// Minimize energy consumption
136    MinimizeEnergy { weight: f64 },
137    /// Maximize success probability
138    MaximizeSuccessProbability { weight: f64 },
139    /// Minimize hardware resource usage
140    MinimizeResourceUsage { weight: f64 },
141    /// Maximize reproducibility
142    MaximizeReproducibility { weight: f64 },
143}
144/// Parallelization strategies
145#[derive(Debug, Clone, PartialEq, Eq)]
146pub enum ParallelizationStrategy {
147    /// No parallelization
148    None,
149    /// Parallel embedding search
150    ParallelEmbedding,
151    /// Parallel parameter optimization
152    ParallelParameterSearch,
153    /// Full pipeline parallelization
154    FullPipeline,
155}
156/// Chain representation in embedding
157#[derive(Debug, Clone)]
158pub struct Chain {
159    /// Logical variable
160    pub logical_variable: usize,
161    /// Physical qubits in chain
162    pub physical_qubits: Vec<usize>,
163    /// Chain strength
164    pub chain_strength: f64,
165    /// Chain connectivity
166    pub connectivity: f64,
167}
168/// Coupling utilization strategies
169#[derive(Debug, Clone, PartialEq, Eq)]
170pub enum CouplingUtilization {
171    /// Conservative usage (high reliability)
172    Conservative,
173    /// Aggressive usage (maximum performance)
174    Aggressive,
175    /// Balanced usage
176    Balanced,
177    /// Adaptive based on problem characteristics
178    Adaptive,
179}
180/// Optimization step in compilation
181#[derive(Debug, Clone)]
182pub struct OptimizationStep {
183    /// Step description
184    pub description: String,
185    /// Objective value achieved
186    pub objective_value: f64,
187    /// Parameters at this step
188    pub parameters: HashMap<String, f64>,
189    /// Time taken for this step
190    pub step_time: Duration,
191}
192/// Embedding constraints for compilation
193#[derive(Debug, Clone)]
194pub struct EmbeddingConstraints {
195    /// Maximum chain length
196    pub max_chain_length: Option<usize>,
197    /// Preferred embedding algorithms
198    pub preferred_algorithms: Vec<EmbeddingAlgorithm>,
199    /// Chain strength optimization
200    pub chain_strength_optimization: bool,
201    /// Embedding quality thresholds
202    pub quality_thresholds: EmbeddingQualityThresholds,
203}
204/// Coupling strength ranges between qubits
205#[derive(Debug, Clone, PartialEq)]
206pub struct CouplingRange {
207    /// Minimum coupling strength
208    pub min_strength: f64,
209    /// Maximum coupling strength
210    pub max_strength: f64,
211    /// Coupling fidelity
212    pub fidelity: f64,
213    /// Crosstalk characteristics
214    pub crosstalk: f64,
215}
216/// Qubit allocation strategies
217#[derive(Debug, Clone, PartialEq, Eq)]
218pub enum QubitAllocationStrategy {
219    /// Minimize total qubits used
220    MinimizeCount,
221    /// Maximize connectivity
222    MaximizeConnectivity,
223    /// Balance load across hardware
224    LoadBalance,
225    /// Prefer high-fidelity qubits
226    PreferHighFidelity,
227    /// Custom allocation function
228    Custom,
229}
230/// Performance prediction for compiled problem
231#[derive(Debug, Clone)]
232pub struct PerformancePrediction {
233    /// Predicted success probability
234    pub success_probability: f64,
235    /// Predicted solution quality
236    pub solution_quality: f64,
237    /// Predicted time to solution
238    pub time_to_solution: f64,
239    /// Confidence intervals
240    pub confidence_intervals: HashMap<String, (f64, f64)>,
241    /// Sensitivity analysis
242    pub sensitivity_analysis: SensitivityAnalysis,
243}
244/// Temperature profile during annealing
245#[derive(Debug, Clone, PartialEq)]
246pub struct TemperatureProfile {
247    /// Initial temperature
248    pub initial_temp: f64,
249    /// Final temperature
250    pub final_temp: f64,
251    /// Temperature control precision
252    pub temp_precision: f64,
253    /// Cooling rate limits
254    pub cooling_rate_limits: (f64, f64),
255}
256/// Hardware-specific constraints
257#[derive(Debug, Clone, PartialEq)]
258pub enum HardwareConstraint {
259    /// Maximum number of active qubits
260    MaxActiveQubits(usize),
261    /// Maximum coupling strength
262    MaxCouplingStrength(f64),
263    /// Minimum annealing time
264    MinAnnealingTime(f64),
265    /// Maximum annealing time
266    MaxAnnealingTime(f64),
267    /// Forbidden qubit pairs
268    ForbiddenPairs(Vec<(usize, usize)>),
269    /// Required calibration frequency
270    CalibrationFrequency(Duration),
271    /// Temperature stability requirements
272    TemperatureStability(f64),
273}
274/// Compilation result containing optimized problem and metadata
275#[derive(Debug, Clone)]
276pub struct CompilationResult {
277    /// Compiled Ising model
278    pub compiled_ising: IsingModel,
279    /// Embedding information
280    pub embedding: EmbeddingInfo,
281    /// Optimized annealing parameters
282    pub annealing_params: AnnealingParams,
283    /// Hardware mapping
284    pub hardware_mapping: HardwareMapping,
285    /// Performance predictions
286    pub performance_prediction: PerformancePrediction,
287    /// Compilation metadata
288    pub metadata: CompilationMetadata,
289}
290/// Sensitivity analysis results
291#[derive(Debug, Clone)]
292pub struct SensitivityAnalysis {
293    /// Parameter sensitivities
294    pub parameter_sensitivities: HashMap<String, f64>,
295    /// Noise sensitivity
296    pub noise_sensitivity: f64,
297    /// Temperature sensitivity
298    pub temperature_sensitivity: f64,
299    /// Robustness measures
300    pub robustness_measures: HashMap<String, f64>,
301}
302/// Qubit noise characteristics
303#[derive(Debug, Clone, PartialEq)]
304pub struct QubitNoise {
305    /// Coherence time (T1)
306    pub t1: f64,
307    /// Dephasing time (T2)
308    pub t2: f64,
309    /// Gate fidelity
310    pub gate_fidelity: f64,
311    /// Bias noise
312    pub bias_noise: f64,
313    /// Readout fidelity
314    pub readout_fidelity: f64,
315}
316/// Errors that can occur in hardware compilation
317#[derive(Error, Debug)]
318pub enum HardwareCompilationError {
319    /// Ising model error
320    #[error("Ising error: {0}")]
321    IsingError(#[from] IsingError),
322    /// QUBO formulation error
323    #[error("QUBO error: {0}")]
324    QuboError(#[from] QuboError),
325    /// Embedding error
326    #[error("Embedding error: {0}")]
327    EmbeddingError(#[from] EmbeddingError),
328    /// Hardware topology error
329    #[error("Hardware topology error: {0}")]
330    TopologyError(String),
331    /// Compilation error
332    #[error("Compilation error: {0}")]
333    CompilationError(String),
334    /// Optimization error
335    #[error("Optimization error: {0}")]
336    OptimizationError(String),
337    /// Hardware characterization error
338    #[error("Hardware characterization error: {0}")]
339    CharacterizationError(String),
340    /// Invalid configuration
341    #[error("Invalid configuration: {0}")]
342    InvalidConfiguration(String),
343    /// Performance prediction error
344    #[error("Performance prediction error: {0}")]
345    PredictionError(String),
346}
347/// Hardware mapping information
348#[derive(Debug, Clone)]
349pub struct HardwareMapping {
350    /// Qubit assignments
351    pub qubit_assignments: HashMap<usize, usize>,
352    /// Coupling assignments
353    pub coupling_assignments: HashMap<(usize, usize), (usize, usize)>,
354    /// Resource utilization
355    pub resource_utilization: ResourceUtilization,
356    /// Hardware constraints satisfied
357    pub constraints_satisfied: Vec<bool>,
358}
359/// Actual performance data for model training
360#[derive(Debug, Clone)]
361pub struct PerformanceData {
362    /// Measured success probability
363    pub success_probability: f64,
364    /// Measured solution quality
365    pub solution_quality: f64,
366    /// Measured time to solution
367    pub time_to_solution: f64,
368    /// Additional metrics
369    pub additional_metrics: HashMap<String, f64>,
370}
371/// Simple machine learning performance model
372pub struct MLPerformanceModel {
373    /// Model parameters
374    parameters: HashMap<String, f64>,
375    /// Training data
376    pub(super) training_data: Vec<(Vec<f64>, PerformanceData)>,
377    /// Model confidence
378    pub(super) confidence: f64,
379}
380impl MLPerformanceModel {
381    /// Create a new ML performance model
382    #[must_use]
383    pub fn new() -> Self {
384        Self {
385            parameters: HashMap::new(),
386            training_data: Vec::new(),
387            confidence: 0.5,
388        }
389    }
390    /// Extract features from problem and embedding
391    pub(crate) fn extract_features(
392        &self,
393        problem: &IsingModel,
394        embedding: &EmbeddingInfo,
395        hardware: &HardwareCharacteristics,
396    ) -> Vec<f64> {
397        let mut features = Vec::new();
398        features.push(problem.num_qubits as f64);
399        features.push(embedding.chains.len() as f64);
400        features.push(embedding.quality_metrics.avg_chain_length);
401        features.push(embedding.quality_metrics.efficiency);
402        features.push(hardware.num_qubits as f64);
403        features.push(hardware.performance_metrics.success_probability);
404        features.push(hardware.performance_metrics.solution_quality);
405        let connectivity_density = hardware
406            .connectivity
407            .iter()
408            .flatten()
409            .filter(|&&connected| connected)
410            .count() as f64
411            / (hardware.num_qubits * hardware.num_qubits) as f64;
412        features.push(connectivity_density);
413        features
414    }
415}
416/// Hardware-aware compiler
417pub struct HardwareCompiler {
418    /// Target hardware specifications
419    target_hardware: CompilationTarget,
420    /// Compilation configuration
421    config: CompilerConfig,
422    /// Cache for embedding results
423    embedding_cache: HashMap<String, EmbeddingResult>,
424    /// Performance model
425    performance_model: Box<dyn PerformanceModel>,
426    /// Optimization engine
427    optimization_engine: OptimizationEngine,
428}
429impl HardwareCompiler {
430    /// Create a new hardware compiler
431    #[must_use]
432    pub fn new(target_hardware: CompilationTarget, config: CompilerConfig) -> Self {
433        Self {
434            target_hardware,
435            config,
436            embedding_cache: HashMap::new(),
437            performance_model: Box::new(MLPerformanceModel::new()),
438            optimization_engine: OptimizationEngine::new(OptimizationConfig {
439                max_iterations: 100,
440                tolerance: 1e-6,
441                algorithm: OptimizationAlgorithm::SimulatedAnnealing,
442                objective_weights: HashMap::from([
443                    ("time".to_string(), 0.3),
444                    ("quality".to_string(), 0.4),
445                    ("energy".to_string(), 0.2),
446                    ("success_probability".to_string(), 0.1),
447                ]),
448            }),
449        }
450    }
451    /// Compile an Ising model for the target hardware
452    pub fn compile(
453        &mut self,
454        problem: &IsingModel,
455    ) -> HardwareCompilationResult<CompilationResult> {
456        let start_time = Instant::now();
457        let problem_analysis = self.analyze_problem(problem)?;
458        let embedding_info = self.generate_embedding(problem)?;
459        let annealing_params = self.optimize_annealing_parameters(problem, &embedding_info)?;
460        let hardware_mapping = self.create_hardware_mapping(problem, &embedding_info)?;
461        let performance_prediction = self.performance_model.predict_performance(
462            problem,
463            &embedding_info,
464            &self.target_hardware.characteristics,
465        )?;
466        let compiled_ising = self.apply_embedding_to_problem(problem, &embedding_info)?;
467        let compilation_time = start_time.elapsed();
468        Ok(CompilationResult {
469            compiled_ising,
470            embedding: embedding_info,
471            annealing_params,
472            hardware_mapping,
473            performance_prediction,
474            metadata: CompilationMetadata {
475                compilation_time,
476                optimization_iterations: self.optimization_engine.state.iteration,
477                compilation_algorithm: "HardwareAwareCompiler".to_string(),
478                compilation_resources: HashMap::from([
479                    ("memory_usage".to_string(), 100.0),
480                    ("cpu_time".to_string(), compilation_time.as_secs_f64()),
481                ]),
482                warnings: Vec::new(),
483                optimization_trace: self.optimization_engine.history.clone(),
484            },
485        })
486    }
487    /// Analyze problem characteristics
488    pub(crate) fn analyze_problem(
489        &self,
490        problem: &IsingModel,
491    ) -> HardwareCompilationResult<ProblemAnalysis> {
492        Ok(ProblemAnalysis {
493            num_variables: problem.num_qubits,
494            connectivity_density: self.calculate_connectivity_density(problem),
495            coupling_distribution: self.analyze_coupling_distribution(problem),
496            problem_structure: self.detect_problem_structure(problem),
497            complexity_estimate: self.estimate_complexity(problem),
498        })
499    }
500    /// Calculate connectivity density of the problem
501    fn calculate_connectivity_density(&self, problem: &IsingModel) -> f64 {
502        let mut num_couplings = 0;
503        for i in 0..problem.num_qubits {
504            for j in (i + 1)..problem.num_qubits {
505                if problem.get_coupling(i, j).unwrap_or(0.0).abs() > 1e-10 {
506                    num_couplings += 1;
507                }
508            }
509        }
510        let max_couplings = problem.num_qubits * (problem.num_qubits - 1) / 2;
511        f64::from(num_couplings) / max_couplings as f64
512    }
513    /// Analyze coupling strength distribution
514    fn analyze_coupling_distribution(&self, problem: &IsingModel) -> CouplingDistribution {
515        let mut couplings = Vec::new();
516        for i in 0..problem.num_qubits {
517            for j in (i + 1)..problem.num_qubits {
518                let coupling = problem.get_coupling(i, j).unwrap_or(0.0);
519                if coupling.abs() > 1e-10 {
520                    couplings.push(coupling.abs());
521                }
522            }
523        }
524        if couplings.is_empty() {
525            return CouplingDistribution {
526                mean: 0.0,
527                std_dev: 0.0,
528                min: 0.0,
529                max: 0.0,
530                distribution_type: DistributionType::Uniform,
531            };
532        }
533        couplings.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
534        let mean = couplings.iter().sum::<f64>() / couplings.len() as f64;
535        let variance =
536            couplings.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / couplings.len() as f64;
537        CouplingDistribution {
538            mean,
539            std_dev: variance.sqrt(),
540            min: couplings[0],
541            max: couplings[couplings.len() - 1],
542            distribution_type: DistributionType::Normal,
543        }
544    }
545    /// Detect problem structure (e.g., sparse, dense, structured)
546    fn detect_problem_structure(&self, problem: &IsingModel) -> ProblemStructure {
547        let connectivity_density = self.calculate_connectivity_density(problem);
548        if connectivity_density < 0.1 {
549            ProblemStructure::Sparse
550        } else if connectivity_density > 0.7 {
551            ProblemStructure::Dense
552        } else {
553            ProblemStructure::Structured
554        }
555    }
556    /// Estimate problem complexity
557    fn estimate_complexity(&self, problem: &IsingModel) -> f64 {
558        let size_factor = (problem.num_qubits as f64).ln();
559        let connectivity_factor = self.calculate_connectivity_density(problem);
560        size_factor * (1.0 + connectivity_factor)
561    }
562    /// Generate embedding for the problem
563    fn generate_embedding(
564        &mut self,
565        problem: &IsingModel,
566    ) -> HardwareCompilationResult<EmbeddingInfo> {
567        let cache_key = self.generate_cache_key(problem);
568        if self.config.cache_embeddings {
569            if let Some(cached_result) = self.embedding_cache.get(&cache_key) {
570                return Ok(self.convert_embedding_result_to_info(cached_result));
571            }
572        }
573        let embedding_result = self.find_best_embedding(problem)?;
574        if self.config.cache_embeddings {
575            self.embedding_cache
576                .insert(cache_key, embedding_result.clone());
577        }
578        Ok(self.convert_embedding_result_to_info(&embedding_result))
579    }
580    /// Find the best embedding using multiple algorithms
581    fn find_best_embedding(
582        &self,
583        problem: &IsingModel,
584    ) -> HardwareCompilationResult<EmbeddingResult> {
585        let mut variable_mapping = HashMap::new();
586        let mut chains = Vec::new();
587        for i in 0..problem.num_qubits {
588            variable_mapping.insert(i, vec![i]);
589            chains.push(Chain {
590                logical_variable: i,
591                physical_qubits: vec![i],
592                chain_strength: 1.0,
593                connectivity: 1.0,
594            });
595        }
596        let quality_metrics = EmbeddingQualityMetrics {
597            avg_chain_length: 1.0,
598            max_chain_length: 1,
599            efficiency: 1.0,
600            chain_balance: 1.0,
601            connectivity_utilization: self.calculate_connectivity_density(problem),
602        };
603        Ok(EmbeddingResult {
604            embedding: variable_mapping.clone(),
605            chain_strength: 1.0,
606            success: true,
607            error_message: None,
608        })
609    }
610    /// Convert `EmbeddingResult` to `EmbeddingInfo`
611    fn convert_embedding_result_to_info(&self, result: &EmbeddingResult) -> EmbeddingInfo {
612        let mut chains = Vec::new();
613        for (logical, physical) in &result.embedding {
614            chains.push(Chain {
615                logical_variable: *logical,
616                physical_qubits: physical.clone(),
617                chain_strength: result.chain_strength,
618                connectivity: 1.0,
619            });
620        }
621        EmbeddingInfo {
622            variable_mapping: result.embedding.clone(),
623            chains,
624            quality_metrics: EmbeddingQualityMetrics {
625                avg_chain_length: 1.0,
626                max_chain_length: 1,
627                efficiency: 1.0,
628                chain_balance: 1.0,
629                connectivity_utilization: 0.5,
630            },
631            algorithm_used: EmbeddingAlgorithm::MinorMiner,
632        }
633    }
634    /// Generate cache key for embedding
635    fn generate_cache_key(&self, problem: &IsingModel) -> String {
636        format!(
637            "{}_{:.6}",
638            problem.num_qubits,
639            self.calculate_connectivity_density(problem)
640        )
641    }
642    /// Optimize annealing parameters for the compiled problem
643    fn optimize_annealing_parameters(
644        &mut self,
645        problem: &IsingModel,
646        embedding: &EmbeddingInfo,
647    ) -> HardwareCompilationResult<AnnealingParams> {
648        let objective_fn = |params: &HashMap<String, f64>| -> f64 {
649            let mut score = 0.0;
650            for (key, &value) in params {
651                match key.as_str() {
652                    "chain_strength" => {
653                        if value < 0.1 || value > 10.0 {
654                            score += 1000.0;
655                        }
656                    }
657                    "annealing_time" => {
658                        if value < 1.0 || value > 1000.0 {
659                            score += 1000.0;
660                        }
661                    }
662                    _ => {}
663                }
664            }
665            score += params.values().map(|v| v.ln().abs()).sum::<f64>();
666            score
667        };
668        let optimized_params = self.optimization_engine.optimize(objective_fn)?;
669        Ok(AnnealingParams {
670            num_sweeps: *optimized_params.get("num_reads").unwrap_or(&1000.0) as usize,
671            num_repetitions: 1,
672            initial_temperature: optimized_params
673                .get("temperature")
674                .unwrap_or(&1.0)
675                .max(0.01),
676            final_temperature: 0.01,
677            timeout: Some(optimized_params.get("annealing_time").unwrap_or(&20.0) / 1000.0),
678            ..Default::default()
679        })
680    }
681    /// Create hardware mapping for the compilation
682    fn create_hardware_mapping(
683        &self,
684        problem: &IsingModel,
685        embedding: &EmbeddingInfo,
686    ) -> HardwareCompilationResult<HardwareMapping> {
687        let mut qubit_assignments = HashMap::new();
688        let mut coupling_assignments = HashMap::new();
689        for (logical, physical_vec) in &embedding.variable_mapping {
690            if let Some(&first_physical) = physical_vec.first() {
691                qubit_assignments.insert(*logical, first_physical);
692            }
693        }
694        for i in 0..problem.num_qubits {
695            for j in (i + 1)..problem.num_qubits {
696                if problem.get_coupling(i, j).unwrap_or(0.0).abs() > 1e-10 {
697                    if let (Some(&phys_i), Some(&phys_j)) =
698                        (qubit_assignments.get(&i), qubit_assignments.get(&j))
699                    {
700                        coupling_assignments.insert((i, j), (phys_i, phys_j));
701                    }
702                }
703            }
704        }
705        let resource_utilization = ResourceUtilization {
706            qubit_utilization: problem.num_qubits as f64
707                / self.target_hardware.characteristics.num_qubits as f64,
708            coupling_utilization: coupling_assignments.len() as f64 / 100.0,
709            control_resource_usage: HashMap::from([
710                ("memory".to_string(), 0.1),
711                ("control_lines".to_string(), 0.2),
712            ]),
713            estimated_energy: problem.num_qubits as f64 * 0.001,
714        };
715        Ok(HardwareMapping {
716            qubit_assignments,
717            coupling_assignments,
718            resource_utilization,
719            constraints_satisfied: vec![true; self.target_hardware.constraints.len()],
720        })
721    }
722    /// Apply embedding to create the final compiled problem
723    fn apply_embedding_to_problem(
724        &self,
725        problem: &IsingModel,
726        embedding: &EmbeddingInfo,
727    ) -> HardwareCompilationResult<IsingModel> {
728        let mut compiled = IsingModel::new(problem.num_qubits);
729        for i in 0..problem.num_qubits {
730            compiled.set_bias(i, problem.get_bias(i).unwrap_or(0.0))?;
731        }
732        for i in 0..problem.num_qubits {
733            for j in (i + 1)..problem.num_qubits {
734                let coupling = problem.get_coupling(i, j).unwrap_or(0.0);
735                if coupling.abs() > 1e-10 {
736                    compiled.set_coupling(i, j, coupling)?;
737                }
738            }
739        }
740        Ok(compiled)
741    }
742}
743/// Optimization engine for compilation
744pub struct OptimizationEngine {
745    /// Current optimization state
746    state: OptimizationState,
747    /// Optimization history
748    history: Vec<OptimizationStep>,
749    /// Configuration
750    config: OptimizationConfig,
751}
752impl OptimizationEngine {
753    /// Create a new optimization engine
754    #[must_use]
755    pub fn new(config: OptimizationConfig) -> Self {
756        Self {
757            state: OptimizationState {
758                objective_value: f64::INFINITY,
759                parameters: HashMap::new(),
760                iteration: 0,
761                converged: false,
762            },
763            history: Vec::new(),
764            config,
765        }
766    }
767    /// Optimize compilation parameters
768    pub fn optimize<F>(
769        &mut self,
770        objective_function: F,
771    ) -> HardwareCompilationResult<HashMap<String, f64>>
772    where
773        F: Fn(&HashMap<String, f64>) -> f64,
774    {
775        let start_time = Instant::now();
776        let mut current_params = HashMap::from([
777            ("chain_strength".to_string(), 1.0),
778            ("annealing_time".to_string(), 20.0),
779            ("temperature".to_string(), 0.01),
780            ("num_reads".to_string(), 1000.0),
781        ]);
782        let mut best_value = objective_function(&current_params);
783        let mut best_params = current_params.clone();
784        for iteration in 0..self.config.max_iterations {
785            let mut candidate_params = current_params.clone();
786            let mut rng = ChaCha8Rng::seed_from_u64(iteration as u64);
787            for (key, value) in &mut candidate_params {
788                let perturbation = rng.random_range(-0.1..0.1) * *value;
789                *value = (*value + perturbation).max(0.01);
790            }
791            let candidate_value = objective_function(&candidate_params);
792            if candidate_value < best_value {
793                best_value = candidate_value;
794                best_params.clone_from(&candidate_params);
795                current_params.clone_from(&candidate_params);
796            }
797            self.history.push(OptimizationStep {
798                description: format!("Iteration {iteration}"),
799                objective_value: candidate_value,
800                parameters: candidate_params,
801                step_time: start_time.elapsed() / (iteration + 1) as u32,
802            });
803            if iteration > 10
804                && self.history[iteration].objective_value
805                    - self.history[iteration - 10].objective_value
806                    < self.config.tolerance
807            {
808                self.state.converged = true;
809                break;
810            }
811        }
812        self.state.parameters = best_params.clone();
813        self.state.objective_value = best_value;
814        Ok(best_params)
815    }
816}
817/// Optimization configuration
818#[derive(Debug, Clone)]
819pub struct OptimizationConfig {
820    /// Maximum iterations
821    pub max_iterations: usize,
822    /// Convergence tolerance
823    pub tolerance: f64,
824    /// Optimization algorithm
825    pub algorithm: OptimizationAlgorithm,
826    /// Multi-objective weights
827    pub objective_weights: HashMap<String, f64>,
828}
829/// Embedding quality metrics
830#[derive(Debug, Clone)]
831pub struct EmbeddingQualityMetrics {
832    /// Average chain length
833    pub avg_chain_length: f64,
834    /// Maximum chain length
835    pub max_chain_length: usize,
836    /// Embedding efficiency
837    pub efficiency: f64,
838    /// Chain balance
839    pub chain_balance: f64,
840    /// Connectivity utilization
841    pub connectivity_utilization: f64,
842}
843/// Distribution types
844#[derive(Debug, Clone, PartialEq, Eq)]
845pub enum DistributionType {
846    /// Uniform distribution
847    Uniform,
848    /// Normal distribution
849    Normal,
850    /// Exponential distribution
851    Exponential,
852    /// Power law distribution
853    PowerLaw,
854}
855/// Topology types for hardware systems
856#[derive(Debug, Clone, PartialEq)]
857pub enum TopologyType {
858    /// 2D grid topology
859    Grid2D { rows: usize, cols: usize },
860    /// 3D grid topology
861    Grid3D { x: usize, y: usize, z: usize },
862    /// Small-world network
863    SmallWorld { degree: usize, rewiring_prob: f64 },
864    /// Scale-free network
865    ScaleFree {
866        num_nodes: usize,
867        attachment_param: usize,
868    },
869    /// Complete graph
870    Complete,
871    /// Tree topology
872    Tree {
873        branching_factor: usize,
874        depth: usize,
875    },
876}
877/// Resource allocation preferences
878#[derive(Debug, Clone)]
879pub struct ResourceAllocation {
880    /// Preferred qubit allocation strategy
881    pub qubit_allocation: QubitAllocationStrategy,
882    /// Coupling utilization preferences
883    pub coupling_utilization: CouplingUtilization,
884    /// Parallel compilation preferences
885    pub parallelization: ParallelizationStrategy,
886}
887/// Problem analysis results
888#[derive(Debug, Clone)]
889pub struct ProblemAnalysis {
890    /// Number of variables
891    pub num_variables: usize,
892    /// Connectivity density
893    pub connectivity_density: f64,
894    /// Coupling strength distribution
895    pub coupling_distribution: CouplingDistribution,
896    /// Problem structure type
897    pub problem_structure: ProblemStructure,
898    /// Complexity estimate
899    pub complexity_estimate: f64,
900}
901/// Coupling strength distribution
902#[derive(Debug, Clone)]
903pub struct CouplingDistribution {
904    /// Mean coupling strength
905    pub mean: f64,
906    /// Standard deviation
907    pub std_dev: f64,
908    /// Minimum coupling
909    pub min: f64,
910    /// Maximum coupling
911    pub max: f64,
912    /// Distribution type
913    pub distribution_type: DistributionType,
914}
915/// Embedding quality thresholds
916#[derive(Debug, Clone)]
917pub struct EmbeddingQualityThresholds {
918    /// Maximum average chain length
919    pub max_avg_chain_length: f64,
920    /// Minimum embedding efficiency
921    pub min_efficiency: f64,
922    /// Maximum embedding overhead
923    pub max_overhead: f64,
924}
925/// Control precision characteristics
926#[derive(Debug, Clone, PartialEq)]
927pub struct ControlPrecision {
928    /// Bias control precision (bits)
929    pub bias_precision: usize,
930    /// Coupling control precision (bits)
931    pub coupling_precision: usize,
932    /// Timing precision (seconds)
933    pub timing_precision: f64,
934}
935/// Performance metrics for hardware systems
936#[derive(Debug, Clone, PartialEq)]
937pub struct PerformanceMetrics {
938    /// Success probability for typical problems
939    pub success_probability: f64,
940    /// Average solution quality
941    pub solution_quality: f64,
942    /// Time to solution distribution
943    pub time_to_solution: Vec<f64>,
944    /// Energy resolution
945    pub energy_resolution: f64,
946    /// Reproducibility measure
947    pub reproducibility: f64,
948}
949/// Optimization state
950#[derive(Debug, Clone)]
951pub struct OptimizationState {
952    /// Current objective value
953    pub objective_value: f64,
954    /// Current parameters
955    pub parameters: HashMap<String, f64>,
956    /// Iteration count
957    pub iteration: usize,
958    /// Convergence status
959    pub converged: bool,
960}
961/// Optimization algorithms
962#[derive(Debug, Clone, PartialEq, Eq)]
963pub enum OptimizationAlgorithm {
964    /// Simulated annealing
965    SimulatedAnnealing,
966    /// Genetic algorithm
967    GeneticAlgorithm,
968    /// Particle swarm optimization
969    ParticleSwarm,
970    /// Bayesian optimization
971    BayesianOptimization,
972    /// Multi-objective NSGA-II
973    NSGAII,
974}
975/// Embedding information
976#[derive(Debug, Clone)]
977pub struct EmbeddingInfo {
978    /// Variable to physical qubit mapping
979    pub variable_mapping: HashMap<usize, Vec<usize>>,
980    /// Chain information
981    pub chains: Vec<Chain>,
982    /// Embedding quality metrics
983    pub quality_metrics: EmbeddingQualityMetrics,
984    /// Embedding algorithm used
985    pub algorithm_used: EmbeddingAlgorithm,
986}
987/// Compiler configuration
988#[derive(Debug, Clone)]
989pub struct CompilerConfig {
990    /// Enable aggressive optimizations
991    pub aggressive_optimization: bool,
992    /// Cache embedding results
993    pub cache_embeddings: bool,
994    /// Parallel compilation
995    pub parallel_compilation: bool,
996    /// Maximum compilation time
997    pub max_compilation_time: Duration,
998    /// Optimization tolerance
999    pub optimization_tolerance: f64,
1000    /// Random seed for reproducibility
1001    pub seed: Option<u64>,
1002}
1003/// Compilation target specification
1004#[derive(Debug, Clone)]
1005pub struct CompilationTarget {
1006    /// Target hardware type
1007    pub hardware_type: HardwareType,
1008    /// Hardware characteristics
1009    pub characteristics: HardwareCharacteristics,
1010    /// Optimization objectives
1011    pub objectives: Vec<OptimizationObjective>,
1012    /// Compilation constraints
1013    pub constraints: Vec<CompilationConstraint>,
1014    /// Resource allocation preferences
1015    pub resource_allocation: ResourceAllocation,
1016}
1017/// Connectivity patterns for hardware topologies
1018#[derive(Debug, Clone, PartialEq, Eq)]
1019pub enum ConnectivityPattern {
1020    /// Nearest neighbor connectivity
1021    NearestNeighbor,
1022    /// All-to-all connectivity
1023    AllToAll,
1024    /// King's graph (8-connected grid)
1025    KingsGraph,
1026    /// Triangular lattice
1027    Triangular,
1028    /// Custom connectivity pattern
1029    Custom(Vec<Vec<bool>>),
1030}
1031/// Hardware characteristics and constraints
1032#[derive(Debug, Clone, PartialEq)]
1033pub struct HardwareCharacteristics {
1034    /// Number of available qubits
1035    pub num_qubits: usize,
1036    /// Qubit connectivity graph
1037    pub connectivity: Vec<Vec<bool>>,
1038    /// Qubit noise characteristics
1039    pub qubit_noise: Vec<QubitNoise>,
1040    /// Coupling strength ranges
1041    pub coupling_ranges: Vec<Vec<CouplingRange>>,
1042    /// Annealing time constraints
1043    pub annealing_time_range: (f64, f64),
1044    /// Temperature characteristics
1045    pub temperature_characteristics: TemperatureProfile,
1046    /// Control precision
1047    pub control_precision: ControlPrecision,
1048    /// Hardware-specific constraints
1049    pub constraints: Vec<HardwareConstraint>,
1050    /// Performance metrics
1051    pub performance_metrics: PerformanceMetrics,
1052}
quantrs2_anneal/hardware_compilation/types.rs

quantrs2_anneal/hardware_compilation/
types.rs
