quantrs2_circuit/debugger/
types.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::builder::Circuit;
6use crate::scirs2_integration::{AnalyzerConfig, GraphMetrics, SciRS2CircuitAnalyzer};
7use quantrs2_core::{
8    error::{QuantRS2Error, QuantRS2Result},
9    gate::GateOp,
10    qubit::QubitId,
11};
12use scirs2_core::ndarray::{Array1, Array2};
13use scirs2_core::Complex64;
14use serde::{Deserialize, Serialize};
15use std::collections::{HashMap, HashSet, VecDeque};
16use std::sync::{Arc, Mutex, RwLock};
17use std::time::{Duration, Instant, SystemTime};
18
19/// Gate properties for debugging
20#[derive(Debug, Clone)]
21pub struct GateProperties {
22    /// Gate name
23    pub name: String,
24    /// Gate matrix representation
25    pub matrix: Option<Array2<Complex64>>,
26    /// Target qubits
27    pub target_qubits: Vec<QubitId>,
28    /// Control qubits
29    pub control_qubits: Vec<QubitId>,
30    /// Gate parameters
31    pub parameters: HashMap<String, f64>,
32    /// Gate fidelity
33    pub fidelity: Option<f64>,
34    /// Gate execution time
35    pub execution_time: Duration,
36}
37/// Breakpoint action
38#[derive(Debug, Clone)]
39pub enum BreakpointAction {
40    /// Pause execution
41    Pause,
42    /// Log information
43    Log { message: String },
44    /// Take snapshot
45    Snapshot,
46    /// Run custom analysis
47    CustomAnalysis { analysis_type: String },
48}
49/// Analysis depth levels
50#[derive(Debug, Clone)]
51pub enum AnalysisDepth {
52    /// Basic performance metrics
53    Basic,
54    /// Standard analysis with trends
55    Standard,
56    /// Comprehensive analysis with predictions
57    Comprehensive,
58    /// Deep analysis with ML insights
59    Deep,
60}
61/// Breakpoint management system
62#[derive(Debug, Clone)]
63pub struct BreakpointManager {
64    /// Gate-based breakpoints
65    pub gate_breakpoints: HashSet<usize>,
66    /// Qubit-based breakpoints
67    pub qubit_breakpoints: HashMap<QubitId, BreakpointCondition>,
68    /// State-based breakpoints
69    pub state_breakpoints: Vec<StateBreakpoint>,
70    /// Conditional breakpoints
71    pub conditional_breakpoints: Vec<ConditionalBreakpoint>,
72    /// Breakpoint hit counts
73    pub hit_counts: HashMap<String, usize>,
74}
75/// Trend direction
76#[derive(Debug, Clone)]
77pub enum TrendDirection {
78    /// Increasing trend
79    Increasing,
80    /// Decreasing trend
81    Decreasing,
82    /// Stable/flat trend
83    Stable,
84    /// Oscillating trend
85    Oscillating,
86    /// Unknown trend
87    Unknown,
88}
89/// Gate execution metrics
90#[derive(Debug, Clone)]
91pub struct GateExecutionMetrics {
92    /// Execution time
93    pub execution_time: Duration,
94    /// Memory usage change
95    pub memory_change: i64,
96    /// Error rate estimate
97    pub error_rate: Option<f64>,
98    /// Resource utilization
99    pub resource_utilization: f64,
100}
101/// Gate visualization information
102#[derive(Debug, Clone)]
103pub struct GateVisualization {
104    /// Gate name
105    pub name: String,
106    /// Position in circuit
107    pub position: (usize, usize),
108    /// Gate type for styling
109    pub gate_type: GateType,
110    /// Visual attributes
111    pub attributes: GateAttributes,
112}
113/// Error pattern identification
114#[derive(Debug, Clone)]
115pub struct ErrorPattern {
116    /// Pattern type
117    pub pattern_type: PatternType,
118    /// Pattern frequency
119    pub frequency: f64,
120    /// Pattern description
121    pub description: String,
122    /// Confidence score
123    pub confidence: f64,
124}
125/// Export formats
126#[derive(Debug, Clone, Hash, Eq, PartialEq)]
127pub enum ExportFormat {
128    /// PNG image
129    PNG,
130    /// SVG vector graphics
131    SVG,
132    /// PDF document
133    PDF,
134    /// JSON data
135    JSON,
136    /// CSV data
137    CSV,
138    /// HTML interactive
139    HTML,
140}
141/// Visualization snapshot
142#[derive(Debug, Clone)]
143pub struct VisualizationSnapshot<const N: usize> {
144    /// Snapshot timestamp
145    pub timestamp: SystemTime,
146    /// Gate index when snapshot was taken
147    pub gate_index: usize,
148    /// Visualization data
149    pub visualization: Visualization<N>,
150    /// Snapshot metadata
151    pub metadata: HashMap<String, String>,
152}
153/// Solution recommendation
154#[derive(Debug, Clone)]
155pub struct Solution {
156    /// Solution description
157    pub description: String,
158    /// Implementation difficulty
159    pub difficulty: Difficulty,
160    /// Expected effectiveness
161    pub effectiveness: f64,
162    /// Implementation steps
163    pub steps: Vec<String>,
164}
165/// State-based breakpoint
166#[derive(Debug, Clone)]
167pub struct StateBreakpoint {
168    /// Breakpoint ID
169    pub id: String,
170    /// Target state pattern
171    pub target_state: StatePattern,
172    /// Tolerance for state matching
173    pub tolerance: f64,
174    /// Whether this breakpoint is enabled
175    pub enabled: bool,
176}
177/// Export options for visualizations
178#[derive(Debug, Clone)]
179pub struct ExportOptions {
180    /// Supported export formats
181    pub formats: HashSet<ExportFormat>,
182    /// Default export quality
183    pub default_quality: RenderingQuality,
184    /// Export directory
185    pub export_directory: Option<String>,
186    /// Auto-export enabled
187    pub auto_export: bool,
188}
189/// Memory usage statistics
190#[derive(Debug, Clone)]
191pub struct MemoryStatistics {
192    /// Average memory usage
193    pub average_usage: f64,
194    /// Peak memory usage
195    pub peak_usage: usize,
196    /// Memory efficiency score
197    pub efficiency_score: f64,
198    /// Memory leak indicators
199    pub leak_indicators: Vec<String>,
200}
201/// Profiling statistics
202#[derive(Debug, Clone)]
203pub struct ProfilingStatistics {
204    /// Total samples collected
205    pub total_samples: usize,
206    /// Profiling duration
207    pub profiling_duration: Duration,
208    /// Average sample rate
209    pub average_sample_rate: f64,
210    /// Performance metrics
211    pub performance_metrics: HashMap<String, f64>,
212}
213/// Types of performance bottlenecks
214#[derive(Debug, Clone)]
215pub enum BottleneckType {
216    /// CPU bound operations
217    CpuBound,
218    /// Memory bound operations
219    MemoryBound,
220    /// I/O bound operations
221    IoBound,
222    /// Gate execution bottleneck
223    GateExecution,
224    /// State vector operations
225    StateVector,
226    /// Quantum entanglement operations
227    Entanglement,
228}
229/// Priority levels
230#[derive(Debug, Clone)]
231pub enum Priority {
232    /// Low priority
233    Low,
234    /// Medium priority
235    Medium,
236    /// High priority
237    High,
238    /// Critical priority
239    Critical,
240}
241/// Types of error patterns
242#[derive(Debug, Clone)]
243pub enum PatternType {
244    /// Periodic error pattern
245    Periodic,
246    /// Burst error pattern
247    Burst,
248    /// Gradual error pattern
249    Gradual,
250    /// Random error pattern
251    Random,
252    /// Systematic error pattern
253    Systematic,
254}
255/// Timing information
256#[derive(Debug, Clone)]
257pub struct TimingInfo {
258    /// Execution start time
259    pub start_time: SystemTime,
260    /// Current execution time
261    pub current_time: SystemTime,
262    /// Total execution duration
263    pub total_duration: Duration,
264    /// Gate execution times
265    pub gate_times: Vec<Duration>,
266    /// Timing statistics
267    pub timing_stats: TimingStatistics,
268}
269/// Single history entry
270#[derive(Debug, Clone)]
271pub struct HistoryEntry<const N: usize> {
272    /// Entry timestamp
273    pub timestamp: SystemTime,
274    /// Gate that was executed
275    pub gate_executed: Option<Box<dyn GateOp>>,
276    /// State before execution
277    pub state_before: Array1<Complex64>,
278    /// State after execution
279    pub state_after: Array1<Complex64>,
280    /// Execution metrics
281    pub execution_metrics: GateExecutionMetrics,
282    /// Any errors that occurred
283    pub errors: Vec<DebugError>,
284}
285/// Memory usage information
286#[derive(Debug, Clone)]
287pub struct MemoryUsage {
288    /// Current memory usage in bytes
289    pub current_usage: usize,
290    /// Peak memory usage
291    pub peak_usage: usize,
292    /// Memory usage history
293    pub usage_history: VecDeque<MemorySnapshot>,
294    /// Memory allocation breakdown
295    pub allocation_breakdown: HashMap<String, usize>,
296}
297/// Gate types for visualization
298#[derive(Debug, Clone)]
299pub enum GateType {
300    /// Single qubit gate
301    SingleQubit,
302    /// Two qubit gate
303    TwoQubit,
304    /// Multi qubit gate
305    MultiQubit,
306    /// Measurement
307    Measurement,
308    /// Barrier
309    Barrier,
310}
311/// Execution status of the debugger
312#[derive(Debug, Clone, PartialEq, Eq)]
313pub enum ExecutionStatus {
314    /// Debugger is ready to start
315    Ready,
316    /// Currently executing
317    Running,
318    /// Paused at a breakpoint
319    Paused,
320    /// Stopped by user
321    Stopped,
322    /// Execution completed
323    Completed,
324    /// Error occurred during execution
325    Error { message: String },
326    /// Stepping through gates one by one
327    Stepping,
328}
329/// Visual attributes for gates
330#[derive(Debug, Clone)]
331pub struct GateAttributes {
332    /// Gate color
333    pub color: Option<String>,
334    /// Gate size
335    pub size: Option<f64>,
336    /// Gate style
337    pub style: Option<String>,
338    /// Additional properties
339    pub properties: HashMap<String, String>,
340}
341/// Watched performance metrics
342#[derive(Debug, Clone)]
343pub struct WatchedMetric {
344    /// Metric name
345    pub name: String,
346    /// Current metric value
347    pub current_value: f64,
348    /// Metric history
349    pub history: VecDeque<MetricSnapshot>,
350    /// Watch configuration
351    pub config: WatchConfig,
352}
353/// Impact assessment
354#[derive(Debug, Clone)]
355pub struct ImpactAssessment {
356    /// Performance impact score
357    pub performance_impact: f64,
358    /// Memory impact score
359    pub memory_impact: f64,
360    /// Accuracy impact score
361    pub accuracy_impact: f64,
362    /// Overall impact score
363    pub overall_impact: f64,
364}
365/// Current execution state of the debugger
366#[derive(Debug, Clone)]
367pub struct ExecutionState<const N: usize> {
368    /// Current gate index being executed
369    pub current_gate_index: usize,
370    /// Current quantum state
371    pub current_state: Array1<Complex64>,
372    /// Execution status
373    pub status: ExecutionStatus,
374    /// Number of executed gates
375    pub gates_executed: usize,
376    /// Current execution depth
377    pub current_depth: usize,
378    /// Memory usage tracking
379    pub memory_usage: MemoryUsage,
380    /// Timing information
381    pub timing_info: TimingInfo,
382}
383/// Watched quantum state
384#[derive(Debug, Clone)]
385pub struct WatchedState<const N: usize> {
386    /// State name
387    pub name: String,
388    /// Current state value
389    pub current_state: Array1<Complex64>,
390    /// State history
391    pub history: VecDeque<StateSnapshot<N>>,
392    /// Watch configuration
393    pub config: WatchConfig,
394}
395/// Connection visualization
396#[derive(Debug, Clone)]
397pub struct ConnectionVisualization {
398    /// Source position
399    pub source: (usize, usize),
400    /// Target position
401    pub target: (usize, usize),
402    /// Connection type
403    pub connection_type: ConnectionType,
404}
405/// Result of a single debugging step
406#[derive(Debug, Clone)]
407pub enum StepResult {
408    /// Step executed successfully
409    Success,
410    /// Hit a breakpoint
411    Breakpoint,
412    /// Execution completed
413    Completed,
414    /// Error occurred
415    Error(QuantRS2Error),
416}
417/// Performance sample
418#[derive(Debug, Clone)]
419pub struct PerformanceSample {
420    /// Sample timestamp
421    pub timestamp: SystemTime,
422    /// CPU usage
423    pub cpu_usage: f64,
424    /// Memory usage
425    pub memory_usage: usize,
426    /// Gate execution time
427    pub gate_execution_time: Duration,
428    /// Quantum state complexity
429    pub state_complexity: f64,
430    /// Error rates
431    pub error_rates: HashMap<String, f64>,
432}
433/// Types of errors to detect
434#[derive(Debug, Clone, Hash, Eq, PartialEq)]
435pub enum ErrorType {
436    /// State vector errors
437    StateVectorError,
438    /// Gate execution errors
439    GateExecutionError,
440    /// Memory errors
441    MemoryError,
442    /// Timing errors
443    TimingError,
444    /// Numerical errors
445    NumericalError,
446    /// Logical errors
447    LogicalError,
448}
449/// Types of visualizations
450#[derive(Debug, Clone, Hash, Eq, PartialEq)]
451pub enum VisualizationType {
452    /// Circuit diagram
453    CircuitDiagram,
454    /// Bloch sphere
455    BlochSphere,
456    /// State vector
457    StateVector,
458    /// Probability distribution
459    ProbabilityDistribution,
460    /// Entanglement visualization
461    Entanglement,
462    /// Performance graphs
463    Performance,
464    /// Memory usage graphs
465    Memory,
466    /// Error analysis plots
467    ErrorAnalysis,
468}
469/// Conditional breakpoint
470#[derive(Debug, Clone)]
471pub struct ConditionalBreakpoint {
472    /// Breakpoint ID
473    pub id: String,
474    /// Condition to evaluate
475    pub condition: BreakpointCondition,
476    /// Action to take when condition is met
477    pub action: BreakpointAction,
478    /// Whether this breakpoint is enabled
479    pub enabled: bool,
480}
481/// State snapshot for history
482#[derive(Debug, Clone)]
483pub struct StateSnapshot<const N: usize> {
484    /// Snapshot timestamp
485    pub timestamp: SystemTime,
486    /// State at this point
487    pub state: Array1<Complex64>,
488    /// Gate index when snapshot was taken
489    pub gate_index: usize,
490    /// Additional metadata
491    pub metadata: HashMap<String, String>,
492}
493/// Trend analysis for metrics
494#[derive(Debug, Clone)]
495pub struct TrendAnalysis {
496    /// Metric name
497    pub metric_name: String,
498    /// Trend direction
499    pub trend_direction: TrendDirection,
500    /// Trend strength
501    pub trend_strength: f64,
502    /// Trend prediction
503    pub prediction: Option<f64>,
504    /// Confidence score
505    pub confidence: f64,
506}
507/// Error correlation analysis
508#[derive(Debug, Clone)]
509pub struct ErrorCorrelation {
510    /// First error type
511    pub error_type_1: ErrorType,
512    /// Second error type
513    pub error_type_2: ErrorType,
514    /// Correlation strength
515    pub correlation_strength: f64,
516    /// Correlation type
517    pub correlation_type: CorrelationType,
518}
519/// Gate snapshot for history
520#[derive(Debug, Clone)]
521pub struct GateSnapshot {
522    /// Snapshot timestamp
523    pub timestamp: SystemTime,
524    /// Gate properties
525    pub properties: GateProperties,
526    /// Gate execution metrics
527    pub execution_metrics: GateExecutionMetrics,
528}
529/// Error statistics
530#[derive(Debug, Clone)]
531pub struct ErrorStatistics {
532    /// Total errors detected
533    pub total_errors: usize,
534    /// Errors by type
535    pub errors_by_type: HashMap<ErrorType, usize>,
536    /// Errors by severity
537    pub errors_by_severity: HashMap<ErrorSeverity, usize>,
538    /// Error rate over time
539    pub error_rate: f64,
540    /// Error trends
541    pub error_trends: HashMap<ErrorType, TrendDirection>,
542}
543/// Execution history tracking
544#[derive(Debug, Clone)]
545pub struct ExecutionHistory<const N: usize> {
546    /// History entries
547    pub entries: VecDeque<HistoryEntry<N>>,
548    /// Maximum entries to keep
549    pub max_entries: usize,
550    /// History statistics
551    pub statistics: HistoryStatistics,
552}
553/// Watched gate properties
554#[derive(Debug, Clone)]
555pub struct WatchedGate {
556    /// Gate name
557    pub name: String,
558    /// Current gate properties
559    pub current_properties: GateProperties,
560    /// Property history
561    pub history: VecDeque<GateSnapshot>,
562    /// Watch configuration
563    pub config: WatchConfig,
564}
565/// Debug error information
566#[derive(Debug, Clone)]
567pub struct DebugError {
568    /// Error type
569    pub error_type: ErrorType,
570    /// Error severity
571    pub severity: ErrorSeverity,
572    /// Error message
573    pub message: String,
574    /// Gate index where error occurred
575    pub gate_index: Option<usize>,
576    /// Timestamp
577    pub timestamp: SystemTime,
578    /// Error context
579    pub context: HashMap<String, String>,
580    /// Suggested fixes
581    pub suggested_fixes: Vec<String>,
582}
583/// State pattern for matching
584#[derive(Debug, Clone)]
585pub enum StatePattern {
586    /// Specific amplitude pattern
587    AmplitudePattern { amplitudes: Vec<Complex64> },
588    /// Probability distribution pattern
589    ProbabilityPattern { probabilities: Vec<f64> },
590    /// Entanglement pattern
591    EntanglementPattern { entanglement_measure: f64 },
592    /// Custom pattern with evaluation function
593    Custom { name: String, description: String },
594}
595/// Timing statistics
596#[derive(Debug, Clone)]
597pub struct TimingStatistics {
598    /// Average gate execution time
599    pub average_gate_time: Duration,
600    /// Fastest gate execution
601    pub fastest_gate: Duration,
602    /// Slowest gate execution
603    pub slowest_gate: Duration,
604    /// Execution variance
605    pub execution_variance: f64,
606}
607/// Prediction result
608#[derive(Debug, Clone)]
609pub struct PredictionResult {
610    /// Predicted value
611    pub predicted_value: f64,
612    /// Confidence interval
613    pub confidence_interval: (f64, f64),
614    /// Prediction accuracy
615    pub accuracy: f64,
616    /// Time horizon
617    pub time_horizon: Duration,
618}
619/// Rendering statistics
620#[derive(Debug, Clone)]
621pub struct RenderingStatistics {
622    /// Total renders performed
623    pub total_renders: usize,
624    /// Average render time
625    pub average_render_time: Duration,
626    /// Total render time
627    pub total_render_time: Duration,
628    /// Render success rate
629    pub success_rate: f64,
630    /// Memory usage for rendering
631    pub memory_usage: usize,
632}
633/// Rendering quality levels
634#[derive(Debug, Clone)]
635pub enum RenderingQuality {
636    /// Low quality for fast rendering
637    Low,
638    /// Medium quality
639    Medium,
640    /// High quality
641    High,
642    /// Ultra high quality
643    Ultra,
644}
645/// Visualization data
646#[derive(Debug, Clone)]
647pub struct Visualization<const N: usize> {
648    /// Visualization type
649    pub visualization_type: VisualizationType,
650    /// Visualization data
651    pub data: VisualizationData<N>,
652    /// Rendering metadata
653    pub metadata: VisualizationMetadata,
654    /// Last update time
655    pub last_update: SystemTime,
656}
657/// Error detector for quantum circuits
658#[derive(Debug, Clone)]
659pub struct ErrorDetector<const N: usize> {
660    /// Error detection configuration
661    pub config: ErrorDetectionConfig,
662    /// Detected errors
663    pub detected_errors: Vec<DebugError>,
664    /// Error statistics
665    pub error_statistics: ErrorStatistics,
666    /// Error analysis results
667    pub analysis_results: ErrorAnalysisResults,
668}
669/// Root cause analysis
670#[derive(Debug, Clone)]
671pub struct RootCause {
672    /// Cause description
673    pub description: String,
674    /// Confidence in this being the root cause
675    pub confidence: f64,
676    /// Contributing factors
677    pub contributing_factors: Vec<String>,
678    /// Recommended solutions
679    pub solutions: Vec<Solution>,
680}
681/// Error analysis results
682#[derive(Debug, Clone)]
683pub struct ErrorAnalysisResults {
684    /// Error patterns identified
685    pub error_patterns: Vec<ErrorPattern>,
686    /// Root cause analysis
687    pub root_causes: Vec<RootCause>,
688    /// Error correlations
689    pub correlations: Vec<ErrorCorrelation>,
690    /// Prediction results
691    pub predictions: HashMap<ErrorType, PredictionResult>,
692}
693/// Watch variables manager
694#[derive(Debug, Clone)]
695pub struct WatchManager<const N: usize> {
696    /// Watched quantum states
697    pub watched_states: HashMap<String, WatchedState<N>>,
698    /// Watched gate properties
699    pub watched_gates: HashMap<String, WatchedGate>,
700    /// Watched performance metrics
701    pub watched_metrics: HashMap<String, WatchedMetric>,
702    /// Watch expressions
703    pub watch_expressions: Vec<WatchExpression>,
704}
705/// Watch expression for custom monitoring
706#[derive(Debug, Clone)]
707pub struct WatchExpression {
708    /// Expression ID
709    pub id: String,
710    /// Expression description
711    pub description: String,
712    /// Expression type
713    pub expression_type: ExpressionType,
714    /// Evaluation history
715    pub evaluation_history: VecDeque<ExpressionResult>,
716}
717/// Types of optimization suggestions
718#[derive(Debug, Clone)]
719pub enum SuggestionType {
720    /// Algorithm optimization
721    Algorithm,
722    /// Memory optimization
723    Memory,
724    /// Circuit optimization
725    Circuit,
726    /// Hardware optimization
727    Hardware,
728    /// Parallelization
729    Parallelization,
730}
731/// Expression evaluation result value
732#[derive(Debug, Clone)]
733pub enum ExpressionValue {
734    /// Numeric value
735    Number(f64),
736    /// Boolean value
737    Boolean(bool),
738    /// String value
739    String(String),
740    /// Complex number
741    Complex(Complex64),
742    /// Vector value
743    Vector(Vec<f64>),
744}
745/// Metric snapshot for performance tracking
746#[derive(Debug, Clone)]
747pub struct MetricSnapshot {
748    /// Snapshot timestamp
749    pub timestamp: SystemTime,
750    /// Metric value
751    pub value: f64,
752    /// Associated gate index
753    pub gate_index: usize,
754    /// Additional context
755    pub context: HashMap<String, String>,
756}
757/// Memory snapshot
758#[derive(Debug, Clone)]
759pub struct MemorySnapshot {
760    /// Snapshot timestamp
761    pub timestamp: SystemTime,
762    /// Memory usage at this point
763    pub usage: usize,
764    /// Associated operation
765    pub operation: String,
766}
767/// Visualization metadata
768#[derive(Debug, Clone)]
769pub struct VisualizationMetadata {
770    /// Creation timestamp
771    pub created: SystemTime,
772    /// Last modified
773    pub modified: SystemTime,
774    /// Visualization size
775    pub size: (u32, u32),
776    /// Rendering time
777    pub render_time: Duration,
778    /// Additional metadata
779    pub metadata: HashMap<String, String>,
780}
781/// Gate execution result
782#[derive(Debug, Clone)]
783pub struct GateExecutionResult {
784    /// Whether execution was successful
785    pub success: bool,
786    /// Execution time
787    pub execution_time: Duration,
788    /// Memory usage change
789    pub memory_change: i64,
790    /// Any errors that occurred
791    pub errors: Vec<DebugError>,
792}
793/// Types of correlations
794#[derive(Debug, Clone)]
795pub enum CorrelationType {
796    /// Positive correlation
797    Positive,
798    /// Negative correlation
799    Negative,
800    /// No correlation
801    None,
802    /// Causal relationship
803    Causal,
804}
805/// History statistics
806#[derive(Debug, Clone)]
807pub struct HistoryStatistics {
808    /// Total gates executed
809    pub total_gates: usize,
810    /// Average execution time per gate
811    pub average_execution_time: Duration,
812    /// Total execution time
813    pub total_execution_time: Duration,
814    /// Memory usage statistics
815    pub memory_stats: MemoryStatistics,
816    /// Error statistics
817    pub error_stats: ErrorStatistics,
818}
819/// Types of watch expressions
820#[derive(Debug, Clone)]
821pub enum ExpressionType {
822    /// State-based expression
823    StateExpression { formula: String },
824    /// Gate-based expression
825    GateExpression { formula: String },
826    /// Performance-based expression
827    PerformanceExpression { formula: String },
828    /// Custom expression
829    Custom { evaluator: String },
830}
831/// Error detection configuration
832#[derive(Debug, Clone)]
833pub struct ErrorDetectionConfig {
834    /// Enable automatic error detection
835    pub enable_auto_detection: bool,
836    /// Error detection sensitivity
837    pub sensitivity: f64,
838    /// Types of errors to detect
839    pub error_types: HashSet<ErrorType>,
840    /// Error reporting threshold
841    pub reporting_threshold: f64,
842    /// Maximum errors to track
843    pub max_errors: usize,
844}
845/// Comprehensive quantum circuit debugger with `SciRS2` integration
846pub struct QuantumDebugger<const N: usize> {
847    /// Circuit being debugged
848    circuit: Circuit<N>,
849    /// Current execution state
850    execution_state: Arc<RwLock<ExecutionState<N>>>,
851    /// Debugger configuration
852    config: DebuggerConfig,
853    /// `SciRS2` analyzer for advanced analysis
854    analyzer: SciRS2CircuitAnalyzer,
855    /// Breakpoints manager
856    pub breakpoints: Arc<RwLock<BreakpointManager>>,
857    /// Watch variables manager
858    watch_manager: Arc<RwLock<WatchManager<N>>>,
859    /// Execution history
860    execution_history: Arc<RwLock<ExecutionHistory<N>>>,
861    /// Performance profiler
862    profiler: Arc<RwLock<PerformanceProfiler>>,
863    /// Visualization engine
864    pub visualizer: Arc<RwLock<VisualizationEngine<N>>>,
865    /// Error detector
866    pub error_detector: Arc<RwLock<ErrorDetector<N>>>,
867}
868impl<const N: usize> QuantumDebugger<N> {
869    /// Create a new quantum debugger
870    #[must_use]
871    pub fn new(circuit: Circuit<N>) -> Self {
872        let config = DebuggerConfig::default();
873        let analyzer = SciRS2CircuitAnalyzer::with_config(AnalyzerConfig::default());
874        Self {
875            circuit,
876            execution_state: Arc::new(RwLock::new(ExecutionState {
877                current_gate_index: 0,
878                current_state: Array1::<Complex64>::zeros(1 << N),
879                status: ExecutionStatus::Ready,
880                gates_executed: 0,
881                current_depth: 0,
882                memory_usage: MemoryUsage {
883                    current_usage: 0,
884                    peak_usage: 0,
885                    usage_history: VecDeque::new(),
886                    allocation_breakdown: HashMap::new(),
887                },
888                timing_info: TimingInfo {
889                    start_time: SystemTime::now(),
890                    current_time: SystemTime::now(),
891                    total_duration: Duration::new(0, 0),
892                    gate_times: Vec::new(),
893                    timing_stats: TimingStatistics {
894                        average_gate_time: Duration::new(0, 0),
895                        fastest_gate: Duration::new(0, 0),
896                        slowest_gate: Duration::new(0, 0),
897                        execution_variance: 0.0,
898                    },
899                },
900            })),
901            config: config.clone(),
902            analyzer,
903            breakpoints: Arc::new(RwLock::new(BreakpointManager {
904                gate_breakpoints: HashSet::new(),
905                qubit_breakpoints: HashMap::new(),
906                state_breakpoints: Vec::new(),
907                conditional_breakpoints: Vec::new(),
908                hit_counts: HashMap::new(),
909            })),
910            watch_manager: Arc::new(RwLock::new(WatchManager {
911                watched_states: HashMap::new(),
912                watched_gates: HashMap::new(),
913                watched_metrics: HashMap::new(),
914                watch_expressions: Vec::new(),
915            })),
916            execution_history: Arc::new(RwLock::new(ExecutionHistory {
917                entries: VecDeque::new(),
918                max_entries: config.max_history_entries,
919                statistics: HistoryStatistics {
920                    total_gates: 0,
921                    average_execution_time: Duration::new(0, 0),
922                    total_execution_time: Duration::new(0, 0),
923                    memory_stats: MemoryStatistics {
924                        average_usage: 0.0,
925                        peak_usage: 0,
926                        efficiency_score: 1.0,
927                        leak_indicators: Vec::new(),
928                    },
929                    error_stats: ErrorStatistics {
930                        total_errors: 0,
931                        errors_by_type: HashMap::new(),
932                        errors_by_severity: HashMap::new(),
933                        error_rate: 0.0,
934                        error_trends: HashMap::new(),
935                    },
936                },
937            })),
938            profiler: Arc::new(RwLock::new(PerformanceProfiler {
939                config: ProfilerConfig {
940                    sample_frequency: Duration::from_millis(10),
941                    max_samples: 10000,
942                    tracked_metrics: HashSet::new(),
943                    analysis_depth: AnalysisDepth::Standard,
944                },
945                samples: VecDeque::new(),
946                analysis_results: PerformanceAnalysis {
947                    trends: HashMap::new(),
948                    bottlenecks: Vec::new(),
949                    suggestions: Vec::new(),
950                    predictions: HashMap::new(),
951                },
952                statistics: ProfilingStatistics {
953                    total_samples: 0,
954                    profiling_duration: Duration::new(0, 0),
955                    average_sample_rate: 0.0,
956                    performance_metrics: HashMap::new(),
957                },
958            })),
959            visualizer: Arc::new(RwLock::new(VisualizationEngine {
960                config: VisualizationConfig {
961                    enable_realtime: true,
962                    enabled_types: {
963                        let mut types = HashSet::new();
964                        types.insert(VisualizationType::CircuitDiagram);
965                        types.insert(VisualizationType::StateVector);
966                        types.insert(VisualizationType::BlochSphere);
967                        types
968                    },
969                    update_frequency: Duration::from_millis(100),
970                    rendering_quality: RenderingQuality::Medium,
971                    export_options: ExportOptions {
972                        formats: {
973                            let mut formats = HashSet::new();
974                            formats.insert(ExportFormat::PNG);
975                            formats.insert(ExportFormat::JSON);
976                            formats
977                        },
978                        default_quality: RenderingQuality::High,
979                        export_directory: None,
980                        auto_export: false,
981                    },
982                },
983                current_visualizations: HashMap::new(),
984                visualization_history: VecDeque::new(),
985                rendering_stats: RenderingStatistics {
986                    total_renders: 0,
987                    average_render_time: Duration::new(0, 0),
988                    total_render_time: Duration::new(0, 0),
989                    success_rate: 1.0,
990                    memory_usage: 0,
991                },
992            })),
993            error_detector: Arc::new(RwLock::new(ErrorDetector {
994                config: ErrorDetectionConfig {
995                    enable_auto_detection: true,
996                    sensitivity: 0.8,
997                    error_types: {
998                        let mut types = HashSet::new();
999                        types.insert(ErrorType::StateVectorError);
1000                        types.insert(ErrorType::GateExecutionError);
1001                        types.insert(ErrorType::NumericalError);
1002                        types
1003                    },
1004                    reporting_threshold: 0.1,
1005                    max_errors: 1000,
1006                },
1007                detected_errors: Vec::new(),
1008                error_statistics: ErrorStatistics {
1009                    total_errors: 0,
1010                    errors_by_type: HashMap::new(),
1011                    errors_by_severity: HashMap::new(),
1012                    error_rate: 0.0,
1013                    error_trends: HashMap::new(),
1014                },
1015                analysis_results: ErrorAnalysisResults {
1016                    error_patterns: Vec::new(),
1017                    root_causes: Vec::new(),
1018                    correlations: Vec::new(),
1019                    predictions: HashMap::new(),
1020                },
1021            })),
1022        }
1023    }
1024    /// Create debugger with custom configuration
1025    #[must_use]
1026    pub fn with_config(circuit: Circuit<N>, config: DebuggerConfig) -> Self {
1027        let mut debugger = Self::new(circuit);
1028        debugger.config = config;
1029        debugger
1030    }
1031    /// Start debugging session
1032    pub fn start_session(&mut self) -> QuantRS2Result<()> {
1033        {
1034            let mut state = self.execution_state.write().map_err(|_| {
1035                QuantRS2Error::InvalidOperation(
1036                    "Failed to acquire execution state write lock".to_string(),
1037                )
1038            })?;
1039            state.status = ExecutionStatus::Running;
1040            state.timing_info.start_time = SystemTime::now();
1041        }
1042        self.initialize_scirs2_analysis()?;
1043        if self.config.enable_profiling {
1044            self.start_profiling()?;
1045        }
1046        if self.config.enable_auto_visualization {
1047            self.initialize_visualization()?;
1048        }
1049        Ok(())
1050    }
1051    /// Execute next gate with debugging
1052    pub fn step_next(&mut self) -> QuantRS2Result<StepResult> {
1053        let start_time = Instant::now();
1054        if self.should_break()? {
1055            let mut state = self.execution_state.write().map_err(|_| {
1056                QuantRS2Error::InvalidOperation(
1057                    "Failed to acquire execution state write lock".to_string(),
1058                )
1059            })?;
1060            state.status = ExecutionStatus::Paused;
1061            return Ok(StepResult::Breakpoint);
1062        }
1063        let gate_index = {
1064            let state = self.execution_state.read().map_err(|_| {
1065                QuantRS2Error::InvalidOperation(
1066                    "Failed to acquire execution state read lock".to_string(),
1067                )
1068            })?;
1069            state.current_gate_index
1070        };
1071        if gate_index >= self.circuit.gates().len() {
1072            let mut state = self.execution_state.write().map_err(|_| {
1073                QuantRS2Error::InvalidOperation(
1074                    "Failed to acquire execution state write lock".to_string(),
1075                )
1076            })?;
1077            state.status = ExecutionStatus::Completed;
1078            return Ok(StepResult::Completed);
1079        }
1080        self.pre_execution_analysis(gate_index)?;
1081        let execution_result = self.execute_gate_with_monitoring(gate_index)?;
1082        self.post_execution_analysis(gate_index, &execution_result)?;
1083        {
1084            let mut state = self.execution_state.write().map_err(|_| {
1085                QuantRS2Error::InvalidOperation(
1086                    "Failed to acquire execution state write lock".to_string(),
1087                )
1088            })?;
1089            state.current_gate_index += 1;
1090            state.gates_executed += 1;
1091            state.current_depth = self.calculate_current_depth()?;
1092            state.timing_info.gate_times.push(start_time.elapsed());
1093        }
1094        if self.config.enable_auto_visualization {
1095            self.update_visualizations()?;
1096        }
1097        Ok(StepResult::Success)
1098    }
1099    /// Run circuit until completion or breakpoint
1100    pub fn run(&mut self) -> QuantRS2Result<ExecutionSummary> {
1101        self.start_session()?;
1102        let mut step_count = 0;
1103        loop {
1104            match self.step_next()? {
1105                StepResult::Success => {
1106                    step_count += 1;
1107                }
1108                StepResult::Breakpoint => {
1109                    return Ok(ExecutionSummary {
1110                        status: ExecutionStatus::Paused,
1111                        steps_executed: step_count,
1112                        final_state: self.get_current_state()?,
1113                        execution_time: self.get_execution_time()?,
1114                        memory_usage: self.get_memory_usage()?,
1115                    });
1116                }
1117                StepResult::Completed => {
1118                    break;
1119                }
1120                StepResult::Error(error) => {
1121                    return Err(error);
1122                }
1123            }
1124        }
1125        self.finalize_execution()?;
1126        Ok(ExecutionSummary {
1127            status: ExecutionStatus::Completed,
1128            steps_executed: step_count,
1129            final_state: self.get_current_state()?,
1130            execution_time: self.get_execution_time()?,
1131            memory_usage: self.get_memory_usage()?,
1132        })
1133    }
1134    /// Pause execution
1135    pub fn pause(&mut self) -> QuantRS2Result<()> {
1136        let mut state = self.execution_state.write().map_err(|_| {
1137            QuantRS2Error::InvalidOperation(
1138                "Failed to acquire execution state write lock".to_string(),
1139            )
1140        })?;
1141        state.status = ExecutionStatus::Paused;
1142        Ok(())
1143    }
1144    /// Resume execution
1145    pub fn resume(&mut self) -> QuantRS2Result<()> {
1146        let mut state = self.execution_state.write().map_err(|_| {
1147            QuantRS2Error::InvalidOperation(
1148                "Failed to acquire execution state write lock".to_string(),
1149            )
1150        })?;
1151        state.status = ExecutionStatus::Running;
1152        Ok(())
1153    }
1154    /// Stop execution
1155    pub fn stop(&mut self) -> QuantRS2Result<()> {
1156        let mut state = self.execution_state.write().map_err(|_| {
1157            QuantRS2Error::InvalidOperation(
1158                "Failed to acquire execution state write lock".to_string(),
1159            )
1160        })?;
1161        state.status = ExecutionStatus::Stopped;
1162        Ok(())
1163    }
1164    /// Add breakpoint at gate index
1165    pub fn add_gate_breakpoint(&mut self, gate_index: usize) -> QuantRS2Result<()> {
1166        let mut breakpoints = self.breakpoints.write().map_err(|_| {
1167            QuantRS2Error::InvalidOperation("Failed to acquire breakpoints write lock".to_string())
1168        })?;
1169        breakpoints.gate_breakpoints.insert(gate_index);
1170        Ok(())
1171    }
1172    /// Add qubit breakpoint
1173    pub fn add_qubit_breakpoint(
1174        &mut self,
1175        qubit: QubitId,
1176        condition: BreakpointCondition,
1177    ) -> QuantRS2Result<()> {
1178        let mut breakpoints = self.breakpoints.write().map_err(|_| {
1179            QuantRS2Error::InvalidOperation("Failed to acquire breakpoints write lock".to_string())
1180        })?;
1181        breakpoints.qubit_breakpoints.insert(qubit, condition);
1182        Ok(())
1183    }
1184    /// Add state breakpoint
1185    pub fn add_state_breakpoint(
1186        &mut self,
1187        id: String,
1188        pattern: StatePattern,
1189        tolerance: f64,
1190    ) -> QuantRS2Result<()> {
1191        let mut breakpoints = self.breakpoints.write().map_err(|_| {
1192            QuantRS2Error::InvalidOperation("Failed to acquire breakpoints write lock".to_string())
1193        })?;
1194        breakpoints.state_breakpoints.push(StateBreakpoint {
1195            id,
1196            target_state: pattern,
1197            tolerance,
1198            enabled: true,
1199        });
1200        Ok(())
1201    }
1202    /// Get current quantum state
1203    pub fn get_current_state(&self) -> QuantRS2Result<Array1<Complex64>> {
1204        let state = self.execution_state.read().map_err(|_| {
1205            QuantRS2Error::InvalidOperation(
1206                "Failed to acquire execution state read lock".to_string(),
1207            )
1208        })?;
1209        Ok(state.current_state.clone())
1210    }
1211    /// Get execution status
1212    #[must_use]
1213    pub fn get_execution_status(&self) -> ExecutionStatus {
1214        let state = self
1215            .execution_state
1216            .read()
1217            .expect("execution state lock should not be poisoned");
1218        state.status.clone()
1219    }
1220    /// Get performance analysis
1221    pub fn get_performance_analysis(&self) -> QuantRS2Result<PerformanceAnalysis> {
1222        let profiler = self.profiler.read().map_err(|_| {
1223            QuantRS2Error::InvalidOperation("Failed to acquire profiler read lock".to_string())
1224        })?;
1225        Ok(profiler.analysis_results.clone())
1226    }
1227    /// Get error analysis
1228    pub fn get_error_analysis(&self) -> QuantRS2Result<ErrorAnalysisResults> {
1229        let detector = self.error_detector.read().map_err(|_| {
1230            QuantRS2Error::InvalidOperation(
1231                "Failed to acquire error detector read lock".to_string(),
1232            )
1233        })?;
1234        Ok(detector.analysis_results.clone())
1235    }
1236    /// Export debugging session
1237    pub fn export_session(&self, format: ExportFormat, path: &str) -> QuantRS2Result<()> {
1238        match format {
1239            ExportFormat::JSON => self.export_json(path),
1240            ExportFormat::HTML => self.export_html(path),
1241            ExportFormat::CSV => self.export_csv(path),
1242            _ => Err(QuantRS2Error::InvalidOperation(
1243                "Unsupported export format".to_string(),
1244            )),
1245        }
1246    }
1247    fn initialize_scirs2_analysis(&self) -> QuantRS2Result<()> {
1248        let _graph = self.analyzer.circuit_to_scirs2_graph(&self.circuit)?;
1249        Ok(())
1250    }
1251    const fn start_profiling(&self) -> QuantRS2Result<()> {
1252        Ok(())
1253    }
1254    const fn initialize_visualization(&self) -> QuantRS2Result<()> {
1255        Ok(())
1256    }
1257    fn should_break(&self) -> QuantRS2Result<bool> {
1258        let breakpoints = self.breakpoints.read().map_err(|_| {
1259            QuantRS2Error::InvalidOperation("Failed to acquire breakpoints read lock".to_string())
1260        })?;
1261        let state = self.execution_state.read().map_err(|_| {
1262            QuantRS2Error::InvalidOperation(
1263                "Failed to acquire execution state read lock".to_string(),
1264            )
1265        })?;
1266        if breakpoints
1267            .gate_breakpoints
1268            .contains(&state.current_gate_index)
1269        {
1270            return Ok(true);
1271        }
1272        Ok(false)
1273    }
1274    const fn pre_execution_analysis(&self, _gate_index: usize) -> QuantRS2Result<()> {
1275        Ok(())
1276    }
1277    const fn execute_gate_with_monitoring(
1278        &self,
1279        _gate_index: usize,
1280    ) -> QuantRS2Result<GateExecutionResult> {
1281        Ok(GateExecutionResult {
1282            success: true,
1283            execution_time: Duration::from_millis(1),
1284            memory_change: 0,
1285            errors: Vec::new(),
1286        })
1287    }
1288    const fn post_execution_analysis(
1289        &self,
1290        _gate_index: usize,
1291        _result: &GateExecutionResult,
1292    ) -> QuantRS2Result<()> {
1293        Ok(())
1294    }
1295    const fn calculate_current_depth(&self) -> QuantRS2Result<usize> {
1296        Ok(0)
1297    }
1298    const fn update_visualizations(&self) -> QuantRS2Result<()> {
1299        Ok(())
1300    }
1301    fn finalize_execution(&self) -> QuantRS2Result<()> {
1302        let mut state = self.execution_state.write().map_err(|_| {
1303            QuantRS2Error::InvalidOperation(
1304                "Failed to acquire execution state write lock".to_string(),
1305            )
1306        })?;
1307        state.status = ExecutionStatus::Completed;
1308        state.timing_info.current_time = SystemTime::now();
1309        Ok(())
1310    }
1311    fn get_execution_time(&self) -> QuantRS2Result<Duration> {
1312        let state = self.execution_state.read().map_err(|_| {
1313            QuantRS2Error::InvalidOperation(
1314                "Failed to acquire execution state read lock".to_string(),
1315            )
1316        })?;
1317        Ok(state.timing_info.total_duration)
1318    }
1319    fn get_memory_usage(&self) -> QuantRS2Result<MemoryUsage> {
1320        let state = self.execution_state.read().map_err(|_| {
1321            QuantRS2Error::InvalidOperation(
1322                "Failed to acquire execution state read lock".to_string(),
1323            )
1324        })?;
1325        Ok(state.memory_usage.clone())
1326    }
1327    const fn export_json(&self, _path: &str) -> QuantRS2Result<()> {
1328        Ok(())
1329    }
1330    const fn export_html(&self, _path: &str) -> QuantRS2Result<()> {
1331        Ok(())
1332    }
1333    const fn export_csv(&self, _path: &str) -> QuantRS2Result<()> {
1334        Ok(())
1335    }
1336}
1337/// Connection types
1338#[derive(Debug, Clone)]
1339pub enum ConnectionType {
1340    /// Control connection
1341    Control,
1342    /// Target connection
1343    Target,
1344    /// Classical connection
1345    Classical,
1346    /// Entanglement connection
1347    Entanglement,
1348}
1349/// Result of expression evaluation
1350#[derive(Debug, Clone)]
1351pub struct ExpressionResult {
1352    /// Evaluation timestamp
1353    pub timestamp: SystemTime,
1354    /// Result value
1355    pub value: ExpressionValue,
1356    /// Evaluation success
1357    pub success: bool,
1358    /// Error message if evaluation failed
1359    pub error_message: Option<String>,
1360}
1361/// Visualization configuration
1362#[derive(Debug, Clone)]
1363pub struct VisualizationConfig {
1364    /// Enable real-time visualization
1365    pub enable_realtime: bool,
1366    /// Visualization types to enable
1367    pub enabled_types: HashSet<VisualizationType>,
1368    /// Update frequency
1369    pub update_frequency: Duration,
1370    /// Rendering quality
1371    pub rendering_quality: RenderingQuality,
1372    /// Export options
1373    pub export_options: ExportOptions,
1374}
1375/// Debugger configuration options
1376#[derive(Debug, Clone, Serialize, Deserialize)]
1377pub struct DebuggerConfig {
1378    /// Enable step-by-step execution
1379    pub enable_step_mode: bool,
1380    /// Enable automatic state visualization
1381    pub enable_auto_visualization: bool,
1382    /// Enable performance profiling
1383    pub enable_profiling: bool,
1384    /// Enable memory tracking
1385    pub enable_memory_tracking: bool,
1386    /// Enable error detection
1387    pub enable_error_detection: bool,
1388    /// Maximum history entries to keep
1389    pub max_history_entries: usize,
1390    /// Visualization update frequency
1391    pub visualization_frequency: Duration,
1392    /// Profiling sample rate
1393    pub profiling_sample_rate: f64,
1394    /// Memory usage threshold for warnings
1395    pub memory_warning_threshold: f64,
1396    /// Gate execution timeout
1397    pub gate_timeout: Duration,
1398}
1399/// Error severity levels
1400#[derive(Debug, Clone)]
1401pub enum ErrorSeverity {
1402    /// Low severity
1403    Low,
1404    /// Medium severity
1405    Medium,
1406    /// High severity
1407    High,
1408    /// Critical severity
1409    Critical,
1410}
1411/// Summary of debugging session
1412#[derive(Debug, Clone)]
1413pub struct ExecutionSummary {
1414    /// Final execution status
1415    pub status: ExecutionStatus,
1416    /// Number of steps executed
1417    pub steps_executed: usize,
1418    /// Final quantum state
1419    pub final_state: Array1<Complex64>,
1420    /// Total execution time
1421    pub execution_time: Duration,
1422    /// Final memory usage
1423    pub memory_usage: MemoryUsage,
1424}
1425/// Performance bottleneck identification
1426#[derive(Debug, Clone)]
1427pub struct PerformanceBottleneck {
1428    /// Bottleneck type
1429    pub bottleneck_type: BottleneckType,
1430    /// Severity score
1431    pub severity: f64,
1432    /// Description
1433    pub description: String,
1434    /// Recommended actions
1435    pub recommendations: Vec<String>,
1436    /// Impact assessment
1437    pub impact: ImpactAssessment,
1438}
1439/// Visualization data types
1440#[derive(Debug, Clone)]
1441pub enum VisualizationData<const N: usize> {
1442    /// Circuit diagram data
1443    CircuitData {
1444        gates: Vec<GateVisualization>,
1445        connections: Vec<ConnectionVisualization>,
1446        current_position: Option<usize>,
1447    },
1448    /// Bloch sphere data
1449    BlochData {
1450        qubit_states: HashMap<QubitId, BlochVector>,
1451        evolution_path: Vec<BlochVector>,
1452    },
1453    /// State vector data
1454    StateData {
1455        amplitudes: Array1<Complex64>,
1456        probabilities: Array1<f64>,
1457        phases: Array1<f64>,
1458    },
1459    /// Performance data
1460    PerformanceData {
1461        metrics: HashMap<String, Vec<f64>>,
1462        timestamps: Vec<SystemTime>,
1463    },
1464}
1465/// Performance profiler
1466#[derive(Debug, Clone)]
1467pub struct PerformanceProfiler {
1468    /// Profiling configuration
1469    pub config: ProfilerConfig,
1470    /// Performance samples
1471    pub samples: VecDeque<PerformanceSample>,
1472    /// Performance analysis results
1473    pub analysis_results: PerformanceAnalysis,
1474    /// Profiling statistics
1475    pub statistics: ProfilingStatistics,
1476}
1477/// Visualization engine
1478#[derive(Debug, Clone)]
1479pub struct VisualizationEngine<const N: usize> {
1480    /// Visualization configuration
1481    pub config: VisualizationConfig,
1482    /// Current visualizations
1483    pub current_visualizations: HashMap<String, Visualization<N>>,
1484    /// Visualization history
1485    pub visualization_history: VecDeque<VisualizationSnapshot<N>>,
1486    /// Rendering statistics
1487    pub rendering_stats: RenderingStatistics,
1488}
1489/// Profiler configuration
1490#[derive(Debug, Clone)]
1491pub struct ProfilerConfig {
1492    /// Sampling frequency
1493    pub sample_frequency: Duration,
1494    /// Maximum samples to keep
1495    pub max_samples: usize,
1496    /// Performance metrics to track
1497    pub tracked_metrics: HashSet<String>,
1498    /// Analysis depth
1499    pub analysis_depth: AnalysisDepth,
1500}
1501/// Performance analysis results
1502#[derive(Debug, Clone)]
1503pub struct PerformanceAnalysis {
1504    /// Performance trends
1505    pub trends: HashMap<String, TrendAnalysis>,
1506    /// Bottleneck identification
1507    pub bottlenecks: Vec<PerformanceBottleneck>,
1508    /// Optimization suggestions
1509    pub suggestions: Vec<OptimizationSuggestion>,
1510    /// Predictive analysis
1511    pub predictions: HashMap<String, PredictionResult>,
1512}
1513/// Bloch vector representation
1514#[derive(Debug, Clone)]
1515pub struct BlochVector {
1516    /// X component
1517    pub x: f64,
1518    /// Y component
1519    pub y: f64,
1520    /// Z component
1521    pub z: f64,
1522    /// Timestamp
1523    pub timestamp: SystemTime,
1524}
1525/// Optimization suggestion
1526#[derive(Debug, Clone)]
1527pub struct OptimizationSuggestion {
1528    /// Suggestion type
1529    pub suggestion_type: SuggestionType,
1530    /// Priority level
1531    pub priority: Priority,
1532    /// Expected improvement
1533    pub expected_improvement: f64,
1534    /// Implementation difficulty
1535    pub difficulty: Difficulty,
1536    /// Description
1537    pub description: String,
1538    /// Implementation steps
1539    pub implementation_steps: Vec<String>,
1540}
1541/// Watch configuration
1542#[derive(Debug, Clone)]
1543pub struct WatchConfig {
1544    /// Update frequency
1545    pub update_frequency: Duration,
1546    /// Maximum history entries
1547    pub max_history: usize,
1548    /// Alert thresholds
1549    pub alert_thresholds: HashMap<String, f64>,
1550    /// Auto-save snapshots
1551    pub auto_save: bool,
1552}
1553/// Breakpoint conditions for qubits
1554#[derive(Debug, Clone)]
1555pub enum BreakpointCondition {
1556    /// Break when qubit is measured
1557    OnMeasurement,
1558    /// Break when qubit entanglement exceeds threshold
1559    OnEntanglement { threshold: f64 },
1560    /// Break when qubit fidelity drops below threshold
1561    OnFidelityDrop { threshold: f64 },
1562    /// Break on any gate operation
1563    OnAnyGate,
1564    /// Break on specific gate types
1565    OnGateType { gate_types: Vec<String> },
1566}
1567/// Implementation difficulty
1568#[derive(Debug, Clone)]
1569pub enum Difficulty {
1570    /// Easy to implement
1571    Easy,
1572    /// Medium difficulty
1573    Medium,
1574    /// Hard to implement
1575    Hard,
1576    /// Very hard to implement
1577    VeryHard,
1578}
quantrs2_circuit/debugger/types.rs

quantrs2_circuit/debugger/
types.rs
