quantrs2_device/mid_circuit_measurements/
results.rs

1//! Result types and data structures for mid-circuit measurements
2
3use std::collections::HashMap;
4use std::time::{Duration, SystemTime};
5
6use quantrs2_core::qubit::QubitId;
7use scirs2_core::ndarray::{Array1, Array2};
8use serde::{Deserialize, Serialize};
9
10/// Enhanced mid-circuit measurement execution result with SciRS2 analytics
11#[derive(Debug, Clone, Serialize, Deserialize)]
12pub struct MidCircuitExecutionResult {
13    /// Final quantum measurement results
14    pub final_measurements: HashMap<String, usize>,
15    /// Classical register states
16    pub classical_registers: HashMap<String, Vec<u8>>,
17    /// Mid-circuit measurement history
18    pub measurement_history: Vec<MeasurementEvent>,
19    /// Execution statistics
20    pub execution_stats: ExecutionStats,
21    /// Performance metrics
22    pub performance_metrics: PerformanceMetrics,
23    /// Error analysis
24    pub error_analysis: Option<ErrorAnalysis>,
25    /// Advanced analytics results
26    pub analytics_results: AdvancedAnalyticsResults,
27    /// Prediction results
28    pub prediction_results: Option<MeasurementPredictionResults>,
29    /// Optimization recommendations
30    pub optimization_recommendations: OptimizationRecommendations,
31    /// Adaptive learning insights
32    pub adaptive_insights: AdaptiveLearningInsights,
33}
34
35/// Individual measurement event during execution
36#[derive(Debug, Clone, Serialize, Deserialize)]
37pub struct MeasurementEvent {
38    /// Timestamp (microseconds from start)
39    pub timestamp: f64,
40    /// Measured qubit
41    pub qubit: QubitId,
42    /// Measurement result (0 or 1)
43    pub result: u8,
44    /// Classical bit/register where result was stored
45    pub storage_location: StorageLocation,
46    /// Measurement latency (microseconds)
47    pub latency: f64,
48    /// Confidence/fidelity of measurement
49    pub confidence: f64,
50}
51
52/// Location where measurement result is stored
53#[derive(Debug, Clone, Serialize, Deserialize)]
54pub enum StorageLocation {
55    /// Classical bit index
56    ClassicalBit(usize),
57    /// Classical register and bit index
58    ClassicalRegister(String, usize),
59    /// Temporary buffer
60    Buffer(usize),
61}
62
63/// Execution statistics for mid-circuit measurement
64#[derive(Debug, Clone, Serialize, Deserialize)]
65pub struct ExecutionStats {
66    /// Total execution time
67    pub total_execution_time: Duration,
68    /// Time spent on quantum operations
69    pub quantum_time: Duration,
70    /// Time spent on measurements
71    pub measurement_time: Duration,
72    /// Time spent on classical processing
73    pub classical_time: Duration,
74    /// Number of mid-circuit measurements
75    pub num_measurements: usize,
76    /// Number of conditional operations
77    pub num_conditional_ops: usize,
78    /// Average measurement latency
79    pub avg_measurement_latency: f64,
80    /// Maximum measurement latency
81    pub max_measurement_latency: f64,
82}
83
84/// Performance metrics for mid-circuit measurements
85#[derive(Debug, Clone, Serialize, Deserialize)]
86pub struct PerformanceMetrics {
87    /// Measurement success rate
88    pub measurement_success_rate: f64,
89    /// Classical processing efficiency
90    pub classical_efficiency: f64,
91    /// Overall circuit fidelity
92    pub circuit_fidelity: f64,
93    /// Measurement error rate
94    pub measurement_error_rate: f64,
95    /// Timing overhead compared to no measurements
96    pub timing_overhead: f64,
97    /// Resource utilization
98    pub resource_utilization: ResourceUtilization,
99}
100
101/// Resource utilization metrics
102#[derive(Debug, Clone, Serialize, Deserialize)]
103pub struct ResourceUtilization {
104    /// Quantum resource usage (0-1)
105    pub quantum_utilization: f64,
106    /// Classical resource usage (0-1)
107    pub classical_utilization: f64,
108    /// Memory usage for classical data
109    pub memory_usage: usize,
110    /// Communication overhead
111    pub communication_overhead: f64,
112}
113
114/// Error analysis for mid-circuit measurements
115#[derive(Debug, Clone, Serialize, Deserialize)]
116pub struct ErrorAnalysis {
117    /// Measurement errors by qubit
118    pub measurement_errors: HashMap<QubitId, MeasurementErrorStats>,
119    /// Classical processing errors
120    pub classical_errors: Vec<ClassicalError>,
121    /// Timing violations
122    pub timing_violations: Vec<TimingViolation>,
123    /// Correlation analysis
124    pub error_correlations: Array2<f64>,
125}
126
127/// Measurement error statistics
128#[derive(Debug, Clone, Serialize, Deserialize)]
129pub struct MeasurementErrorStats {
130    /// Readout error rate
131    pub readout_error_rate: f64,
132    /// State preparation and measurement (SPAM) error
133    pub spam_error: f64,
134    /// Thermal relaxation during measurement
135    pub thermal_relaxation: f64,
136    /// Dephasing during measurement
137    pub dephasing: f64,
138}
139
140/// Classical processing error
141#[derive(Debug, Clone, Serialize, Deserialize)]
142pub struct ClassicalError {
143    /// Error type
144    pub error_type: ClassicalErrorType,
145    /// Timestamp when error occurred
146    pub timestamp: f64,
147    /// Error description
148    pub description: String,
149    /// Affected operations
150    pub affected_operations: Vec<usize>,
151}
152
153/// Types of classical errors
154#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
155pub enum ClassicalErrorType {
156    /// Timeout in classical condition evaluation
157    Timeout,
158    /// Invalid register access
159    InvalidRegisterAccess,
160    /// Condition evaluation error
161    ConditionEvaluationError,
162    /// Buffer overflow
163    BufferOverflow,
164    /// Communication error
165    CommunicationError,
166}
167
168/// Timing constraint violation
169#[derive(Debug, Clone, Serialize, Deserialize)]
170pub struct TimingViolation {
171    /// Operation that violated timing
172    pub operation_index: usize,
173    /// Expected timing (microseconds)
174    pub expected_timing: f64,
175    /// Actual timing (microseconds)
176    pub actual_timing: f64,
177    /// Violation severity (0-1)
178    pub severity: f64,
179}
180
181/// Advanced analytics results for mid-circuit measurements
182#[derive(Debug, Clone, Serialize, Deserialize, Default)]
183pub struct AdvancedAnalyticsResults {
184    /// Statistical analysis results
185    pub statistical_analysis: StatisticalAnalysisResults,
186    /// Correlation analysis results
187    pub correlation_analysis: CorrelationAnalysisResults,
188    /// Time series analysis results
189    pub time_series_analysis: Option<TimeSeriesAnalysisResults>,
190    /// Anomaly detection results
191    pub anomaly_detection: Option<AnomalyDetectionResults>,
192    /// Distribution analysis results
193    pub distribution_analysis: DistributionAnalysisResults,
194    /// Causal inference results
195    pub causal_analysis: Option<CausalAnalysisResults>,
196}
197
198/// Statistical analysis results
199#[derive(Debug, Clone, Serialize, Deserialize, Default)]
200pub struct StatisticalAnalysisResults {
201    /// Descriptive statistics
202    pub descriptive_stats: DescriptiveStatistics,
203    /// Hypothesis test results
204    pub hypothesis_tests: HypothesisTestResults,
205    /// Confidence intervals
206    pub confidence_intervals: ConfidenceIntervals,
207    /// Effect size measurements
208    pub effect_sizes: EffectSizeAnalysis,
209}
210
211/// Descriptive statistics
212#[derive(Debug, Clone, Serialize, Deserialize)]
213pub struct DescriptiveStatistics {
214    /// Mean measurement latency
215    pub mean_latency: f64,
216    /// Standard deviation of latency
217    pub std_latency: f64,
218    /// Median latency
219    pub median_latency: f64,
220    /// Percentiles (25th, 75th, 95th, 99th)
221    pub latency_percentiles: Vec<f64>,
222    /// Measurement success rate statistics
223    pub success_rate_stats: MeasurementSuccessStats,
224    /// Error rate distribution
225    pub error_rate_distribution: ErrorRateDistribution,
226}
227
228/// Measurement success statistics
229#[derive(Debug, Clone, Serialize, Deserialize)]
230pub struct MeasurementSuccessStats {
231    /// Overall success rate
232    pub overall_success_rate: f64,
233    /// Success rate by qubit
234    pub per_qubit_success_rate: HashMap<QubitId, f64>,
235    /// Success rate over time
236    pub temporal_success_rate: Vec<(f64, f64)>, // (timestamp, success_rate)
237    /// Success rate confidence interval
238    pub success_rate_ci: (f64, f64),
239}
240
241/// Error rate distribution analysis
242#[derive(Debug, Clone, Serialize, Deserialize)]
243pub struct ErrorRateDistribution {
244    /// Error rate histogram
245    pub histogram: Vec<(f64, usize)>, // (error_rate, count)
246    /// Best-fit distribution
247    pub best_fit_distribution: String,
248    /// Distribution parameters
249    pub distribution_parameters: Vec<f64>,
250    /// Goodness-of-fit statistic
251    pub goodness_of_fit: f64,
252}
253
254/// Hypothesis test results
255#[derive(Debug, Clone, Serialize, Deserialize, Default)]
256pub struct HypothesisTestResults {
257    /// Tests for measurement independence
258    pub independence_tests: HashMap<String, StatisticalTest>,
259    /// Tests for stationarity
260    pub stationarity_tests: HashMap<String, StatisticalTest>,
261    /// Tests for normality
262    pub normality_tests: HashMap<String, StatisticalTest>,
263    /// Comparison tests between different conditions
264    pub comparison_tests: HashMap<String, ComparisonTest>,
265}
266
267/// Individual statistical test result
268#[derive(Debug, Clone, Serialize, Deserialize)]
269pub struct StatisticalTest {
270    /// Test statistic
271    pub statistic: f64,
272    /// P-value
273    pub p_value: f64,
274    /// Critical value
275    pub critical_value: f64,
276    /// Test conclusion
277    pub is_significant: bool,
278    /// Effect size
279    pub effect_size: Option<f64>,
280}
281
282impl Default for StatisticalTest {
283    fn default() -> Self {
284        Self {
285            statistic: 0.0,
286            p_value: 0.1,
287            critical_value: 1.96,
288            is_significant: false,
289            effect_size: None,
290        }
291    }
292}
293
294/// Comparison test result
295#[derive(Debug, Clone, Serialize, Deserialize)]
296pub struct ComparisonTest {
297    /// Test type
298    pub test_type: String,
299    /// Test statistic
300    pub statistic: f64,
301    /// P-value
302    pub p_value: f64,
303    /// Mean difference
304    pub mean_difference: f64,
305    /// Confidence interval for difference
306    pub difference_ci: (f64, f64),
307    /// Cohen's d effect size
308    pub cohens_d: f64,
309}
310
311/// Confidence intervals
312#[derive(Debug, Clone, Serialize, Deserialize)]
313pub struct ConfidenceIntervals {
314    /// Confidence level used
315    pub confidence_level: f64,
316    /// Confidence intervals for means
317    pub mean_intervals: HashMap<String, (f64, f64)>,
318    /// Bootstrap confidence intervals
319    pub bootstrap_intervals: HashMap<String, (f64, f64)>,
320    /// Prediction intervals
321    pub prediction_intervals: HashMap<String, (f64, f64)>,
322}
323
324/// Effect size analysis
325#[derive(Debug, Clone, Serialize, Deserialize, Default)]
326pub struct EffectSizeAnalysis {
327    /// Cohen's d for measurement differences
328    pub cohens_d: HashMap<String, f64>,
329    /// Correlation coefficients
330    pub correlations: HashMap<String, f64>,
331    /// R-squared values for relationships
332    pub r_squared: HashMap<String, f64>,
333    /// Practical significance indicators
334    pub practical_significance: HashMap<String, bool>,
335}
336
337/// Correlation analysis results
338#[derive(Debug, Clone, Serialize, Deserialize)]
339pub struct CorrelationAnalysisResults {
340    /// Pearson correlation matrix
341    pub pearson_correlations: Array2<f64>,
342    /// Spearman correlation matrix
343    pub spearman_correlations: Array2<f64>,
344    /// Kendall's tau correlations
345    pub kendall_correlations: Array2<f64>,
346    /// Significant correlations
347    pub significant_correlations: Vec<CorrelationPair>,
348    /// Partial correlations
349    pub partial_correlations: Array2<f64>,
350    /// Correlation network analysis
351    pub network_analysis: CorrelationNetworkAnalysis,
352}
353
354/// Correlation pair
355#[derive(Debug, Clone, Serialize, Deserialize)]
356pub struct CorrelationPair {
357    /// Variable 1
358    pub variable1: String,
359    /// Variable 2
360    pub variable2: String,
361    /// Correlation coefficient
362    pub correlation: f64,
363    /// P-value
364    pub p_value: f64,
365    /// Correlation type
366    pub correlation_type: CorrelationType,
367}
368
369/// Types of correlation
370#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
371pub enum CorrelationType {
372    Pearson,
373    Spearman,
374    Kendall,
375    Partial,
376}
377
378/// Correlation network analysis
379#[derive(Debug, Clone, Serialize, Deserialize)]
380pub struct CorrelationNetworkAnalysis {
381    /// Graph adjacency matrix
382    pub adjacency_matrix: Array2<f64>,
383    /// Node centrality measures
384    pub centrality_measures: NodeCentralityMeasures,
385    /// Community detection results
386    pub communities: Vec<Vec<usize>>,
387    /// Network density
388    pub network_density: f64,
389    /// Clustering coefficient
390    pub clustering_coefficient: f64,
391}
392
393/// Node centrality measures
394#[derive(Debug, Clone, Serialize, Deserialize, Default)]
395pub struct NodeCentralityMeasures {
396    /// Betweenness centrality
397    pub betweenness: Vec<f64>,
398    /// Closeness centrality
399    pub closeness: Vec<f64>,
400    /// Eigenvector centrality
401    pub eigenvector: Vec<f64>,
402    /// Degree centrality
403    pub degree: Vec<f64>,
404}
405
406/// Time series analysis results
407#[derive(Debug, Clone, Serialize, Deserialize)]
408pub struct TimeSeriesAnalysisResults {
409    /// Trend analysis
410    pub trend_analysis: TrendAnalysis,
411    /// Seasonality analysis
412    pub seasonality_analysis: Option<SeasonalityAnalysis>,
413    /// Autocorrelation analysis
414    pub autocorrelation: AutocorrelationAnalysis,
415    /// Change point detection
416    pub change_points: Vec<ChangePoint>,
417    /// Stationarity test results
418    pub stationarity: StationarityTestResults,
419}
420
421/// Trend analysis
422#[derive(Debug, Clone, Serialize, Deserialize)]
423pub struct TrendAnalysis {
424    /// Trend direction
425    pub trend_direction: TrendDirection,
426    /// Trend strength
427    pub trend_strength: f64,
428    /// Trend slope
429    pub trend_slope: f64,
430    /// Trend significance
431    pub trend_significance: f64,
432    /// Trend confidence interval
433    pub trend_ci: (f64, f64),
434}
435
436/// Trend direction
437#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
438pub enum TrendDirection {
439    Increasing,
440    Decreasing,
441    Stable,
442    Volatile,
443    Cyclical,
444}
445
446/// Seasonality analysis
447#[derive(Debug, Clone, Serialize, Deserialize)]
448pub struct SeasonalityAnalysis {
449    /// Detected seasonal periods
450    pub periods: Vec<usize>,
451    /// Seasonal strength
452    pub seasonal_strength: f64,
453    /// Seasonal components
454    pub seasonal_components: Array1<f64>,
455    /// Residual components
456    pub residual_components: Array1<f64>,
457}
458
459/// Autocorrelation analysis
460#[derive(Debug, Clone, Serialize, Deserialize)]
461pub struct AutocorrelationAnalysis {
462    /// Autocorrelation function
463    pub acf: Array1<f64>,
464    /// Partial autocorrelation function
465    pub pacf: Array1<f64>,
466    /// Significant lags
467    pub significant_lags: Vec<usize>,
468    /// Ljung-Box test statistic
469    pub ljung_box_statistic: f64,
470    /// Ljung-Box p-value
471    pub ljung_box_p_value: f64,
472}
473
474/// Change point
475#[derive(Debug, Clone, Serialize, Deserialize)]
476pub struct ChangePoint {
477    /// Change point index
478    pub index: usize,
479    /// Change point timestamp
480    pub timestamp: f64,
481    /// Change point confidence
482    pub confidence: f64,
483    /// Change magnitude
484    pub magnitude: f64,
485    /// Change type
486    pub change_type: ChangePointType,
487}
488
489/// Change point types
490#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
491pub enum ChangePointType {
492    MeanShift,
493    VarianceChange,
494    TrendChange,
495    DistributionChange,
496}
497
498/// Stationarity test results
499#[derive(Debug, Clone, Serialize, Deserialize)]
500pub struct StationarityTestResults {
501    /// Augmented Dickey-Fuller test
502    pub adf_test: StatisticalTest,
503    /// KPSS test
504    pub kpss_test: StatisticalTest,
505    /// Phillips-Perron test
506    pub pp_test: StatisticalTest,
507    /// Overall stationarity conclusion
508    pub is_stationary: bool,
509}
510
511/// Anomaly detection results
512#[derive(Debug, Clone, Serialize, Deserialize)]
513pub struct AnomalyDetectionResults {
514    /// Detected anomalies
515    pub anomalies: Vec<AnomalyEvent>,
516    /// Anomaly scores
517    pub anomaly_scores: Array1<f64>,
518    /// Detection thresholds
519    pub thresholds: HashMap<String, f64>,
520    /// Method performance
521    pub method_performance: AnomalyMethodPerformance,
522}
523
524/// Anomaly event
525#[derive(Debug, Clone, Serialize, Deserialize)]
526pub struct AnomalyEvent {
527    /// Event index
528    pub index: usize,
529    /// Event timestamp
530    pub timestamp: f64,
531    /// Anomaly score
532    pub anomaly_score: f64,
533    /// Anomaly type
534    pub anomaly_type: AnomalyType,
535    /// Affected measurements
536    pub affected_measurements: Vec<usize>,
537    /// Severity level
538    pub severity: AnomalySeverity,
539}
540
541/// Anomaly types
542#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
543pub enum AnomalyType {
544    PointAnomaly,
545    ContextualAnomaly,
546    CollectiveAnomaly,
547    TrendAnomaly,
548    SeasonalAnomaly,
549}
550
551/// Anomaly severity levels
552#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
553pub enum AnomalySeverity {
554    Low,
555    Medium,
556    High,
557    Critical,
558}
559
560/// Anomaly method performance
561#[derive(Debug, Clone, Serialize, Deserialize)]
562pub struct AnomalyMethodPerformance {
563    /// Precision scores
564    pub precision: HashMap<String, f64>,
565    /// Recall scores
566    pub recall: HashMap<String, f64>,
567    /// F1 scores
568    pub f1_scores: HashMap<String, f64>,
569    /// False positive rates
570    pub false_positive_rates: HashMap<String, f64>,
571}
572
573/// Distribution analysis results
574#[derive(Debug, Clone, Serialize, Deserialize, Default)]
575pub struct DistributionAnalysisResults {
576    /// Best-fit distributions
577    pub best_fit_distributions: HashMap<String, DistributionFit>,
578    /// Distribution comparison results
579    pub distribution_comparisons: Vec<DistributionComparison>,
580    /// Mixture model results
581    pub mixture_models: Option<MixtureModelResults>,
582    /// Normality assessment
583    pub normality_assessment: NormalityAssessment,
584}
585
586/// Distribution fit result
587#[derive(Debug, Clone, Serialize, Deserialize)]
588pub struct DistributionFit {
589    /// Distribution name
590    pub distribution_name: String,
591    /// Distribution parameters
592    pub parameters: Vec<f64>,
593    /// Log-likelihood
594    pub log_likelihood: f64,
595    /// AIC score
596    pub aic: f64,
597    /// BIC score
598    pub bic: f64,
599    /// Kolmogorov-Smirnov test statistic
600    pub ks_statistic: f64,
601    /// KS test p-value
602    pub ks_p_value: f64,
603}
604
605/// Distribution comparison
606#[derive(Debug, Clone, Serialize, Deserialize)]
607pub struct DistributionComparison {
608    /// Distribution 1
609    pub distribution1: String,
610    /// Distribution 2
611    pub distribution2: String,
612    /// AIC difference
613    pub aic_difference: f64,
614    /// BIC difference
615    pub bic_difference: f64,
616    /// Likelihood ratio test
617    pub likelihood_ratio_test: StatisticalTest,
618    /// Better fitting distribution
619    pub better_fit: String,
620}
621
622/// Mixture model results
623#[derive(Debug, Clone, Serialize, Deserialize)]
624pub struct MixtureModelResults {
625    /// Number of components
626    pub n_components: usize,
627    /// Component weights
628    pub weights: Array1<f64>,
629    /// Component parameters
630    pub component_parameters: Vec<Vec<f64>>,
631    /// Log-likelihood
632    pub log_likelihood: f64,
633    /// BIC score
634    pub bic: f64,
635    /// Component assignments
636    pub assignments: Array1<usize>,
637}
638
639/// Normality assessment
640#[derive(Debug, Clone, Serialize, Deserialize)]
641pub struct NormalityAssessment {
642    /// Shapiro-Wilk test
643    pub shapiro_wilk: StatisticalTest,
644    /// Anderson-Darling test
645    pub anderson_darling: StatisticalTest,
646    /// Jarque-Bera test
647    pub jarque_bera: StatisticalTest,
648    /// Overall normality conclusion
649    pub is_normal: bool,
650    /// Normality confidence
651    pub normality_confidence: f64,
652}
653
654/// Causal analysis results
655#[derive(Debug, Clone, Serialize, Deserialize, Default)]
656pub struct CausalAnalysisResults {
657    /// Causal graph
658    pub causal_graph: CausalGraph,
659    /// Causal effects
660    pub causal_effects: Vec<CausalEffect>,
661    /// Confounding analysis
662    pub confounding_analysis: ConfoundingAnalysis,
663    /// Causal strength measures
664    pub causal_strength: HashMap<String, f64>,
665}
666
667/// Causal graph
668#[derive(Debug, Clone, Serialize, Deserialize)]
669pub struct CausalGraph {
670    /// Adjacency matrix
671    pub adjacency_matrix: Array2<f64>,
672    /// Node names
673    pub node_names: Vec<String>,
674    /// Edge weights
675    pub edge_weights: HashMap<(usize, usize), f64>,
676    /// Graph confidence
677    pub graph_confidence: f64,
678}
679
680/// Causal effect
681#[derive(Debug, Clone, Serialize, Deserialize)]
682pub struct CausalEffect {
683    /// Cause variable
684    pub cause: String,
685    /// Effect variable
686    pub effect: String,
687    /// Effect size
688    pub effect_size: f64,
689    /// Confidence interval
690    pub confidence_interval: (f64, f64),
691    /// P-value
692    pub p_value: f64,
693    /// Causal mechanism
694    pub mechanism: CausalMechanism,
695}
696
697/// Causal mechanisms
698#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
699pub enum CausalMechanism {
700    Direct,
701    Indirect,
702    Mediated,
703    Confounded,
704    Spurious,
705}
706
707/// Confounding analysis
708#[derive(Debug, Clone, Serialize, Deserialize, Default)]
709pub struct ConfoundingAnalysis {
710    /// Detected confounders
711    pub confounders: Vec<String>,
712    /// Confounder strength
713    pub confounder_strength: HashMap<String, f64>,
714    /// Backdoor criteria satisfaction
715    pub backdoor_satisfied: bool,
716    /// Frontdoor criteria satisfaction
717    pub frontdoor_satisfied: bool,
718}
719
720/// Measurement prediction results
721#[derive(Debug, Clone, Serialize, Deserialize)]
722pub struct MeasurementPredictionResults {
723    /// Predicted measurement outcomes
724    pub predictions: Array1<f64>,
725    /// Prediction confidence intervals
726    pub confidence_intervals: Array2<f64>,
727    /// Prediction timestamps
728    pub timestamps: Vec<f64>,
729    /// Model performance metrics
730    pub model_performance: PredictionModelPerformance,
731    /// Uncertainty quantification
732    pub uncertainty: PredictionUncertainty,
733}
734
735/// Prediction model performance
736#[derive(Debug, Clone, Serialize, Deserialize)]
737pub struct PredictionModelPerformance {
738    /// Mean absolute error
739    pub mae: f64,
740    /// Mean squared error
741    pub mse: f64,
742    /// Root mean squared error
743    pub rmse: f64,
744    /// Mean absolute percentage error
745    pub mape: f64,
746    /// R-squared score
747    pub r2_score: f64,
748    /// Prediction accuracy
749    pub accuracy: f64,
750}
751
752/// Prediction uncertainty
753#[derive(Debug, Clone, Serialize, Deserialize)]
754pub struct PredictionUncertainty {
755    /// Aleatoric uncertainty
756    pub aleatoric_uncertainty: Array1<f64>,
757    /// Epistemic uncertainty
758    pub epistemic_uncertainty: Array1<f64>,
759    /// Total uncertainty
760    pub total_uncertainty: Array1<f64>,
761    /// Uncertainty bounds
762    pub uncertainty_bounds: Array2<f64>,
763}
764
765/// Optimization recommendations
766#[derive(Debug, Clone, Serialize, Deserialize)]
767pub struct OptimizationRecommendations {
768    /// Scheduling optimizations
769    pub scheduling_optimizations: Vec<SchedulingOptimization>,
770    /// Protocol optimizations
771    pub protocol_optimizations: Vec<ProtocolOptimization>,
772    /// Resource optimizations
773    pub resource_optimizations: Vec<ResourceOptimization>,
774    /// Performance improvements
775    pub performance_improvements: Vec<PerformanceImprovement>,
776}
777
778/// Scheduling optimization recommendation
779#[derive(Debug, Clone, Serialize, Deserialize)]
780pub struct SchedulingOptimization {
781    /// Optimization type
782    pub optimization_type: SchedulingOptimizationType,
783    /// Expected improvement
784    pub expected_improvement: f64,
785    /// Implementation difficulty
786    pub difficulty: OptimizationDifficulty,
787    /// Recommendation description
788    pub description: String,
789    /// Implementation steps
790    pub implementation_steps: Vec<String>,
791}
792
793/// Scheduling optimization types
794#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
795pub enum SchedulingOptimizationType {
796    MeasurementBatching,
797    TemporalReordering,
798    ParallelExecution,
799    ConditionalOptimization,
800    LatencyReduction,
801}
802
803/// Protocol optimization recommendation
804#[derive(Debug, Clone, Serialize, Deserialize)]
805pub struct ProtocolOptimization {
806    /// Protocol type
807    pub protocol_type: String,
808    /// Optimization description
809    pub description: String,
810    /// Expected benefit
811    pub expected_benefit: f64,
812    /// Risk assessment
813    pub risk_level: RiskLevel,
814    /// Validation requirements
815    pub validation_requirements: Vec<String>,
816}
817
818/// Resource optimization recommendation
819#[derive(Debug, Clone, Serialize, Deserialize)]
820pub struct ResourceOptimization {
821    /// Resource type
822    pub resource_type: ResourceType,
823    /// Current utilization
824    pub current_utilization: f64,
825    /// Optimal utilization
826    pub optimal_utilization: f64,
827    /// Optimization strategy
828    pub strategy: String,
829    /// Expected savings
830    pub expected_savings: f64,
831}
832
833/// Resource types
834#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
835pub enum ResourceType {
836    QuantumProcessor,
837    ClassicalProcessor,
838    Memory,
839    NetworkBandwidth,
840    StorageCapacity,
841}
842
843/// Performance improvement recommendation
844#[derive(Debug, Clone, Serialize, Deserialize)]
845pub struct PerformanceImprovement {
846    /// Improvement area
847    pub area: PerformanceArea,
848    /// Current performance
849    pub current_performance: f64,
850    /// Target performance
851    pub target_performance: f64,
852    /// Improvement strategy
853    pub strategy: String,
854    /// Implementation priority
855    pub priority: Priority,
856}
857
858/// Performance areas
859#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
860pub enum PerformanceArea {
861    MeasurementLatency,
862    MeasurementAccuracy,
863    ThroughputRate,
864    ErrorRate,
865    ResourceEfficiency,
866}
867
868/// Priority levels
869#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
870pub enum Priority {
871    Low,
872    Medium,
873    High,
874    Critical,
875}
876
877/// Risk levels
878#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
879pub enum RiskLevel {
880    Low,
881    Medium,
882    High,
883    VeryHigh,
884}
885
886/// Optimization difficulty levels
887#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
888pub enum OptimizationDifficulty {
889    Easy,
890    Moderate,
891    Difficult,
892    VeryDifficult,
893}
894
895/// Adaptive learning insights
896#[derive(Debug, Clone, Serialize, Deserialize)]
897pub struct AdaptiveLearningInsights {
898    /// Learning progress metrics
899    pub learning_progress: LearningProgress,
900    /// Model adaptation history
901    pub adaptation_history: Vec<AdaptationEvent>,
902    /// Performance trends
903    pub performance_trends: PerformanceTrends,
904    /// Concept drift detection
905    pub drift_detection: DriftDetectionResults,
906    /// Knowledge transfer insights
907    pub transfer_learning: TransferLearningInsights,
908}
909
910/// Learning progress metrics
911#[derive(Debug, Clone, Serialize, Deserialize)]
912pub struct LearningProgress {
913    /// Training iterations completed
914    pub iterations_completed: usize,
915    /// Current learning rate
916    pub current_learning_rate: f64,
917    /// Training loss history
918    pub loss_history: Array1<f64>,
919    /// Validation accuracy history
920    pub accuracy_history: Array1<f64>,
921    /// Convergence status
922    pub convergence_status: ConvergenceStatus,
923}
924
925/// Convergence status
926#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
927pub enum ConvergenceStatus {
928    NotStarted,
929    InProgress,
930    Converged,
931    Diverged,
932    Plateaued,
933    Stuck,
934    Improving,
935    Diverging,
936    Oscillating,
937}
938
939/// Adaptation event
940#[derive(Debug, Clone, Serialize, Deserialize)]
941pub struct AdaptationEvent {
942    /// Event timestamp
943    pub timestamp: SystemTime,
944    /// Adaptation type
945    pub adaptation_type: AdaptationType,
946    /// Trigger condition
947    pub trigger: String,
948    /// Performance before adaptation
949    pub performance_before: f64,
950    /// Performance after adaptation
951    pub performance_after: f64,
952    /// Performance snapshot at time of adaptation
953    pub performance_snapshot: PerformanceMetrics,
954    /// Magnitude of adaptation
955    pub adaptation_magnitude: f64,
956    /// Success indicator
957    pub success_indicator: f64,
958    /// Adaptation success
959    pub success: bool,
960}
961
962/// Adaptation types
963#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
964pub enum AdaptationType {
965    ParameterTuning,
966    ArchitectureChange,
967    FeatureSelection,
968    HyperparameterOptimization,
969    ModelRetrained,
970    ThresholdAdjustment,
971    PerformanceOptimization,
972}
973
974/// Performance trends
975#[derive(Debug, Clone, Serialize, Deserialize)]
976pub struct PerformanceTrends {
977    /// Short-term trend
978    pub short_term_trend: TrendDirection,
979    /// Long-term trend
980    pub long_term_trend: TrendDirection,
981    /// Trend strength
982    pub trend_strength: f64,
983    /// Seasonal patterns
984    pub seasonal_patterns: Option<SeasonalityAnalysis>,
985    /// Performance volatility
986    pub volatility: f64,
987}
988
989/// Drift detection results
990#[derive(Debug, Clone, Serialize, Deserialize)]
991pub struct DriftDetectionResults {
992    /// Drift detected
993    pub drift_detected: bool,
994    /// Drift type
995    pub drift_type: Option<DriftType>,
996    /// Drift magnitude
997    pub drift_magnitude: f64,
998    /// Detection confidence
999    pub detection_confidence: f64,
1000    /// Recommended actions
1001    pub recommended_actions: Vec<String>,
1002}
1003
1004/// Drift types
1005#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1006pub enum DriftType {
1007    Gradual,
1008    Sudden,
1009    Incremental,
1010    Recurring,
1011    Virtual,
1012    PerformanceDegradation,
1013    QualityDrift,
1014    ConceptDrift,
1015}
1016
1017/// Transfer learning insights
1018#[derive(Debug, Clone, Serialize, Deserialize)]
1019pub struct TransferLearningInsights {
1020    /// Knowledge transfer effectiveness
1021    pub transfer_effectiveness: f64,
1022    /// Source domain similarity
1023    pub domain_similarity: f64,
1024    /// Feature transferability
1025    pub feature_transferability: Array1<f64>,
1026    /// Adaptation requirements
1027    pub adaptation_requirements: Vec<String>,
1028    /// Transfer learning recommendations
1029    pub recommendations: Vec<String>,
1030}
1031
1032/// Device capabilities for mid-circuit measurements
1033#[derive(Debug, Clone, Serialize, Deserialize)]
1034pub struct MidCircuitCapabilities {
1035    /// Maximum number of mid-circuit measurements
1036    pub max_measurements: Option<usize>,
1037    /// Supported measurement types
1038    pub supported_measurement_types: Vec<MeasurementType>,
1039    /// Classical register capacity
1040    pub classical_register_capacity: usize,
1041    /// Maximum classical processing time
1042    pub max_classical_processing_time: f64,
1043    /// Real-time feedback support
1044    pub realtime_feedback: bool,
1045    /// Parallel measurement support
1046    pub parallel_measurements: bool,
1047    /// Native measurement protocols
1048    pub native_protocols: Vec<String>,
1049    /// Timing constraints
1050    pub timing_constraints: TimingConstraints,
1051}
1052
1053/// Supported measurement types
1054#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1055pub enum MeasurementType {
1056    /// Standard Z-basis measurement
1057    ZBasis,
1058    /// X-basis measurement
1059    XBasis,
1060    /// Y-basis measurement
1061    YBasis,
1062    /// Custom Pauli measurement
1063    Pauli(String),
1064    /// Joint measurement of multiple qubits
1065    Joint,
1066    /// Non-destructive measurement
1067    NonDestructive,
1068}
1069
1070/// Timing constraints for mid-circuit measurements
1071#[derive(Debug, Clone, Serialize, Deserialize)]
1072pub struct TimingConstraints {
1073    /// Minimum time between measurements (nanoseconds)
1074    pub min_measurement_spacing: f64,
1075    /// Maximum measurement duration (nanoseconds)
1076    pub max_measurement_duration: f64,
1077    /// Classical processing deadline (nanoseconds)
1078    pub classical_deadline: f64,
1079    /// Coherence time limits
1080    pub coherence_limits: HashMap<QubitId, f64>,
1081}
1082
1083// Additional types for analytics modules
1084
1085/// Statistical anomaly information
1086#[derive(Debug, Clone, Serialize, Deserialize)]
1087pub struct StatisticalAnomaly {
1088    /// Index in the data series
1089    pub index: usize,
1090    /// Anomalous value
1091    pub value: f64,
1092    /// Z-score of the anomaly
1093    pub z_score: f64,
1094    /// Statistical p-value
1095    pub p_value: f64,
1096    /// Metric type
1097    pub metric_type: String,
1098    /// Severity of the anomaly
1099    pub anomaly_severity: AnomalySeverity,
1100}
1101
1102/// Temporal anomaly information
1103#[derive(Debug, Clone, Serialize, Deserialize)]
1104pub struct TemporalAnomaly {
1105    /// Start index of anomalous period
1106    pub start_index: usize,
1107    /// End index of anomalous period
1108    pub end_index: usize,
1109    /// Change point index
1110    pub change_point: usize,
1111    /// Magnitude of change
1112    pub magnitude: f64,
1113    /// Direction of change
1114    pub direction: ChangeDirection,
1115    /// Confidence in anomaly detection
1116    pub confidence: f64,
1117}
1118
1119/// Direction of change in temporal anomaly
1120#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1121pub enum ChangeDirection {
1122    Increase,
1123    Decrease,
1124    Oscillation,
1125}
1126
1127/// Pattern anomaly information
1128#[derive(Debug, Clone, Serialize, Deserialize)]
1129pub struct PatternAnomaly {
1130    /// Type of pattern anomaly
1131    pub pattern_type: PatternType,
1132    /// Description of the anomaly
1133    pub description: String,
1134    /// Severity level
1135    pub severity: AnomalySeverity,
1136    /// Indices affected by the anomaly
1137    pub affected_indices: Vec<usize>,
1138    /// Confidence in detection
1139    pub confidence: f64,
1140}
1141
1142/// Types of pattern anomalies
1143#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1144pub enum PatternType {
1145    CorrelationAnomaly,
1146    ConstantSequence,
1147    PeriodicityBreak,
1148    TrendReversal,
1149    VariabilityAnomaly,
1150}
1151
1152/// Summary of all anomaly detection results
1153#[derive(Debug, Clone, Serialize, Deserialize)]
1154pub struct AnomalySummary {
1155    /// Total number of anomalies detected
1156    pub total_anomalies: usize,
1157    /// Overall anomaly rate
1158    pub anomaly_rate: f64,
1159    /// Distribution by severity
1160    pub severity_distribution: Vec<(String, usize)>,
1161    /// Types of anomalies found
1162    pub anomaly_types: Vec<String>,
1163    /// Recommendations for addressing anomalies
1164    pub recommendations: Vec<String>,
1165}
1166
1167/// Causal relationship information (only missing fields if any)
1168#[derive(Debug, Clone, Serialize, Deserialize)]
1169pub struct CausalRelationship {
1170    /// Cause variable
1171    pub cause: String,
1172    /// Effect variable
1173    pub effect: String,
1174    /// Strength of causal relationship
1175    pub causal_strength: f64,
1176    /// Direction of causality
1177    pub causal_direction: CausalDirection,
1178    /// P-value of causal test
1179    pub p_value: f64,
1180    /// Confidence interval for effect
1181    pub confidence_interval: (f64, f64),
1182    /// Causal mechanism
1183    pub mechanism: CausalMechanism,
1184}
1185
1186/// Direction of causal relationship
1187#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1188pub enum CausalDirection {
1189    Forward,
1190    Backward,
1191    Bidirectional,
1192    None,
1193}
1194
1195/// Edge type in causal graph
1196#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1197pub enum EdgeType {
1198    Directed,
1199    Undirected,
1200    Bidirected,
1201}
1202
1203/// Intervention analysis results
1204#[derive(Debug, Clone, Serialize, Deserialize)]
1205pub struct InterventionAnalysis {
1206    /// Type of intervention
1207    pub intervention_type: String,
1208    /// Target variable
1209    pub target_variable: String,
1210    /// Magnitude of intervention
1211    pub intervention_magnitude: f64,
1212    /// Predicted effects
1213    pub predicted_effects: Vec<PredictedEffect>,
1214    /// Cost of intervention
1215    pub intervention_cost: f64,
1216    /// Benefit-cost ratio
1217    pub benefit_ratio: f64,
1218}
1219
1220/// Predicted effect of intervention
1221#[derive(Debug, Clone, Serialize, Deserialize)]
1222pub struct PredictedEffect {
1223    /// Variable affected
1224    pub variable: String,
1225    /// Effect size
1226    pub effect_size: f64,
1227    /// Confidence interval
1228    pub confidence_interval: (f64, f64),
1229    /// P-value
1230    pub p_value: f64,
1231}
1232
1233/// Confounding assessment
1234#[derive(Debug, Clone, Serialize, Deserialize)]
1235pub struct ConfoundingAssessment {
1236    /// Identified confounders
1237    pub confounders: Vec<ConfoundingVariable>,
1238    /// Overall confounding risk
1239    pub overall_confounding_risk: String,
1240    /// Recommendations
1241    pub recommendations: Vec<String>,
1242}
1243
1244/// Confounding variable information
1245#[derive(Debug, Clone, Serialize, Deserialize)]
1246pub struct ConfoundingVariable {
1247    /// Variable name
1248    pub variable: String,
1249    /// Confounding strength
1250    pub confounding_strength: f64,
1251    /// Adjustment method
1252    pub adjustment_method: String,
1253    /// P-value
1254    pub p_value: f64,
1255}
1256
1257/// Prediction model information
1258#[derive(Debug, Clone, Serialize, Deserialize)]
1259pub struct PredictionModel {
1260    /// Model type
1261    pub model_type: String,
1262    /// Model coefficients
1263    pub coefficients: Vec<f64>,
1264    /// Feature names
1265    pub feature_names: Vec<String>,
1266    /// Training accuracy
1267    pub training_accuracy: f64,
1268    /// Validation accuracy
1269    pub validation_accuracy: f64,
1270    /// Last training time
1271    pub last_trained: SystemTime,
1272    /// Hyperparameters
1273    pub hyperparameters: Vec<(String, f64)>,
1274}
1275
1276impl Default for PredictionModel {
1277    fn default() -> Self {
1278        Self {
1279            model_type: "linear".to_string(),
1280            coefficients: vec![],
1281            feature_names: vec![],
1282            training_accuracy: 0.0,
1283            validation_accuracy: 0.0,
1284            last_trained: SystemTime::now(),
1285            hyperparameters: vec![],
1286        }
1287    }
1288}
1289
1290/// ML features for optimization
1291#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1292pub struct MLFeatures {
1293    /// Statistical features
1294    pub statistical_features: StatisticalFeatures,
1295    /// Temporal features
1296    pub temporal_features: TemporalFeatures,
1297    /// Pattern features
1298    pub pattern_features: PatternFeatures,
1299    /// Feature importance
1300    pub feature_importance: Vec<FeatureImportance>,
1301}
1302
1303/// Statistical features
1304#[derive(Debug, Clone, Serialize, Deserialize)]
1305pub struct StatisticalFeatures {
1306    /// Mean latency
1307    pub mean_latency: f64,
1308    /// Standard deviation of latency
1309    pub std_latency: f64,
1310    /// Mean confidence
1311    pub mean_confidence: f64,
1312    /// Standard deviation of confidence
1313    pub std_confidence: f64,
1314    /// Skewness of latency
1315    pub skewness_latency: f64,
1316    /// Kurtosis of latency
1317    pub kurtosis_latency: f64,
1318}
1319
1320impl Default for StatisticalFeatures {
1321    fn default() -> Self {
1322        Self {
1323            mean_latency: 0.0,
1324            std_latency: 0.0,
1325            mean_confidence: 0.0,
1326            std_confidence: 0.0,
1327            skewness_latency: 0.0,
1328            kurtosis_latency: 0.0,
1329        }
1330    }
1331}
1332
1333/// Temporal features
1334#[derive(Debug, Clone, Serialize, Deserialize)]
1335pub struct TemporalFeatures {
1336    /// Measurement rate
1337    pub measurement_rate: f64,
1338    /// Temporal autocorrelation
1339    pub temporal_autocorrelation: f64,
1340    /// Trend slope
1341    pub trend_slope: f64,
1342    /// Periodicity strength
1343    pub periodicity_strength: f64,
1344}
1345
1346impl Default for TemporalFeatures {
1347    fn default() -> Self {
1348        Self {
1349            measurement_rate: 0.0,
1350            temporal_autocorrelation: 0.0,
1351            trend_slope: 0.0,
1352            periodicity_strength: 0.0,
1353        }
1354    }
1355}
1356
1357/// Pattern features
1358#[derive(Debug, Clone, Serialize, Deserialize)]
1359pub struct PatternFeatures {
1360    /// Correlation between latency and confidence
1361    pub latency_confidence_correlation: f64,
1362    /// Measurement consistency
1363    pub measurement_consistency: f64,
1364    /// Outlier ratio
1365    pub outlier_ratio: f64,
1366    /// Pattern complexity
1367    pub pattern_complexity: f64,
1368}
1369
1370impl Default for PatternFeatures {
1371    fn default() -> Self {
1372        Self {
1373            latency_confidence_correlation: 0.0,
1374            measurement_consistency: 0.0,
1375            outlier_ratio: 0.0,
1376            pattern_complexity: 0.0,
1377        }
1378    }
1379}
1380
1381/// Feature importance
1382#[derive(Debug, Clone, Serialize, Deserialize)]
1383pub struct FeatureImportance {
1384    /// Feature name
1385    pub feature_name: String,
1386    /// Importance score
1387    pub importance: f64,
1388}
1389
1390/// Training epoch information
1391#[derive(Debug, Clone, Serialize, Deserialize)]
1392pub struct TrainingEpoch {
1393    /// Epoch number
1394    pub epoch_number: usize,
1395    /// Features used
1396    pub features: MLFeatures,
1397    /// Target metrics
1398    pub target_metrics: PerformanceMetrics,
1399    /// Training loss
1400    pub training_loss: f64,
1401    /// Validation loss
1402    pub validation_loss: f64,
1403    /// Learning rate
1404    pub learning_rate: f64,
1405}
1406
1407/// Model performance metrics
1408#[derive(Debug, Clone, Serialize, Deserialize)]
1409pub struct ModelPerformance {
1410    /// Training accuracy
1411    pub training_accuracy: f64,
1412    /// Validation accuracy
1413    pub validation_accuracy: f64,
1414    /// Cross-validation score
1415    pub cross_validation_score: f64,
1416    /// Overfitting score
1417    pub overfitting_score: f64,
1418}
1419
1420/// Optimization model information
1421#[derive(Debug, Clone, Serialize, Deserialize)]
1422pub struct OptimizationModel {
1423    /// Model type
1424    pub model_type: String,
1425    /// Model parameters
1426    pub parameters: Vec<f64>,
1427    /// Training features
1428    pub training_features: MLFeatures,
1429    /// Model performance
1430    pub model_performance: ModelPerformance,
1431    /// Last update time
1432    pub last_updated: SystemTime,
1433}
1434
1435/// Performance improvements prediction
1436#[derive(Debug, Clone, Serialize, Deserialize)]
1437pub struct PerformanceImprovements {
1438    /// Latency reduction
1439    pub latency_reduction: f64,
1440    /// Confidence increase
1441    pub confidence_increase: f64,
1442    /// Throughput increase
1443    pub throughput_increase: f64,
1444    /// Error rate reduction
1445    pub error_rate_reduction: f64,
1446    /// Overall score improvement
1447    pub overall_score_improvement: f64,
1448}
1449
1450impl Default for PerformanceImprovements {
1451    fn default() -> Self {
1452        Self {
1453            latency_reduction: 0.0,
1454            confidence_increase: 0.0,
1455            throughput_increase: 0.0,
1456            error_rate_reduction: 0.0,
1457            overall_score_improvement: 0.0,
1458        }
1459    }
1460}
1461
1462/// Optimization recommendation
1463#[derive(Debug, Clone, Serialize, Deserialize)]
1464pub struct OptimizationRecommendation {
1465    /// Parameter to optimize
1466    pub parameter: String,
1467    /// Current value
1468    pub current_value: f64,
1469    /// Recommended value
1470    pub recommended_value: f64,
1471    /// Expected improvement
1472    pub expected_improvement: f64,
1473    /// Confidence in recommendation
1474    pub confidence: f64,
1475    /// Rationale for recommendation
1476    pub rationale: String,
1477}
1478
1479/// Optimization result
1480#[derive(Debug, Clone, Serialize, Deserialize)]
1481pub struct OptimizationResult {
1482    /// Optimization recommendations
1483    pub recommendations: Vec<OptimizationRecommendation>,
1484    /// Predicted improvements
1485    pub predicted_improvements: PerformanceImprovements,
1486    /// Confidence in optimization
1487    pub confidence: f64,
1488    /// Model version
1489    pub model_version: String,
1490}
1491
1492impl Default for OptimizationResult {
1493    fn default() -> Self {
1494        Self {
1495            recommendations: vec![],
1496            predicted_improvements: PerformanceImprovements::default(),
1497            confidence: 0.5,
1498            model_version: "1.0".to_string(),
1499        }
1500    }
1501}
quantrs2_device/mid_circuit_measurements/results.rs

quantrs2_device/mid_circuit_measurements/
results.rs
