quantrs2_device/mid_circuit_measurements/
config.rs

1//! Configuration types for mid-circuit measurements
2
3use serde::{Deserialize, Serialize};
4
5/// Comprehensive configuration for mid-circuit measurements
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct MidCircuitConfig {
8    /// Maximum allowed measurement latency (microseconds)
9    pub max_measurement_latency: f64,
10    /// Enable real-time classical processing
11    pub enable_realtime_processing: bool,
12    /// Buffer size for measurement results
13    pub measurement_buffer_size: usize,
14    /// Timeout for classical condition evaluation (microseconds)
15    pub classical_timeout: f64,
16    /// Enable measurement error mitigation
17    pub enable_measurement_mitigation: bool,
18    /// Parallel measurement execution
19    pub enable_parallel_measurements: bool,
20    /// Hardware-specific optimizations
21    pub hardware_optimizations: HardwareOptimizations,
22    /// Validation settings
23    pub validation_config: ValidationConfig,
24    /// Advanced SciRS2 analytics configuration
25    pub analytics_config: AdvancedAnalyticsConfig,
26    /// Adaptive measurement configuration
27    pub adaptive_config: AdaptiveConfig,
28    /// Machine learning optimization configuration
29    pub ml_optimization_config: MLOptimizationConfig,
30    /// Real-time prediction configuration
31    pub prediction_config: PredictionConfig,
32    /// Enable adaptive protocols
33    pub enable_adaptive_protocols: bool,
34}
35
36impl Default for MidCircuitConfig {
37    fn default() -> Self {
38        Self {
39            max_measurement_latency: 100.0, // 100 microseconds
40            enable_realtime_processing: true,
41            measurement_buffer_size: 1024,
42            classical_timeout: 50.0, // 50 microseconds
43            enable_measurement_mitigation: true,
44            enable_parallel_measurements: true,
45            hardware_optimizations: HardwareOptimizations::default(),
46            validation_config: ValidationConfig::default(),
47            analytics_config: AdvancedAnalyticsConfig::default(),
48            adaptive_config: AdaptiveConfig::default(),
49            ml_optimization_config: MLOptimizationConfig::default(),
50            prediction_config: PredictionConfig::default(),
51            enable_adaptive_protocols: true,
52        }
53    }
54}
55
56/// Hardware-specific optimizations for mid-circuit measurements
57#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct HardwareOptimizations {
59    /// Batch measurement operations when possible
60    pub batch_measurements: bool,
61    /// Optimize measurement scheduling
62    pub optimize_scheduling: bool,
63    /// Use hardware-native measurement protocols
64    pub use_native_protocols: bool,
65    /// Enable measurement compression
66    pub measurement_compression: bool,
67    /// Pre-compile classical conditions
68    pub precompile_conditions: bool,
69}
70
71impl Default for HardwareOptimizations {
72    fn default() -> Self {
73        Self {
74            batch_measurements: true,
75            optimize_scheduling: true,
76            use_native_protocols: true,
77            measurement_compression: false,
78            precompile_conditions: true,
79        }
80    }
81}
82
83/// Validation configuration for mid-circuit measurements
84#[derive(Debug, Clone, Serialize, Deserialize)]
85pub struct ValidationConfig {
86    /// Validate backend measurement capabilities
87    pub validate_capabilities: bool,
88    /// Check measurement timing constraints
89    pub check_timing_constraints: bool,
90    /// Validate classical register sizes
91    pub validate_register_sizes: bool,
92    /// Check for measurement conflicts
93    pub check_measurement_conflicts: bool,
94    /// Validate feed-forward operations
95    pub validate_feedforward: bool,
96}
97
98impl Default for ValidationConfig {
99    fn default() -> Self {
100        Self {
101            validate_capabilities: true,
102            check_timing_constraints: true,
103            validate_register_sizes: true,
104            check_measurement_conflicts: true,
105            validate_feedforward: true,
106        }
107    }
108}
109
110/// Advanced analytics configuration for mid-circuit measurements
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub struct AdvancedAnalyticsConfig {
113    /// Enable real-time statistical analysis
114    pub enable_realtime_stats: bool,
115    /// Enable correlation analysis between measurements
116    pub enable_correlation_analysis: bool,
117    /// Enable time series analysis
118    pub enable_time_series: bool,
119    /// Enable anomaly detection
120    pub enable_anomaly_detection: bool,
121    /// Statistical significance threshold
122    pub significance_threshold: f64,
123    /// Rolling window size for analysis
124    pub analysis_window_size: usize,
125    /// Enable distribution fitting
126    pub enable_distribution_fitting: bool,
127    /// Enable causal inference
128    pub enable_causal_inference: bool,
129}
130
131impl Default for AdvancedAnalyticsConfig {
132    fn default() -> Self {
133        Self {
134            enable_realtime_stats: true,
135            enable_correlation_analysis: true,
136            enable_time_series: false,
137            enable_anomaly_detection: true,
138            significance_threshold: 0.05,
139            analysis_window_size: 100,
140            enable_distribution_fitting: false,
141            enable_causal_inference: false,
142        }
143    }
144}
145
146/// Adaptive measurement configuration
147#[derive(Debug, Clone, Serialize, Deserialize)]
148pub struct AdaptiveConfig {
149    /// Enable adaptive measurement scheduling
150    pub enable_adaptive_scheduling: bool,
151    /// Enable dynamic threshold adjustment
152    pub enable_dynamic_thresholds: bool,
153    /// Enable measurement protocol adaptation
154    pub enable_protocol_adaptation: bool,
155    /// Adaptation learning rate
156    pub learning_rate: f64,
157    /// Baseline update rate for adaptive learning
158    pub baseline_update_rate: f64,
159    /// Drift threshold for detecting changes
160    pub drift_threshold: f64,
161    /// Adaptation window size
162    pub adaptation_window: usize,
163    /// Enable feedback-based optimization
164    pub enable_feedback_optimization: bool,
165    /// Performance improvement threshold for adaptation
166    pub improvement_threshold: f64,
167}
168
169impl Default for AdaptiveConfig {
170    fn default() -> Self {
171        Self {
172            enable_adaptive_scheduling: false,
173            enable_dynamic_thresholds: false,
174            enable_protocol_adaptation: false,
175            learning_rate: 0.01,
176            baseline_update_rate: 0.1,
177            drift_threshold: 0.1,
178            adaptation_window: 50,
179            enable_feedback_optimization: false,
180            improvement_threshold: 0.05,
181        }
182    }
183}
184
185/// Machine learning optimization configuration
186#[derive(Debug, Clone, Serialize, Deserialize)]
187pub struct MLOptimizationConfig {
188    /// Enable ML-driven measurement optimization
189    pub enable_ml_optimization: bool,
190    /// Model types to use
191    pub model_types: Vec<MLModelType>,
192    /// Training configuration
193    pub training_config: MLTrainingConfig,
194    /// Feature engineering settings
195    pub feature_engineering: FeatureEngineeringConfig,
196    /// Enable transfer learning
197    pub enable_transfer_learning: bool,
198    /// Online learning configuration
199    pub online_learning: OnlineLearningConfig,
200}
201
202impl Default for MLOptimizationConfig {
203    fn default() -> Self {
204        Self {
205            enable_ml_optimization: false,
206            model_types: vec![MLModelType::LinearRegression],
207            training_config: MLTrainingConfig::default(),
208            feature_engineering: FeatureEngineeringConfig::default(),
209            enable_transfer_learning: false,
210            online_learning: OnlineLearningConfig::default(),
211        }
212    }
213}
214
215/// ML model types for measurement optimization
216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
217pub enum MLModelType {
218    LinearRegression,
219    RandomForest {
220        n_estimators: usize,
221    },
222    GradientBoosting {
223        n_estimators: usize,
224        learning_rate: f64,
225    },
226    NeuralNetwork {
227        hidden_layers: Vec<usize>,
228    },
229    SupportVectorMachine {
230        kernel: String,
231    },
232    GaussianProcess,
233    ReinforcementLearning {
234        algorithm: String,
235    },
236}
237
238/// ML training configuration
239#[derive(Debug, Clone, Serialize, Deserialize)]
240pub struct MLTrainingConfig {
241    /// Training data size
242    pub training_size: usize,
243    /// Validation split ratio
244    pub validation_split: f64,
245    /// Cross-validation folds
246    pub cv_folds: usize,
247    /// Early stopping patience
248    pub early_stopping_patience: usize,
249    /// Learning rate schedule
250    pub learning_rate_schedule: LearningRateSchedule,
251    /// Regularization parameters
252    pub regularization: RegularizationConfig,
253}
254
255impl Default for MLTrainingConfig {
256    fn default() -> Self {
257        Self {
258            training_size: 1000,
259            validation_split: 0.2,
260            cv_folds: 5,
261            early_stopping_patience: 10,
262            learning_rate_schedule: LearningRateSchedule::Constant { rate: 0.001 },
263            regularization: RegularizationConfig::default(),
264        }
265    }
266}
267
268/// Learning rate schedule
269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
270pub enum LearningRateSchedule {
271    Constant { rate: f64 },
272    Exponential { initial_rate: f64, decay_rate: f64 },
273    StepWise { rates: Vec<(usize, f64)> },
274    Adaptive { patience: usize, factor: f64 },
275}
276
277/// Regularization configuration
278#[derive(Debug, Clone, Serialize, Deserialize)]
279pub struct RegularizationConfig {
280    /// L1 regularization strength
281    pub l1_alpha: f64,
282    /// L2 regularization strength
283    pub l2_alpha: f64,
284    /// Dropout rate
285    pub dropout_rate: f64,
286    /// Enable batch normalization
287    pub batch_normalization: bool,
288}
289
290impl Default for RegularizationConfig {
291    fn default() -> Self {
292        Self {
293            l1_alpha: 0.01,
294            l2_alpha: 0.01,
295            dropout_rate: 0.1,
296            batch_normalization: false,
297        }
298    }
299}
300
301/// Feature engineering configuration
302#[derive(Debug, Clone, Serialize, Deserialize)]
303pub struct FeatureEngineeringConfig {
304    /// Enable temporal features
305    pub enable_temporal_features: bool,
306    /// Enable statistical features
307    pub enable_statistical_features: bool,
308    /// Enable frequency domain features
309    pub enable_frequency_features: bool,
310    /// Enable interaction features
311    pub enable_interaction_features: bool,
312    /// Feature selection method
313    pub selection_method: FeatureSelectionMethod,
314    /// Maximum number of features
315    pub max_features: usize,
316}
317
318impl Default for FeatureEngineeringConfig {
319    fn default() -> Self {
320        Self {
321            enable_temporal_features: true,
322            enable_statistical_features: true,
323            enable_frequency_features: false,
324            enable_interaction_features: false,
325            selection_method: FeatureSelectionMethod::VarianceThreshold { threshold: 0.01 },
326            max_features: 20,
327        }
328    }
329}
330
331/// Feature selection methods
332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
333pub enum FeatureSelectionMethod {
334    VarianceThreshold { threshold: f64 },
335    UnivariateSelection { k_best: usize },
336    RecursiveFeatureElimination { n_features: usize },
337    LassoRegularization { alpha: f64 },
338    MutualInformation { k_best: usize },
339}
340
341/// Online learning configuration
342#[derive(Debug, Clone, Serialize, Deserialize)]
343pub struct OnlineLearningConfig {
344    /// Enable online learning
345    pub enable_online_learning: bool,
346    /// Update frequency (number of samples)
347    pub update_frequency: usize,
348    /// Memory window size
349    pub memory_window: usize,
350    /// Concept drift detection
351    pub drift_detection: DriftDetectionConfig,
352}
353
354impl Default for OnlineLearningConfig {
355    fn default() -> Self {
356        Self {
357            enable_online_learning: false,
358            update_frequency: 100,
359            memory_window: 1000,
360            drift_detection: DriftDetectionConfig::default(),
361        }
362    }
363}
364
365/// Concept drift detection configuration
366#[derive(Debug, Clone, Serialize, Deserialize)]
367pub struct DriftDetectionConfig {
368    /// Enable drift detection
369    pub enable_drift_detection: bool,
370    /// Detection method
371    pub detection_method: DriftDetectionMethod,
372    /// Detection threshold
373    pub detection_threshold: f64,
374    /// Minimum samples for detection
375    pub min_samples: usize,
376}
377
378impl Default for DriftDetectionConfig {
379    fn default() -> Self {
380        Self {
381            enable_drift_detection: false,
382            detection_method: DriftDetectionMethod::KolmogorovSmirnov,
383            detection_threshold: 0.05,
384            min_samples: 30,
385        }
386    }
387}
388
389/// Drift detection methods
390#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
391pub enum DriftDetectionMethod {
392    KolmogorovSmirnov,
393    PageHinkley {
394        delta: f64,
395        lambda: f64,
396    },
397    ADWIN {
398        delta: f64,
399    },
400    DDM {
401        alpha_warning: f64,
402        alpha_drift: f64,
403    },
404}
405
406/// Real-time prediction configuration
407#[derive(Debug, Clone, Serialize, Deserialize)]
408pub struct PredictionConfig {
409    /// Enable predictive modeling
410    pub enable_prediction: bool,
411    /// Prediction horizon (number of measurements)
412    pub prediction_horizon: usize,
413    /// Minimum training samples required
414    pub min_training_samples: usize,
415    /// Sequence length for time series predictions
416    pub sequence_length: usize,
417    /// Time series analysis configuration
418    pub time_series_config: TimeSeriesConfig,
419    /// Uncertainty quantification
420    pub uncertainty_config: UncertaintyConfig,
421    /// Enable ensemble predictions
422    pub enable_ensemble: bool,
423}
424
425impl Default for PredictionConfig {
426    fn default() -> Self {
427        Self {
428            enable_prediction: false,
429            prediction_horizon: 5,
430            min_training_samples: 100,
431            sequence_length: 10,
432            time_series_config: TimeSeriesConfig::default(),
433            uncertainty_config: UncertaintyConfig::default(),
434            enable_ensemble: false,
435        }
436    }
437}
438
439/// Time series analysis configuration
440#[derive(Debug, Clone, Serialize, Deserialize)]
441pub struct TimeSeriesConfig {
442    /// Enable trend analysis
443    pub enable_trend: bool,
444    /// Enable seasonality detection
445    pub enable_seasonality: bool,
446    /// Seasonality period
447    pub seasonality_period: usize,
448    /// Enable autocorrelation analysis
449    pub enable_autocorrelation: bool,
450    /// Forecasting method
451    pub forecasting_method: ForecastingMethod,
452}
453
454impl Default for TimeSeriesConfig {
455    fn default() -> Self {
456        Self {
457            enable_trend: true,
458            enable_seasonality: false,
459            seasonality_period: 24,
460            enable_autocorrelation: true,
461            forecasting_method: ForecastingMethod::ExponentialSmoothing {
462                alpha: 0.3,
463                beta: 0.1,
464                gamma: 0.1,
465            },
466        }
467    }
468}
469
470/// Forecasting methods
471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
472pub enum ForecastingMethod {
473    ARIMA {
474        p: usize,
475        d: usize,
476        q: usize,
477    },
478    ExponentialSmoothing {
479        alpha: f64,
480        beta: f64,
481        gamma: f64,
482    },
483    Prophet,
484    LSTM {
485        hidden_size: usize,
486        num_layers: usize,
487    },
488    Transformer {
489        d_model: usize,
490        n_heads: usize,
491    },
492}
493
494/// Uncertainty quantification configuration
495#[derive(Debug, Clone, Serialize, Deserialize)]
496pub struct UncertaintyConfig {
497    /// Enable uncertainty quantification
498    pub enable_uncertainty: bool,
499    /// Confidence level
500    pub confidence_level: f64,
501    /// Uncertainty method
502    pub uncertainty_method: UncertaintyMethod,
503    /// Bootstrap samples for uncertainty estimation
504    pub bootstrap_samples: usize,
505}
506
507impl Default for UncertaintyConfig {
508    fn default() -> Self {
509        Self {
510            enable_uncertainty: false,
511            confidence_level: 0.95,
512            uncertainty_method: UncertaintyMethod::Bootstrap,
513            bootstrap_samples: 1000,
514        }
515    }
516}
517
518/// Uncertainty quantification methods
519#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
520pub enum UncertaintyMethod {
521    Bootstrap,
522    BayesianInference,
523    ConformalPrediction,
524    GaussianProcess,
525    EnsembleVariance,
526}
quantrs2_device/mid_circuit_measurements/config.rs

quantrs2_device/mid_circuit_measurements/
config.rs
