quantrs2_device/dynamical_decoupling/
config.rs

1//! Configuration structures for dynamical decoupling
2
3use std::collections::HashMap;
4
5/// Configuration for dynamical decoupling with SciRS2 optimization
6#[derive(Debug, Clone)]
7pub struct DynamicalDecouplingConfig {
8    /// DD sequence type
9    pub sequence_type: DDSequenceType,
10    /// Sequence optimization configuration
11    pub optimization_config: DDOptimizationConfig,
12    /// Hardware adaptation settings
13    pub hardware_adaptation: DDHardwareConfig,
14    /// Noise characterization settings
15    pub noise_characterization: DDNoiseConfig,
16    /// Performance analysis settings
17    pub performance_config: DDPerformanceConfig,
18    /// Validation and testing settings
19    pub validation_config: DDValidationConfig,
20}
21
22impl Default for DynamicalDecouplingConfig {
23    fn default() -> Self {
24        Self {
25            sequence_type: DDSequenceType::CPMG { n_pulses: 4 },
26            optimization_config: DDOptimizationConfig::default(),
27            hardware_adaptation: DDHardwareConfig::default(),
28            noise_characterization: DDNoiseConfig::default(),
29            performance_config: DDPerformanceConfig::default(),
30            validation_config: DDValidationConfig::default(),
31        }
32    }
33}
34
35/// Adaptive DD configuration
36#[derive(Debug, Clone)]
37pub struct AdaptiveDDConfig {
38    /// Enable adaptive sequence selection
39    pub enable_adaptive_selection: bool,
40    /// Enable real-time adaptation
41    pub enable_real_time_adaptation: bool,
42    /// Adaptation threshold
43    pub adaptation_threshold: f64,
44    /// Minimum adaptation interval
45    pub min_adaptation_interval: std::time::Duration,
46    /// Adaptation criteria
47    pub adaptation_criteria: AdaptationCriteria,
48    /// Real-time monitoring configuration
49    pub monitoring_config: MonitoringConfig,
50    /// Feedback control parameters
51    pub feedback_control: FeedbackControlConfig,
52    /// Learning parameters
53    pub learning_config: LearningConfig,
54    /// Sequence selection strategy
55    pub selection_strategy: SequenceSelectionStrategy,
56    /// Adaptation triggers
57    pub adaptation_triggers: Vec<crate::adaptive_compilation::strategies::AdaptationTrigger>,
58}
59
60impl Default for AdaptiveDDConfig {
61    fn default() -> Self {
62        Self {
63            enable_adaptive_selection: true,
64            enable_real_time_adaptation: true,
65            adaptation_threshold: 0.1,
66            min_adaptation_interval: std::time::Duration::from_millis(100),
67            adaptation_criteria: AdaptationCriteria::default(),
68            monitoring_config: MonitoringConfig::default(),
69            feedback_control: FeedbackControlConfig::default(),
70            learning_config: LearningConfig::default(),
71            selection_strategy: SequenceSelectionStrategy::PerformanceBased,
72            adaptation_triggers: vec![
73                crate::adaptive_compilation::strategies::AdaptationTrigger::PerformanceDegradation,
74                crate::adaptive_compilation::strategies::AdaptationTrigger::ErrorRateIncrease,
75            ],
76        }
77    }
78}
79
80/// Criteria for adaptive DD selection
81#[derive(Debug, Clone)]
82pub struct AdaptationCriteria {
83    /// Coherence time threshold
84    pub coherence_threshold: f64,
85    /// Fidelity threshold
86    pub fidelity_threshold: f64,
87    /// Noise level threshold
88    pub noise_threshold: f64,
89    /// Performance degradation tolerance
90    pub performance_tolerance: f64,
91    /// Adaptation frequency
92    pub adaptation_frequency: AdaptationFrequency,
93}
94
95impl Default for AdaptationCriteria {
96    fn default() -> Self {
97        Self {
98            coherence_threshold: 0.1, // 10% degradation
99            fidelity_threshold: 0.95,
100            noise_threshold: 0.05,
101            performance_tolerance: 0.1,
102            adaptation_frequency: AdaptationFrequency::Dynamic,
103        }
104    }
105}
106
107/// Adaptation frequency options
108#[derive(Debug, Clone, PartialEq)]
109pub enum AdaptationFrequency {
110    /// Fixed time intervals
111    Fixed(std::time::Duration),
112    /// Event-driven adaptation
113    EventDriven,
114    /// Dynamic based on performance
115    Dynamic,
116    /// Continuous adaptation
117    Continuous,
118}
119
120/// Monitoring configuration for adaptive DD
121#[derive(Debug, Clone)]
122pub struct MonitoringConfig {
123    /// Enable real-time monitoring
124    pub enable_realtime: bool,
125    /// Monitoring metrics
126    pub metrics: Vec<MonitoringMetric>,
127    /// Sampling rate
128    pub sampling_rate: f64,
129    /// Buffer size for historical data
130    pub buffer_size: usize,
131    /// Alert thresholds
132    pub alert_thresholds: std::collections::HashMap<String, f64>,
133}
134
135impl Default for MonitoringConfig {
136    fn default() -> Self {
137        Self {
138            enable_realtime: true,
139            metrics: vec![
140                MonitoringMetric::CoherenceTime,
141                MonitoringMetric::Fidelity,
142                MonitoringMetric::NoiseLevel,
143            ],
144            sampling_rate: 1000.0, // Hz
145            buffer_size: 1000,
146            alert_thresholds: std::collections::HashMap::new(),
147        }
148    }
149}
150
151/// Monitoring metrics
152#[derive(Debug, Clone, PartialEq, Eq, Hash)]
153pub enum MonitoringMetric {
154    /// Coherence time
155    CoherenceTime,
156    /// Process fidelity
157    Fidelity,
158    /// Noise level
159    NoiseLevel,
160    /// Gate error rate
161    GateErrorRate,
162    /// Readout error rate
163    ReadoutErrorRate,
164    /// Cross-talk strength
165    CrosstalkStrength,
166    /// Temperature
167    Temperature,
168    /// Power consumption
169    PowerConsumption,
170}
171
172/// Feedback control configuration
173#[derive(Debug, Clone)]
174pub struct FeedbackControlConfig {
175    /// Control algorithm
176    pub control_algorithm: ControlAlgorithm,
177    /// PID parameters
178    pub pid_parameters: PIDParameters,
179    /// Control bandwidth
180    pub control_bandwidth: f64,
181    /// Actuator limits
182    pub actuator_limits: ActuatorLimits,
183    /// Safety margins
184    pub safety_margins: SafetyMargins,
185}
186
187impl Default for FeedbackControlConfig {
188    fn default() -> Self {
189        Self {
190            control_algorithm: ControlAlgorithm::PID,
191            pid_parameters: PIDParameters::default(),
192            control_bandwidth: 100.0, // Hz
193            actuator_limits: ActuatorLimits::default(),
194            safety_margins: SafetyMargins::default(),
195        }
196    }
197}
198
199/// Control algorithms
200#[derive(Debug, Clone, PartialEq)]
201pub enum ControlAlgorithm {
202    /// PID control
203    PID,
204    /// Model predictive control
205    MPC,
206    /// Adaptive control
207    Adaptive,
208    /// Reinforcement learning
209    ReinforcementLearning,
210    /// Neural network control
211    NeuralNetwork,
212}
213
214/// PID controller parameters
215#[derive(Debug, Clone)]
216pub struct PIDParameters {
217    /// Proportional gain
218    pub kp: f64,
219    /// Integral gain
220    pub ki: f64,
221    /// Derivative gain
222    pub kd: f64,
223    /// Integral windup limit
224    pub windup_limit: f64,
225    /// Output limits
226    pub output_limits: (f64, f64),
227}
228
229impl Default for PIDParameters {
230    fn default() -> Self {
231        Self {
232            kp: 1.0,
233            ki: 0.1,
234            kd: 0.01,
235            windup_limit: 100.0,
236            output_limits: (-100.0, 100.0),
237        }
238    }
239}
240
241/// Actuator limits
242#[derive(Debug, Clone)]
243pub struct ActuatorLimits {
244    /// Maximum pulse amplitude
245    pub max_amplitude: f64,
246    /// Maximum pulse duration
247    pub max_duration: f64,
248    /// Maximum frequency
249    pub max_frequency: f64,
250    /// Rate limits
251    pub rate_limits: std::collections::HashMap<String, f64>,
252}
253
254impl Default for ActuatorLimits {
255    fn default() -> Self {
256        Self {
257            max_amplitude: 1.0,
258            max_duration: 1e-6, // 1 μs
259            max_frequency: 1e9, // 1 GHz
260            rate_limits: std::collections::HashMap::new(),
261        }
262    }
263}
264
265/// Safety margins
266#[derive(Debug, Clone)]
267pub struct SafetyMargins {
268    /// Temperature margin
269    pub temperature_margin: f64,
270    /// Power margin
271    pub power_margin: f64,
272    /// Coherence margin
273    pub coherence_margin: f64,
274    /// Fidelity margin
275    pub fidelity_margin: f64,
276}
277
278impl Default for SafetyMargins {
279    fn default() -> Self {
280        Self {
281            temperature_margin: 0.1, // 10%
282            power_margin: 0.2,       // 20%
283            coherence_margin: 0.15,  // 15%
284            fidelity_margin: 0.05,   // 5%
285        }
286    }
287}
288
289/// Learning configuration for adaptive DD
290#[derive(Debug, Clone)]
291pub struct LearningConfig {
292    /// Learning algorithm
293    pub learning_algorithm: LearningAlgorithm,
294    /// Learning rate
295    pub learning_rate: f64,
296    /// Experience replay buffer size
297    pub replay_buffer_size: usize,
298    /// Exploration strategy
299    pub exploration_strategy: ExplorationStrategy,
300    /// Update frequency
301    pub update_frequency: usize,
302    /// Target update frequency
303    pub target_update_frequency: usize,
304}
305
306impl Default for LearningConfig {
307    fn default() -> Self {
308        Self {
309            learning_algorithm: LearningAlgorithm::QLearning,
310            learning_rate: 0.01,
311            replay_buffer_size: 10000,
312            exploration_strategy: ExplorationStrategy::EpsilonGreedy(0.1),
313            update_frequency: 10,
314            target_update_frequency: 100,
315        }
316    }
317}
318
319/// Learning algorithms
320#[derive(Debug, Clone, PartialEq)]
321pub enum LearningAlgorithm {
322    /// Q-learning
323    QLearning,
324    /// Deep Q-Network
325    DQN,
326    /// Policy gradient
327    PolicyGradient,
328    /// Actor-Critic
329    ActorCritic,
330    /// Proximal Policy Optimization
331    PPO,
332}
333
334/// Exploration strategies
335#[derive(Debug, Clone, PartialEq)]
336pub enum ExplorationStrategy {
337    /// Epsilon-greedy exploration
338    EpsilonGreedy(f64),
339    /// Boltzmann exploration
340    Boltzmann(f64),
341    /// Upper confidence bound
342    UCB(f64),
343    /// Thompson sampling
344    ThompsonSampling,
345}
346
347/// Sequence selection strategies for adaptive DD
348#[derive(Debug, Clone, PartialEq)]
349pub enum SequenceSelectionStrategy {
350    /// Performance-based selection
351    PerformanceBased,
352    /// Noise characteristic-based selection
353    NoiseCharacteristicBased,
354    /// Hybrid optimization approach
355    HybridOptimization,
356    /// Machine learning driven selection
357    MLDriven,
358    /// Rule-based selection
359    RuleBased,
360    /// Random selection
361    Random,
362}
363
364/// Types of dynamical decoupling sequences
365#[derive(Debug, Clone, PartialEq, Eq, Hash)]
366pub enum DDSequenceType {
367    /// Hahn Echo sequence
368    HahnEcho,
369    /// Carr-Purcell (CP) sequence
370    CarrPurcell,
371    /// Carr-Purcell-Meiboom-Gill (CPMG) sequence
372    CPMG { n_pulses: usize },
373    /// XY-4 sequence
374    XY4,
375    /// XY-8 sequence
376    XY8,
377    /// XY-16 sequence
378    XY16,
379    /// Knill dynamical decoupling (KDD)
380    KDD,
381    /// Uhrig dynamical decoupling (UDD)
382    UDD { n_pulses: usize },
383    /// Quadratic dynamical decoupling (QDD)
384    QDD,
385    /// Concatenated dynamical decoupling (CDD)
386    CDD,
387    /// Robust dynamical decoupling (RDD)
388    RDD,
389    /// Composite DD sequence
390    Composite,
391    /// Multi-qubit coordinated sequence
392    MultiQubitCoordinated,
393    /// Optimized sequences using SciRS2
394    SciRS2Optimized,
395    /// Adaptive DD sequence
396    Adaptive,
397    /// Custom user-defined sequence
398    Custom(String),
399}
400
401/// DD sequence optimization configuration using SciRS2
402#[derive(Debug, Clone)]
403pub struct DDOptimizationConfig {
404    /// Enable sequence optimization
405    pub enable_optimization: bool,
406    /// Optimization objective
407    pub optimization_objective: DDOptimizationObjective,
408    /// Optimization algorithm
409    pub optimization_algorithm: DDOptimizationAlgorithm,
410    /// Maximum optimization iterations
411    pub max_iterations: usize,
412    /// Convergence tolerance
413    pub convergence_tolerance: f64,
414    /// Parameter bounds for optimization
415    pub parameter_bounds: Option<Vec<(f64, f64)>>,
416    /// Multi-objective optimization weights
417    pub multi_objective_weights: HashMap<String, f64>,
418    /// Enable adaptive optimization
419    pub enable_adaptive: bool,
420    /// Enable SciRS2 optimization
421    pub enable_scirs2_optimization: bool,
422    /// Maximum optimization iterations
423    pub max_optimization_iterations: usize,
424    /// Optimization objectives
425    pub optimization_objectives: Vec<DDOptimizationObjectiveType>,
426}
427
428impl Default for DDOptimizationConfig {
429    fn default() -> Self {
430        Self {
431            enable_optimization: true,
432            optimization_objective: DDOptimizationObjective::MaximizeCoherenceTime,
433            optimization_algorithm: DDOptimizationAlgorithm::GradientFree,
434            max_iterations: 1000,
435            convergence_tolerance: 1e-6,
436            parameter_bounds: None,
437            multi_objective_weights: HashMap::new(),
438            enable_adaptive: true,
439            enable_scirs2_optimization: true,
440            max_optimization_iterations: 1000,
441            optimization_objectives: vec![
442                DDOptimizationObjectiveType::MaximizeFidelity,
443                DDOptimizationObjectiveType::MaximizeCoherenceTime,
444            ],
445        }
446    }
447}
448
449/// DD optimization objectives
450#[derive(Debug, Clone, PartialEq)]
451pub enum DDOptimizationObjective {
452    /// Maximize coherence time
453    MaximizeCoherenceTime,
454    /// Minimize decoherence rate
455    MinimizeDecoherenceRate,
456    /// Maximize process fidelity
457    MaximizeProcessFidelity,
458    /// Minimize gate overhead
459    MinimizeGateOverhead,
460    /// Maximize robustness to noise
461    MaximizeRobustness,
462    /// Multi-objective optimization
463    MultiObjective,
464    /// Custom objective function
465    Custom(String),
466}
467
468/// DD-specific optimization objectives
469#[derive(Debug, Clone, PartialEq)]
470pub enum DDOptimizationObjectiveType {
471    /// Maximize fidelity
472    MaximizeFidelity,
473    /// Minimize execution time
474    MinimizeExecutionTime,
475    /// Maximize coherence time
476    MaximizeCoherenceTime,
477    /// Minimize noise amplification
478    MinimizeNoiseAmplification,
479    /// Maximize robustness
480    MaximizeRobustness,
481    /// Minimize resource usage
482    MinimizeResourceUsage,
483}
484
485/// DD optimization algorithms
486#[derive(Debug, Clone, PartialEq)]
487pub enum DDOptimizationAlgorithm {
488    /// Gradient-free optimization
489    GradientFree,
490    /// Simulated annealing
491    SimulatedAnnealing,
492    /// Genetic algorithm
493    GeneticAlgorithm,
494    /// Particle swarm optimization
495    ParticleSwarm,
496    /// Differential evolution
497    DifferentialEvolution,
498    /// Bayesian optimization
499    BayesianOptimization,
500    /// Reinforcement learning
501    ReinforcementLearning,
502}
503
504/// Platform types for hardware adaptation
505#[derive(Debug, Clone, PartialEq)]
506pub enum PlatformType {
507    /// IBM Quantum platform
508    IBMQuantum,
509    /// AWS Braket platform
510    AWSBraket,
511    /// Azure Quantum platform
512    AzureQuantum,
513    /// Google Quantum AI platform
514    GoogleQuantumAI,
515    /// Rigetti QCS platform
516    RigettiQCS,
517    /// IonQ Cloud platform
518    IonQCloud,
519    /// Generic platform
520    Generic,
521}
522
523/// Hardware adaptation configuration for DD
524#[derive(Debug, Clone)]
525pub struct DDHardwareConfig {
526    /// Enable hardware-aware optimization
527    pub enable_hardware_aware: bool,
528    /// Account for gate set constraints
529    pub gate_set_constraints: bool,
530    /// Account for connectivity constraints
531    pub connectivity_constraints: bool,
532    /// Account for timing constraints
533    pub timing_constraints: bool,
534    /// Hardware-specific pulse optimization
535    pub pulse_optimization: DDPulseConfig,
536    /// Error characterization integration
537    pub error_characterization: bool,
538    /// Enable platform optimization
539    pub enable_platform_optimization: bool,
540    /// Enable calibration integration
541    pub enable_calibration_integration: bool,
542    /// Supported platforms
543    pub supported_platforms: Vec<PlatformType>,
544    /// Target platform for optimization
545    pub target_platform: Option<PlatformType>,
546}
547
548impl Default for DDHardwareConfig {
549    fn default() -> Self {
550        Self {
551            enable_hardware_aware: true,
552            gate_set_constraints: true,
553            connectivity_constraints: true,
554            timing_constraints: true,
555            pulse_optimization: DDPulseConfig::default(),
556            error_characterization: true,
557            enable_platform_optimization: true,
558            enable_calibration_integration: true,
559            supported_platforms: vec![
560                PlatformType::IBMQuantum,
561                PlatformType::AWSBraket,
562                PlatformType::AzureQuantum,
563                PlatformType::GoogleQuantumAI,
564                PlatformType::Generic,
565            ],
566            target_platform: Some(PlatformType::Generic),
567        }
568    }
569}
570
571/// DD pulse optimization configuration
572#[derive(Debug, Clone)]
573pub struct DDPulseConfig {
574    /// Enable pulse-level optimization
575    pub enable_pulse_optimization: bool,
576    /// Pulse shape optimization
577    pub pulse_shape_optimization: bool,
578    /// Composite pulse sequences
579    pub composite_pulses: bool,
580    /// Adiabatic pulses
581    pub adiabatic_pulses: bool,
582    /// Optimal control pulses
583    pub optimal_control: bool,
584}
585
586impl Default for DDPulseConfig {
587    fn default() -> Self {
588        Self {
589            enable_pulse_optimization: false,
590            pulse_shape_optimization: false,
591            composite_pulses: true,
592            adiabatic_pulses: false,
593            optimal_control: false,
594        }
595    }
596}
597
598/// Noise characterization configuration for DD
599#[derive(Debug, Clone)]
600pub struct DDNoiseConfig {
601    /// Enable noise characterization
602    pub enable_characterization: bool,
603    /// Noise types to consider
604    pub noise_types: Vec<NoiseType>,
605    /// Spectral noise analysis
606    pub spectral_analysis: bool,
607    /// Temporal correlation analysis
608    pub temporal_correlation: bool,
609    /// Spatial correlation analysis
610    pub spatial_correlation: bool,
611    /// Non-Markovian noise modeling
612    pub non_markovian_modeling: bool,
613    /// Enable spectral analysis
614    pub enable_spectral_analysis: bool,
615    /// Enable correlation analysis
616    pub enable_correlation_analysis: bool,
617    /// Sampling rate for noise characterization
618    pub sampling_rate: f64,
619    /// Target noise types for analysis
620    pub target_noise_types: Vec<NoiseType>,
621}
622
623impl Default for DDNoiseConfig {
624    fn default() -> Self {
625        Self {
626            enable_characterization: true,
627            noise_types: vec![
628                NoiseType::AmplitudeDamping,
629                NoiseType::PhaseDamping,
630                NoiseType::Depolarizing,
631            ],
632            spectral_analysis: true,
633            temporal_correlation: true,
634            spatial_correlation: false,
635            non_markovian_modeling: false,
636            enable_spectral_analysis: true,
637            enable_correlation_analysis: true,
638            sampling_rate: 1000.0,
639            target_noise_types: vec![
640                NoiseType::AmplitudeDamping,
641                NoiseType::PhaseDamping,
642                NoiseType::Depolarizing,
643                NoiseType::CoherentErrors,
644            ],
645        }
646    }
647}
648
649/// Types of noise affecting qubits
650#[derive(Debug, Clone, PartialEq, Eq, Hash)]
651pub enum NoiseType {
652    /// Amplitude damping (T1 decay)
653    AmplitudeDamping,
654    /// Phase damping (T2 dephasing)
655    PhaseDamping,
656    /// Depolarizing noise
657    Depolarizing,
658    /// Pauli noise
659    Pauli,
660    /// Coherent errors
661    CoherentErrors,
662    /// 1/f noise
663    OneOverFNoise,
664    /// Random telegraph noise
665    RandomTelegraphNoise,
666    /// Charge noise
667    ChargeNoise,
668    /// Flux noise
669    FluxNoise,
670    /// Cross-talk
671    CrossTalk,
672    /// Measurement noise
673    MeasurementNoise,
674    /// Control noise
675    ControlNoise,
676}
677
678/// Performance analysis configuration for DD
679#[derive(Debug, Clone)]
680pub struct DDPerformanceConfig {
681    /// Enable performance analysis
682    pub enable_analysis: bool,
683    /// Performance metrics to calculate
684    pub metrics: Vec<DDPerformanceMetric>,
685    /// Statistical analysis depth
686    pub statistical_depth: StatisticalDepth,
687    /// Enable benchmarking
688    pub enable_benchmarking: bool,
689    /// Benchmarking configuration
690    pub benchmarking_config: DDBenchmarkingConfig,
691    /// Enable coherence tracking
692    pub enable_coherence_tracking: bool,
693    /// Enable fidelity monitoring
694    pub enable_fidelity_monitoring: bool,
695    /// Number of measurement shots
696    pub measurement_shots: usize,
697}
698
699impl Default for DDPerformanceConfig {
700    fn default() -> Self {
701        Self {
702            enable_analysis: true,
703            metrics: vec![
704                DDPerformanceMetric::CoherenceTime,
705                DDPerformanceMetric::ProcessFidelity,
706                DDPerformanceMetric::GateOverhead,
707            ],
708            statistical_depth: StatisticalDepth::Comprehensive,
709            enable_benchmarking: true,
710            benchmarking_config: DDBenchmarkingConfig::default(),
711            enable_coherence_tracking: true,
712            enable_fidelity_monitoring: true,
713            measurement_shots: 1000,
714        }
715    }
716}
717
718/// DD performance metrics
719#[derive(Debug, Clone, PartialEq, Eq, Hash)]
720pub enum DDPerformanceMetric {
721    /// Effective coherence time
722    CoherenceTime,
723    /// Process fidelity
724    ProcessFidelity,
725    /// Gate count overhead
726    GateOverhead,
727    /// Execution time overhead
728    TimeOverhead,
729    /// Robustness to parameter variations
730    RobustnessScore,
731    /// Noise suppression factor
732    NoiseSuppressionFactor,
733    /// Resource efficiency
734    ResourceEfficiency,
735}
736
737/// Statistical analysis depth
738#[derive(Debug, Clone, PartialEq)]
739pub enum StatisticalDepth {
740    /// Basic statistical analysis
741    Basic,
742    /// Comprehensive statistical analysis
743    Comprehensive,
744    /// Advanced statistical analysis with machine learning
745    Advanced,
746}
747
748/// DD benchmarking configuration
749#[derive(Debug, Clone)]
750pub struct DDBenchmarkingConfig {
751    /// Enable comparative benchmarking
752    pub enable_comparative: bool,
753    /// Benchmark protocols
754    pub protocols: Vec<BenchmarkProtocol>,
755    /// Number of benchmark runs
756    pub benchmark_runs: usize,
757    /// Statistical confidence level
758    pub confidence_level: f64,
759}
760
761impl Default for DDBenchmarkingConfig {
762    fn default() -> Self {
763        Self {
764            enable_comparative: true,
765            protocols: vec![
766                BenchmarkProtocol::RandomizedBenchmarking,
767                BenchmarkProtocol::ProcessTomography,
768            ],
769            benchmark_runs: 100,
770            confidence_level: 0.95,
771        }
772    }
773}
774
775/// Benchmark protocols for DD
776#[derive(Debug, Clone, PartialEq)]
777pub enum BenchmarkProtocol {
778    /// Randomized benchmarking
779    RandomizedBenchmarking,
780    /// Process tomography
781    ProcessTomography,
782    /// Gate set tomography
783    GateSetTomography,
784    /// Cross-entropy benchmarking
785    CrossEntropyBenchmarking,
786    /// Cycle benchmarking
787    CycleBenchmarking,
788}
789
790/// DD validation configuration
791#[derive(Debug, Clone)]
792pub struct DDValidationConfig {
793    /// Enable validation
794    pub enable_validation: bool,
795    /// Cross-validation folds
796    pub cross_validation_folds: usize,
797    /// Out-of-sample validation fraction
798    pub out_of_sample_fraction: f64,
799    /// Enable robustness testing
800    pub enable_robustness_testing: bool,
801    /// Robustness test parameters
802    pub robustness_test_config: RobustnessTestConfig,
803    /// Enable generalization analysis
804    pub enable_generalization: bool,
805}
806
807impl Default for DDValidationConfig {
808    fn default() -> Self {
809        Self {
810            enable_validation: true,
811            cross_validation_folds: 5,
812            out_of_sample_fraction: 0.2,
813            enable_robustness_testing: true,
814            robustness_test_config: RobustnessTestConfig::default(),
815            enable_generalization: true,
816        }
817    }
818}
819
820/// Robustness test configuration
821#[derive(Debug, Clone)]
822pub struct RobustnessTestConfig {
823    /// Parameter variation ranges
824    pub parameter_variations: HashMap<String, (f64, f64)>,
825    /// Noise level variations
826    pub noise_variations: Vec<f64>,
827    /// Hardware variation tests
828    pub hardware_variations: bool,
829    /// Systematic error tests
830    pub systematic_errors: bool,
831}
832
833impl Default for RobustnessTestConfig {
834    fn default() -> Self {
835        let mut parameter_variations = HashMap::new();
836        parameter_variations.insert("pulse_amplitude".to_string(), (0.8, 1.2));
837        parameter_variations.insert("pulse_duration".to_string(), (0.9, 1.1));
838
839        Self {
840            parameter_variations,
841            noise_variations: vec![0.5, 1.0, 1.5, 2.0],
842            hardware_variations: true,
843            systematic_errors: true,
844        }
845    }
846}
847
848/// Real-time DD configuration
849#[derive(Debug, Clone)]
850pub struct RealTimeDDConfig {
851    /// Enable real-time adaptation
852    pub enable_realtime: bool,
853    /// Response time requirements
854    pub response_time: std::time::Duration,
855    /// Real-time scheduling priority
856    pub scheduling_priority: SchedulingPriority,
857    /// Resource allocation
858    pub resource_allocation: ResourceAllocation,
859    /// Latency requirements
860    pub latency_requirements: LatencyRequirements,
861}
862
863impl Default for RealTimeDDConfig {
864    fn default() -> Self {
865        Self {
866            enable_realtime: true,
867            response_time: std::time::Duration::from_micros(10), // 10 μs
868            scheduling_priority: SchedulingPriority::High,
869            resource_allocation: ResourceAllocation::default(),
870            latency_requirements: LatencyRequirements::default(),
871        }
872    }
873}
874
875/// Scheduling priorities
876#[derive(Debug, Clone, PartialEq)]
877pub enum SchedulingPriority {
878    Low,
879    Normal,
880    High,
881    Critical,
882    RealTime,
883}
884
885/// Resource allocation configuration
886#[derive(Debug, Clone)]
887pub struct ResourceAllocation {
888    /// CPU cores for DD processing
889    pub cpu_cores: usize,
890    /// Memory allocation (bytes)
891    pub memory_allocation: usize,
892    /// GPU acceleration
893    pub gpu_acceleration: bool,
894    /// Network bandwidth allocation
895    pub network_bandwidth: f64,
896}
897
898impl Default for ResourceAllocation {
899    fn default() -> Self {
900        Self {
901            cpu_cores: 2,
902            memory_allocation: 1024 * 1024 * 100, // 100 MB
903            gpu_acceleration: false,
904            network_bandwidth: 1e6, // 1 Mbps
905        }
906    }
907}
908
909/// Latency requirements
910#[derive(Debug, Clone)]
911pub struct LatencyRequirements {
912    /// Maximum control latency
913    pub max_control_latency: std::time::Duration,
914    /// Maximum measurement latency
915    pub max_measurement_latency: std::time::Duration,
916    /// Maximum adaptation latency
917    pub max_adaptation_latency: std::time::Duration,
918    /// Jitter tolerance
919    pub jitter_tolerance: std::time::Duration,
920}
921
922impl Default for LatencyRequirements {
923    fn default() -> Self {
924        Self {
925            max_control_latency: std::time::Duration::from_nanos(100),
926            max_measurement_latency: std::time::Duration::from_micros(1),
927            max_adaptation_latency: std::time::Duration::from_micros(10),
928            jitter_tolerance: std::time::Duration::from_nanos(10),
929        }
930    }
931}
932
933/// Type alias for backward compatibility with tests
934pub type DDHardwareAdaptationConfig = DDHardwareConfig;
quantrs2_device/dynamical_decoupling/config.rs

quantrs2_device/dynamical_decoupling/
config.rs
