quantrs2_device/mid_circuit_measurements/
mod.rs

1//! Mid-circuit measurements module
2//!
3//! This module provides comprehensive support for mid-circuit measurements in quantum circuits,
4//! including advanced analytics, machine learning optimization, and adaptive learning capabilities.
5
6pub mod analytics;
7pub mod config;
8pub mod executor;
9pub mod fallback;
10pub mod ml;
11pub mod monitoring;
12pub mod results;
13
14// Re-export main types and interfaces
15pub use config::{
16    AdaptiveConfig, AdvancedAnalyticsConfig, FeatureEngineeringConfig, HardwareOptimizations,
17    MLModelType, MLOptimizationConfig, MLTrainingConfig, MidCircuitConfig, OnlineLearningConfig,
18    PredictionConfig, TimeSeriesConfig, UncertaintyConfig, ValidationConfig,
19};
20
21pub use results::{
22    AdaptiveLearningInsights, AdvancedAnalyticsResults, ErrorAnalysis, ExecutionStats,
23    MeasurementEvent, MeasurementPredictionResults, MeasurementType, MidCircuitCapabilities,
24    MidCircuitExecutionResult, OptimizationRecommendations, PerformanceMetrics, StorageLocation,
25    TimingConstraints, TrendDirection,
26};
27
28pub use executor::{MidCircuitDeviceExecutor, MidCircuitExecutor, ValidationResult};
29
30pub use analytics::{
31    anomaly::AnomalyDetector, causal::CausalAnalyzer, correlation::CorrelationAnalyzer,
32    distribution::DistributionAnalyzer, statistical::StatisticalAnalyzer,
33    time_series::TimeSeriesAnalyzer, AdvancedAnalyticsEngine,
34};
35
36pub use ml::{AdaptiveMeasurementManager, MLOptimizer, MeasurementPredictor};
37
38pub use monitoring::{AlertThresholds, ExportFormat, OptimizationCache, PerformanceMonitor};
39
40use crate::DeviceResult;
41use std::time::Duration;
42
43/// Convenience function to create a configured mid-circuit measurement executor
44pub fn create_mid_circuit_executor(
45    config: MidCircuitConfig,
46    calibration_manager: crate::calibration::CalibrationManager,
47) -> MidCircuitExecutor {
48    MidCircuitExecutor::new(config, calibration_manager)
49}
50
51/// Convenience function to create default mid-circuit configuration
52pub fn default_mid_circuit_config() -> MidCircuitConfig {
53    MidCircuitConfig::default()
54}
55
56/// Convenience function to create high-performance mid-circuit configuration
57pub fn high_performance_config() -> MidCircuitConfig {
58    MidCircuitConfig {
59        max_measurement_latency: 500.0, // 0.5ms
60        enable_realtime_processing: true,
61        measurement_buffer_size: 10000,
62        classical_timeout: 100.0,
63        enable_measurement_mitigation: true,
64        enable_parallel_measurements: true,
65        enable_adaptive_protocols: true,
66        hardware_optimizations: HardwareOptimizations {
67            batch_measurements: true,
68            optimize_scheduling: true,
69            use_native_protocols: true,
70            measurement_compression: false,
71            precompile_conditions: true,
72        },
73        validation_config: ValidationConfig {
74            validate_capabilities: true,
75            check_timing_constraints: true,
76            validate_register_sizes: true,
77            check_measurement_conflicts: true,
78            validate_feedforward: true,
79        },
80        analytics_config: AdvancedAnalyticsConfig {
81            enable_realtime_stats: true,
82            enable_correlation_analysis: true,
83            enable_time_series: true,
84            enable_anomaly_detection: true,
85            significance_threshold: 0.05,
86            analysis_window_size: 1000,
87            enable_distribution_fitting: true,
88            enable_causal_inference: true,
89        },
90        ml_optimization_config: MLOptimizationConfig {
91            enable_ml_optimization: true,
92            model_types: vec![MLModelType::NeuralNetwork {
93                hidden_layers: vec![64, 32],
94            }],
95            training_config: MLTrainingConfig::default(),
96            feature_engineering: FeatureEngineeringConfig::default(),
97            enable_transfer_learning: true,
98            online_learning: OnlineLearningConfig::default(),
99        },
100        prediction_config: PredictionConfig {
101            enable_prediction: true,
102            prediction_horizon: 50,
103            min_training_samples: 100,
104            sequence_length: 10,
105            time_series_config: TimeSeriesConfig::default(),
106            uncertainty_config: UncertaintyConfig::default(),
107            enable_ensemble: false,
108        },
109        adaptive_config: AdaptiveConfig {
110            enable_adaptive_scheduling: true,
111            enable_dynamic_thresholds: true,
112            enable_protocol_adaptation: true,
113            learning_rate: 0.001,
114            baseline_update_rate: 0.1,
115            drift_threshold: 0.1,
116            adaptation_window: 50,
117            enable_feedback_optimization: true,
118            improvement_threshold: 0.05,
119        },
120    }
121}
122
123/// Convenience function to create analytics-focused configuration
124pub fn analytics_focused_config() -> MidCircuitConfig {
125    MidCircuitConfig {
126        analytics_config: AdvancedAnalyticsConfig {
127            enable_realtime_stats: true,
128            enable_correlation_analysis: true,
129            enable_time_series: true,
130            enable_anomaly_detection: true,
131            significance_threshold: 0.01,
132            analysis_window_size: 5000,
133            enable_distribution_fitting: true,
134            enable_causal_inference: true,
135        },
136        ml_optimization_config: MLOptimizationConfig {
137            enable_ml_optimization: true,
138            model_types: vec![],
139            training_config: Default::default(),
140            feature_engineering: Default::default(),
141            enable_transfer_learning: true,
142            online_learning: Default::default(),
143        },
144        ..Default::default()
145    }
146}
147
148/// Convenience function to create minimal configuration for basic measurements
149pub fn minimal_config() -> MidCircuitConfig {
150    MidCircuitConfig {
151        max_measurement_latency: 2000.0, // 2ms
152        enable_realtime_processing: false,
153        measurement_buffer_size: 1000,
154        classical_timeout: 50.0, // 50 microseconds
155        enable_measurement_mitigation: false,
156        enable_parallel_measurements: false,
157        enable_adaptive_protocols: false,
158        hardware_optimizations: HardwareOptimizations {
159            batch_measurements: false,
160            optimize_scheduling: false,
161            use_native_protocols: false,
162            measurement_compression: false,
163            precompile_conditions: false,
164        },
165        validation_config: ValidationConfig {
166            validate_capabilities: true,
167            check_timing_constraints: false,
168            validate_register_sizes: false,
169            check_measurement_conflicts: false,
170            validate_feedforward: false,
171        },
172        analytics_config: AdvancedAnalyticsConfig {
173            enable_realtime_stats: true,
174            enable_correlation_analysis: false,
175            enable_time_series: false,
176            enable_anomaly_detection: false,
177            significance_threshold: 0.05,
178            analysis_window_size: 100,
179            enable_distribution_fitting: false,
180            enable_causal_inference: false,
181        },
182        ml_optimization_config: MLOptimizationConfig {
183            enable_ml_optimization: false,
184            model_types: vec![],
185            training_config: Default::default(),
186            feature_engineering: Default::default(),
187            enable_transfer_learning: false,
188            online_learning: Default::default(),
189        },
190        prediction_config: PredictionConfig {
191            enable_prediction: false,
192            prediction_horizon: 5,
193            min_training_samples: 100,
194            sequence_length: 10,
195            time_series_config: Default::default(),
196            uncertainty_config: Default::default(),
197            enable_ensemble: false,
198        },
199        adaptive_config: AdaptiveConfig {
200            enable_adaptive_scheduling: false,
201            enable_dynamic_thresholds: false,
202            enable_protocol_adaptation: false,
203            learning_rate: 0.01,
204            baseline_update_rate: 0.1,
205            drift_threshold: 0.1,
206            adaptation_window: 100,
207            enable_feedback_optimization: false,
208            improvement_threshold: 0.05,
209        },
210    }
211}
212
213/// Initialize mid-circuit measurement system with custom configuration
214pub fn initialize_system(config: MidCircuitConfig) -> DeviceResult<MidCircuitMeasurementSystem> {
215    let calibration_manager = crate::calibration::CalibrationManager::new();
216    let executor = MidCircuitExecutor::new(config.clone(), calibration_manager);
217    let analytics_engine = analytics::AdvancedAnalyticsEngine::new(&config.analytics_config);
218    let performance_monitor = monitoring::PerformanceMonitor::new();
219    let optimization_cache = monitoring::OptimizationCache::new();
220
221    Ok(MidCircuitMeasurementSystem {
222        config,
223        executor,
224        analytics_engine,
225        performance_monitor,
226        optimization_cache,
227    })
228}
229
230/// Complete mid-circuit measurement system
231pub struct MidCircuitMeasurementSystem {
232    pub config: MidCircuitConfig,
233    pub executor: MidCircuitExecutor,
234    pub analytics_engine: analytics::AdvancedAnalyticsEngine,
235    pub performance_monitor: monitoring::PerformanceMonitor,
236    pub optimization_cache: monitoring::OptimizationCache,
237}
238
239impl MidCircuitMeasurementSystem {
240    /// Create new system with default configuration
241    pub fn new() -> DeviceResult<Self> {
242        initialize_system(default_mid_circuit_config())
243    }
244
245    /// Create new system with high-performance configuration
246    pub fn new_high_performance() -> DeviceResult<Self> {
247        initialize_system(high_performance_config())
248    }
249
250    /// Create new system with analytics-focused configuration
251    pub fn new_analytics_focused() -> DeviceResult<Self> {
252        initialize_system(analytics_focused_config())
253    }
254
255    /// Create new system with minimal configuration
256    pub fn new_minimal() -> DeviceResult<Self> {
257        initialize_system(minimal_config())
258    }
259
260    /// Execute a circuit with comprehensive measurement analysis
261    pub async fn execute_and_analyze<const N: usize>(
262        &mut self,
263        circuit: &quantrs2_circuit::measurement::MeasurementCircuit<N>,
264        device_executor: &dyn MidCircuitDeviceExecutor,
265        shots: usize,
266    ) -> DeviceResult<MidCircuitExecutionResult> {
267        // Execute the circuit
268        let mut result = self
269            .executor
270            .execute_circuit(circuit, device_executor, shots)
271            .await?;
272
273        // Record performance metrics
274        self.performance_monitor
275            .record_metrics(&result.performance_metrics)?;
276
277        // Perform additional analytics if enabled
278        if self.config.analytics_config.enable_realtime_stats {
279            let enhanced_analytics = self
280                .analytics_engine
281                .analyze(&result.measurement_history, &result.execution_stats)
282                .await?;
283            result.analytics_results = enhanced_analytics;
284        }
285
286        Ok(result)
287    }
288
289    /// Get comprehensive system status
290    pub fn get_system_status(&self) -> DeviceResult<SystemStatus> {
291        let performance_summary = self.performance_monitor.get_performance_summary()?;
292        let cache_stats = self.optimization_cache.get_cache_stats();
293        let active_alerts = self.performance_monitor.check_alerts()?;
294
295        let system_health = if active_alerts.iter().any(|a| a.severity == "Critical") {
296            SystemHealth::Critical
297        } else if !active_alerts.is_empty() {
298            SystemHealth::Warning
299        } else {
300            SystemHealth::Healthy
301        };
302
303        Ok(SystemStatus {
304            performance_summary,
305            cache_stats: Some(cache_stats),
306            active_alerts,
307            system_health,
308            uptime: Duration::from_secs(0), // Default uptime since overall_stats doesn't exist
309        })
310    }
311
312    /// Export system metrics
313    pub fn export_metrics(&self, format: monitoring::ExportFormat) -> DeviceResult<String> {
314        self.performance_monitor.export_metrics(format)
315    }
316
317    /// Clear all caches and reset monitoring
318    pub fn reset_system(&mut self) -> DeviceResult<()> {
319        self.optimization_cache.clear();
320        // Note: In a full implementation, we would also reset the performance monitor
321        // and analytics engine state
322        Ok(())
323    }
324}
325
326/// System status information
327#[derive(Debug, Clone)]
328pub struct SystemStatus {
329    pub performance_summary: monitoring::PerformanceSummary,
330    pub cache_stats: Option<monitoring::CacheStatistics>,
331    pub active_alerts: Vec<monitoring::PerformanceAlert>,
332    pub system_health: SystemHealth,
333    pub uptime: std::time::Duration,
334}
335
336/// System health status
337#[derive(Debug, Clone, PartialEq, Eq)]
338pub enum SystemHealth {
339    Healthy,
340    Warning,
341    Critical,
342}
343
344impl Default for MidCircuitMeasurementSystem {
345    fn default() -> Self {
346        Self::new().expect("Failed to create default MidCircuitMeasurementSystem")
347    }
348}
349
350#[cfg(test)]
351mod tests {
352    use super::*;
353
354    #[test]
355    fn test_default_config_creation() {
356        let config = default_mid_circuit_config();
357        assert!(config.max_measurement_latency > 0.0);
358        assert!(config.measurement_buffer_size > 0);
359    }
360
361    #[test]
362    fn test_high_performance_config() {
363        let config = high_performance_config();
364        assert!(config.enable_realtime_processing);
365        assert!(config.hardware_optimizations.batch_measurements);
366        assert!(config.analytics_config.enable_realtime_stats);
367    }
368
369    #[test]
370    fn test_minimal_config() {
371        let config = minimal_config();
372        assert!(!config.enable_realtime_processing);
373        assert!(!config.ml_optimization_config.enable_ml_optimization);
374        assert!(!config.prediction_config.enable_prediction);
375    }
376
377    #[test]
378    fn test_system_initialization() {
379        let config = default_mid_circuit_config();
380        let result = initialize_system(config);
381        assert!(result.is_ok());
382    }
383}
quantrs2_device/mid_circuit_measurements/mod.rs

quantrs2_device/mid_circuit_measurements/
mod.rs
