quantrs2_sim/
lib.rs

1// Architectural decisions - these are intentional design patterns
2#![allow(clippy::unnecessary_wraps)] // Result return types for API consistency
3#![allow(clippy::unused_self)] // Trait implementations require &self
4#![allow(clippy::unused_async)]
5// Async placeholders for future implementation
6// Performance-related (not safety issues, can be optimized later)
7#![allow(clippy::significant_drop_tightening)] // Lock scope optimization TODO
8// Style-related (low priority)
9#![allow(clippy::match_same_arms)] // Sometimes intentional for clarity
10#![allow(clippy::option_if_let_else)] // Style preference
11#![allow(clippy::return_self_not_must_use)] // Builder pattern
12#![allow(clippy::needless_range_loop)] // Sometimes clearer with index
13// Additional suppressions for remaining warnings
14#![allow(clippy::branches_sharing_code)] // Sometimes intentional
15#![allow(clippy::type_complexity)] // Quantum types are complex
16#![allow(clippy::missing_const_for_fn)] // Not always beneficial
17#![allow(clippy::format_push_string)] // Performance optimization TODO
18#![allow(clippy::cast_possible_truncation)] // Platform-specific, validated
19#![allow(clippy::future_not_send)] // Async architecture decision
20#![allow(clippy::needless_pass_by_ref_mut)] // API consistency
21#![allow(clippy::cast_precision_loss)] // Acceptable for quantum simulation
22#![allow(clippy::uninlined_format_args)] // Style preference
23#![allow(clippy::assigning_clones)] // Sometimes clearer
24#![allow(clippy::zero_sized_map_values)] // Intentional for set-like maps
25#![allow(clippy::used_underscore_binding)] // Sometimes needed for unused captures
26#![allow(clippy::collection_is_never_read)] // Builder pattern / lazy evaluation
27#![allow(clippy::wildcard_in_or_patterns)] // Sometimes intentional
28#![allow(clippy::ptr_arg)] // API consistency with slices
29#![allow(clippy::implicit_hasher)] // Generic hasher not always needed
30#![allow(clippy::ref_option)] // Sometimes needed for lifetime reasons
31#![allow(clippy::expect_fun_call)] // Clearer error messages
32#![allow(clippy::if_not_else)] // Sometimes clearer
33#![allow(clippy::iter_on_single_items)] // Sometimes intentional
34#![allow(clippy::trivially_copy_pass_by_ref)] // API consistency
35#![allow(clippy::empty_line_after_doc_comments)] // Formatting preference
36#![allow(clippy::manual_let_else)] // Style preference
37#![allow(clippy::await_holding_lock)] // Async architecture
38// Full clippy category suppressions
39#![allow(clippy::pedantic)]
40#![allow(clippy::nursery)]
41#![allow(clippy::cargo)]
42// Additional specific suppressions
43#![allow(clippy::large_enum_variant)]
44#![allow(clippy::borrowed_box)]
45#![allow(clippy::manual_map)]
46#![allow(clippy::non_send_fields_in_send_ty)]
47#![allow(clippy::if_same_then_else)]
48#![allow(clippy::manual_clamp)]
49#![allow(clippy::double_must_use)]
50#![allow(clippy::only_used_in_recursion)]
51#![allow(clippy::same_item_push)]
52#![allow(clippy::format_in_format_args)]
53#![allow(clippy::implied_bounds_in_impls)]
54#![allow(clippy::explicit_counter_loop)]
55#![allow(clippy::duplicated_attributes)]
56#![allow(clippy::new_ret_no_self)]
57#![allow(clippy::must_use_unit)]
58#![allow(clippy::redundant_pattern_matching)]
59#![allow(clippy::redundant_guards)]
60#![allow(clippy::wrong_self_convention)]
61#![allow(clippy::iter_next_slice)]
62#![allow(clippy::create_dir)]
63#![allow(clippy::enum_variant_names)]
64// Additional specific suppressions (correct lint names)
65#![allow(clippy::should_implement_trait)] // Methods like default(), from_str(), next()
66#![allow(clippy::upper_case_acronyms)] // VQE, QAOA, QFT, CNOT, SGD
67#![allow(clippy::unnecessary_map_or)] // map_or simplification suggestions
68#![allow(clippy::derivable_impls)] // Impl can be derived
69#![allow(clippy::or_fun_call)] // unwrap_or_else with default value
70#![allow(clippy::cloned_ref_to_slice_refs)] // clone can be replaced with from_ref
71#![allow(clippy::collapsible_match)]
72#![allow(clippy::len_without_is_empty)]
73#![allow(clippy::arc_with_non_send_sync)]
74#![allow(clippy::std_instead_of_core)] // Allow std usage
75#![allow(clippy::match_like_matches_macro)] // Sometimes match is clearer
76#![allow(clippy::suspicious_open_options)] // File open options
77#![allow(clippy::new_without_default)] // new() without Default impl
78#![allow(clippy::legacy_numeric_constants)] // Allow std::f64::MAX etc.
79
80//! # quantrs2-sim
81//!
82//! Quantum circuit simulators for the QuantRS2 framework.
83//!
84//! This crate is part of the [QuantRS2](https://github.com/cool-japan/quantrs) quantum computing
85//! framework. It provides multiple simulation backends for quantum circuits, including state-vector,
86//! MPS (Matrix Product State), stabilizer, and GPU-accelerated simulation.
87//!
88//! ## Simulation Backends
89//!
90//! - **State Vector**: Exact simulation up to ~30 qubits using dense vectors
91//! - **MPS Simulator**: Tensor-network simulation for structured circuits
92//! - **Stabilizer**: Efficient Clifford circuit simulation via Gottesman-Knill
93//! - **GPU-Accelerated**: CUDA/Metal-backed simulation for large circuits
94//! - **Distributed**: Multi-node quantum simulation via MPI
95//!
96//! ## Quick Start
97//!
98//! ```rust
99//! use quantrs2_sim::statevector::StateVectorSimulator;
100//! use quantrs2_circuit::builder::{Circuit, Simulator};
101//!
102//! // Build a 2-qubit Bell state circuit
103//! let mut circ: Circuit<2> = Circuit::new();
104//! circ.h(0).expect("h").cnot(0, 1).expect("cnot");
105//!
106//! // Simulate and inspect the resulting register
107//! let sim = StateVectorSimulator::new();
108//! let reg = sim.run(&circ).expect("simulation failed");
109//! assert_eq!(reg.num_qubits(), 2);
110//! ```
111
112pub mod adaptive_gate_fusion;
113pub mod adaptive_ml_error_correction;
114pub mod adiabatic_quantum_computing;
115pub mod advanced_ml_error_mitigation;
116pub mod advanced_variational_algorithms;
117pub mod autodiff_vqe;
118pub mod automatic_parallelization;
119pub mod cache_optimized_layouts;
120pub mod circuit_interfaces;
121pub mod concatenated_error_correction;
122// CUDA-specific modules (not available on macOS)
123#[cfg(all(feature = "gpu", not(target_os = "macos")))]
124pub mod cuda;
125#[cfg(all(feature = "gpu", not(target_os = "macos")))]
126pub mod cuda_kernels;
127pub mod cuquantum;
128pub mod debugger;
129pub mod decision_diagram;
130pub mod device_noise_models;
131// Distributed GPU simulation (CUDA-based, not available on macOS)
132#[cfg(all(feature = "gpu", not(target_os = "macos")))]
133pub mod distributed_gpu;
134pub mod distributed_simulator;
135pub mod dynamic;
136pub mod enhanced_statevector;
137pub mod enhanced_tensor_networks;
138pub mod error;
139pub mod error_mitigation;
140pub mod fault_tolerant_synthesis;
141pub mod fermionic_simulation;
142pub mod fpga_acceleration;
143pub mod fusion;
144pub mod gpu_kernel_optimization;
145pub mod gpu_observables;
146pub mod hardware_aware_qml;
147pub mod holographic_quantum_error_correction;
148pub mod jit_compilation;
149pub mod large_scale_simulator;
150pub mod linalg_ops;
151pub mod memory_bandwidth_optimization;
152pub mod memory_optimization;
153pub mod memory_prefetching_optimization;
154pub mod mixed_precision;
155pub mod mixed_precision_impl;
156pub mod mpi_distributed_simulation;
157pub mod mps_basic;
158#[cfg(feature = "mps")]
159pub mod mps_enhanced;
160pub mod mps_simulator;
161pub mod noise_extrapolation;
162pub mod open_quantum_systems;
163pub mod opencl_amd_backend;
164pub mod operation_cache;
165#[cfg(feature = "optimize")]
166pub mod optirs_integration;
167pub mod parallel_tensor_optimization;
168pub mod path_integral;
169pub mod pauli;
170pub mod photonic;
171pub mod precision;
172pub mod qaoa_optimization;
173pub mod qmc;
174pub mod qml;
175pub mod qml_integration;
176pub mod quantum_advantage_demonstration;
177pub mod quantum_algorithms;
178pub mod quantum_annealing;
179pub mod quantum_cellular_automata;
180pub mod quantum_chemistry;
181pub mod quantum_chemistry_dmrg;
182pub mod quantum_cloud_integration;
183pub mod quantum_field_theory;
184pub mod quantum_gravity_simulation;
185pub mod quantum_info;
186pub mod quantum_inspired_classical;
187pub mod quantum_ldpc_codes;
188pub mod quantum_machine_learning_layers;
189pub mod quantum_ml_algorithms;
190pub mod quantum_reservoir_computing;
191pub mod quantum_reservoir_computing_enhanced;
192pub mod quantum_supremacy;
193pub mod quantum_volume;
194pub mod realtime_hardware_integration;
195pub mod scirs2_complex_simd;
196pub mod scirs2_eigensolvers;
197pub mod scirs2_integration;
198pub mod scirs2_qft;
199pub mod scirs2_sparse;
200pub mod shot_sampling;
201pub mod simulator;
202pub mod sparse;
203pub mod specialized_gates;
204pub mod specialized_simulator;
205pub mod stabilizer;
206pub mod state_vector_simd;
207pub mod statevector;
208pub mod stim_dem;
209pub mod stim_executor;
210pub mod stim_parser;
211pub mod stim_sampler;
212pub mod telemetry;
213pub mod tensor;
214pub mod topological_quantum_simulation;
215pub mod tpu_acceleration;
216pub mod trotter;
217pub mod visualization_hooks;
218
219pub mod tensor_network;
220pub mod utils;
221// Optimization modules refactored into specialized implementations:
222// optimized_chunked, optimized_simd, optimized_simple, optimized_simulator, etc.
223pub mod auto_optimizer;
224pub mod benchmark;
225pub mod circuit_optimization;
226pub mod circuit_optimizer;
227pub mod clifford_sparse;
228pub mod performance_prediction;
229
230/// PennyLane device backend (JSON protocol)
231pub mod pennylane;
232
233/// New organized API for QuantRS2 Simulation 1.0
234///
235/// This module provides a hierarchical organization of the simulation API
236/// with clear naming conventions and logical grouping.
237pub mod api;
238pub mod compilation_optimization;
239pub mod diagnostics;
240pub mod memory_verification_simple;
241pub mod optimized_chunked;
242pub mod optimized_simd;
243pub mod optimized_simple;
244pub mod optimized_simulator;
245pub mod optimized_simulator_chunked;
246pub mod optimized_simulator_simple;
247pub mod performance_benchmark;
248pub mod qulacs_backend;
249#[cfg(test)]
250pub mod tests;
251#[cfg(test)]
252pub mod tests_optimized;
253#[cfg(test)]
254pub mod tests_quantum_inspired_classical;
255#[cfg(test)]
256pub mod tests_quantum_ml_layers;
257#[cfg(test)]
258pub mod tests_simple;
259#[cfg(test)]
260pub mod tests_tensor_network;
261#[cfg(test)]
262pub mod tests_ultrathink_implementations;
263
264/// Noise models for quantum simulation
265pub mod noise;
266
267/// Advanced noise models for realistic device simulation
268pub mod noise_advanced;
269
270/// Comprehensive noise models with Kraus operators
271pub mod noise_models;
272
273/// Quantum error correction codes and utilities
274pub mod error_correction;
275
276/// Prelude module that re-exports common types and traits
277pub mod prelude {
278    pub use crate::adaptive_ml_error_correction::{
279        benchmark_adaptive_ml_error_correction, AdaptiveCorrectionResult, AdaptiveMLConfig,
280        AdaptiveMLErrorCorrection, CorrectionMetrics, ErrorCorrectionAgent,
281        FeatureExtractionMethod, FeatureExtractor, LearningStrategy, MLModelType,
282        SyndromeClassificationNetwork, TrainingExample as MLTrainingExample,
283    };
284    pub use crate::adiabatic_quantum_computing::{
285        AdiabaticBenchmarkResults, AdiabaticConfig, AdiabaticQuantumComputer, AdiabaticResult,
286        AdiabaticSnapshot, AdiabaticStats, AdiabaticUtils, GapMeasurement, GapTrackingConfig,
287        ScheduleType,
288    };
289    pub use crate::advanced_variational_algorithms::{
290        benchmark_advanced_vqa, AcquisitionFunction, AdvancedOptimizerType, AdvancedVQATrainer,
291        BayesianModel, CompressionMethod, CostFunction, FiniteDifferenceGradient,
292        GradientCalculator, GrowthCriterion, HamiltonianTerm as VQAHamiltonianTerm,
293        IsingCostFunction, MixerHamiltonian, MixerType, NetworkConnectivity,
294        OptimizationProblemType, OptimizerState as VQAOptimizerState, ParameterShiftGradient,
295        ProblemHamiltonian, QuantumActivation, TensorTopology, VQAConfig, VQAResult,
296        VQATrainerState, VQATrainingStats, VariationalAnsatz, WarmRestartConfig,
297    };
298    pub use crate::auto_optimizer::{
299        execute_with_auto_optimization, recommend_backend_for_circuit, AnalysisDepth,
300        AutoOptimizer, AutoOptimizerConfig, BackendRecommendation, BackendType,
301        CircuitCharacteristics, ConnectivityProperties, FallbackStrategy,
302        OptimizationLevel as AutoOptimizationLevel, PerformanceHistory,
303        PerformanceMetrics as AutoOptimizerPerformanceMetrics,
304    };
305    pub use crate::autodiff_vqe::{
306        ansatze, AutoDiffContext, ConvergenceCriteria, GradientMethod, ParametricCircuit,
307        ParametricGate, ParametricRX, ParametricRY, ParametricRZ, VQEIteration, VQEResult,
308        VQEWithAutodiff,
309    };
310    pub use crate::automatic_parallelization::{
311        benchmark_automatic_parallelization, AutoParallelBenchmarkResults, AutoParallelConfig,
312        AutoParallelEngine, CircuitParallelResult, DependencyGraph, GateNode,
313        LoadBalancingConfig as AutoLoadBalancingConfig, OptimizationLevel,
314        OptimizationRecommendation as ParallelOptimizationRecommendation, ParallelPerformanceStats,
315        ParallelTask, ParallelizationAnalysis, ParallelizationStrategy, RecommendationComplexity,
316        RecommendationType, ResourceConstraints, ResourceSnapshot, ResourceUtilization,
317        TaskCompletionStats, TaskPriority, WorkStealingStrategy,
318    };
319    pub use crate::cache_optimized_layouts::{
320        CacheHierarchyConfig, CacheLayoutAdaptationResult, CacheOperationStats,
321        CacheOptimizedGateManager, CacheOptimizedLayout, CacheOptimizedStateVector,
322        CachePerformanceStats, CacheReplacementPolicy,
323    };
324    pub use crate::circuit_interfaces::{
325        BackendCompiledData, CircuitExecutionResult, CircuitInterface, CircuitInterfaceConfig,
326        CircuitInterfaceStats, CircuitInterfaceUtils, CircuitMetadata, CircuitOptimizationResult,
327        CompilationMetadata, CompiledCircuit, InterfaceBenchmarkResults, InterfaceCircuit,
328        InterfaceGate, InterfaceGateType, OptimizationStats, SimulationBackend, StabilizerOp,
329    };
330    pub use crate::circuit_optimization::{
331        optimize_circuit, optimize_circuit_with_config, CircuitOptimizer, OptimizationConfig,
332        OptimizationResult, OptimizationStatistics,
333    };
334    pub use crate::circuit_optimizer::{
335        Circuit as OptimizerCircuit, CircuitOptimizer as PassBasedOptimizer, Gate as OptimizerGate,
336        GateType as OptimizerGateType, OptimizationPass,
337        OptimizationStats as PassOptimizationStats,
338    };
339    pub use crate::clifford_sparse::{CliffordGate, SparseCliffordSimulator};
340    pub use crate::compilation_optimization::{
341        CompilationAnalysis, CompilationOptimizer, CompilationOptimizerConfig,
342        OptimizationRecommendation, OptimizationType, RecommendationPriority,
343    };
344    pub use crate::concatenated_error_correction::{
345        benchmark_concatenated_error_correction, create_standard_concatenated_code, CodeParameters,
346        ConcatenatedCodeConfig, ConcatenatedCorrectionResult, ConcatenatedErrorCorrection,
347        ConcatenationLevel, ConcatenationStats, DecodingResult, ErrorCorrectionCode, ErrorType,
348        HierarchicalDecodingMethod, LevelDecodingResult,
349    };
350    #[cfg(all(feature = "advanced_math", not(target_os = "macos")))]
351    pub use crate::cuda_kernels::{CudaContext, CudaDeviceProperties, CudaKernel};
352    #[cfg(all(feature = "gpu", not(target_os = "macos")))]
353    pub use crate::cuda_kernels::{
354        CudaKernelConfig, CudaKernelStats, CudaQuantumKernels, GateType as CudaGateType,
355        OptimizationLevel as CudaOptimizationLevel,
356    };
357    pub use crate::debugger::{
358        BreakCondition, DebugConfig, DebugReport, PerformanceMetrics, QuantumDebugger, StepResult,
359        WatchFrequency, WatchProperty, Watchpoint,
360    };
361    pub use crate::decision_diagram::{
362        benchmark_dd_simulator, DDNode, DDOptimizer, DDSimulator, DDStats, DecisionDiagram, Edge,
363    };
364    pub use crate::device_noise_models::{
365        CalibrationData, CoherenceParameters, DeviceNoiseConfig, DeviceNoiseModel,
366        DeviceNoiseSimulator, DeviceNoiseUtils, DeviceTopology, DeviceType, FrequencyDrift,
367        GateErrorRates, GateTimes, NoiseBenchmarkResults, NoiseSimulationStats,
368        SuperconductingNoiseModel,
369    };
370    pub use crate::distributed_simulator::{
371        benchmark_distributed_simulation, ChunkMetadata, CommunicationConfig, CommunicationManager,
372        CommunicationPattern, CommunicationRequirements, DistributedGateOperation,
373        DistributedPerformanceStats, DistributedQuantumSimulator, DistributedSimulatorConfig,
374        DistributionStrategy, FaultToleranceConfig, FaultToleranceMessage, FaultToleranceStats,
375        LoadBalancer, LoadBalancingCommand, LoadBalancingConfig,
376        LoadBalancingStrategy as DistributedLoadBalancingStrategy, NetworkConfig, NetworkMessage,
377        NetworkStats, NodeCapabilities, NodeInfo, NodePerformanceStats, NodeStatus,
378        OperationPriority, RebalancingStats, SimulationState, StateChunk, SynchronizationLevel,
379        WorkDistribution,
380    };
381    pub use crate::dynamic::*;
382    pub use crate::enhanced_statevector::EnhancedStateVectorSimulator;
383    pub use crate::error::{Result, SimulatorError};
384    #[allow(unused_imports)]
385    pub use crate::error_correction::*;
386    pub use crate::error_mitigation::{
387        ExtrapolationMethod as ZNEExtrapolationMethod, MeasurementErrorMitigation, SymmetryType,
388        SymmetryVerification as ErrorMitigationSymmetryVerification, ZeroNoiseExtrapolation,
389    };
390    pub use crate::fermionic_simulation::{
391        benchmark_fermionic_simulation, FermionicHamiltonian, FermionicOperator,
392        FermionicSimulator, FermionicStats, FermionicString, JordanWignerTransform,
393    };
394    pub use crate::fusion::{
395        benchmark_fusion_strategies, FusedGate, FusionStats, FusionStrategy, GateFusion, GateGroup,
396        OptimizedCircuit, OptimizedGate,
397    };
398    pub use crate::gpu_observables::{
399        ObservableCalculator, ObservableConfig, PauliHamiltonian, PauliObservable, PauliOp,
400    };
401    pub use crate::holographic_quantum_error_correction::{
402        benchmark_holographic_qec, BulkReconstructionMethod, BulkReconstructionResult,
403        HolographicCodeType, HolographicQECBenchmarkResults, HolographicQECConfig,
404        HolographicQECResult, HolographicQECSimulator, HolographicQECStats, HolographicQECUtils,
405    };
406    pub use crate::jit_compilation::{
407        benchmark_jit_compilation, CompilationPriority, CompilationStatus, CompiledFunction,
408        CompiledGateSequence, GateSequencePattern, JITBenchmarkResults, JITCompiler, JITConfig,
409        JITOptimization, JITOptimizationLevel, JITPerformanceStats, JITQuantumSimulator,
410        JITSimulatorStats, OptimizationSuggestion, PatternAnalysisResult, PatternComplexity,
411        RuntimeProfiler, RuntimeProfilerStats,
412    };
413    pub use crate::large_scale_simulator::{
414        CompressedQuantumState, CompressionAlgorithm, CompressionMetadata,
415        LargeScaleQuantumSimulator, LargeScaleSimulatorConfig, MemoryMappedQuantumState,
416        MemoryStatistics as LargeScaleMemoryStatistics, QuantumStateRepresentation,
417        SparseQuantumState,
418    };
419    pub use crate::memory_bandwidth_optimization::{
420        BandwidthMonitor, MemoryBandwidthOptimizer, MemoryLayout, MemoryOptimizationConfig,
421        MemoryOptimizationReport, MemoryStats, OptimizedStateVector,
422    };
423    pub use crate::memory_optimization::{
424        AdvancedMemoryPool, MemoryStats as AdvancedMemoryStats, NumaAwareAllocator,
425    };
426    pub use crate::memory_prefetching_optimization::{
427        AccessPatternPredictor, AccessPatternType, DataLocalityOptimizer,
428        LocalityOptimizationResult, LocalityStrategy, LoopPattern, MemoryPrefetcher, NUMATopology,
429        PerformanceFeedback, PrefetchConfig, PrefetchHint, PrefetchStats, PrefetchStrategy,
430    };
431    pub use crate::mps_basic::{BasicMPS, BasicMPSConfig, BasicMPSSimulator};
432    #[cfg(feature = "mps")]
433    pub use crate::mps_enhanced::{utils::*, EnhancedMPS, EnhancedMPSSimulator, MPSConfig};
434    pub use crate::mps_simulator::{MPSSimulator, MPS};
435    pub use crate::noise::*;
436    pub use crate::noise::{NoiseChannel, NoiseModel};
437    pub use crate::noise_advanced::*;
438    pub use crate::noise_advanced::{AdvancedNoiseModel, RealisticNoiseModelBuilder};
439    pub use crate::noise_extrapolation::{
440        benchmark_noise_extrapolation, DistillationProtocol, ExtrapolationMethod, FitStatistics,
441        NoiseScalingMethod, SymmetryOperation, SymmetryVerification, SymmetryVerificationResult,
442        VirtualDistillation, VirtualDistillationResult, ZNEResult, ZeroNoiseExtrapolator,
443    };
444    pub use crate::noise_models::{
445        AmplitudeDampingNoise, BitFlipNoise, DepolarizingNoise, NoiseChannel as KrausNoiseChannel,
446        NoiseModel as KrausNoiseModel, PhaseDampingNoise, PhaseFlipNoise, ThermalRelaxationNoise,
447    };
448    pub use crate::open_quantum_systems::{
449        quantum_fidelity, CompositeNoiseModel, EvolutionResult, IntegrationMethod, LindladOperator,
450        LindladSimulator, NoiseModelBuilder, ProcessTomography, QuantumChannel,
451    };
452    pub use crate::opencl_amd_backend::{
453        benchmark_amd_opencl_backend, AMDOpenCLSimulator, KernelArg, MemoryFlags, OpenCLBuffer,
454        OpenCLConfig, OpenCLDevice, OpenCLDeviceType, OpenCLKernel, OpenCLPlatform, OpenCLStats,
455        OptimizationLevel as OpenCLOptimizationLevel,
456    };
457    pub use crate::operation_cache::{
458        CacheConfig, CacheStats, CachedData, CachedOperation, EvictionPolicy, GateMatrixCache,
459        OperationKey, QuantumOperationCache,
460    };
461    pub use crate::parallel_tensor_optimization::{
462        ContractionPair, LoadBalancingStrategy, NumaTopology, ParallelTensorConfig,
463        ParallelTensorEngine, ParallelTensorStats, TensorWorkQueue, TensorWorkUnit,
464        ThreadAffinityConfig,
465    };
466    pub use crate::path_integral::{
467        benchmark_path_integral_methods, ConvergenceStats, PathIntegralConfig, PathIntegralMethod,
468        PathIntegralResult, PathIntegralSimulator, PathIntegralStats, PathIntegralUtils,
469        QuantumPath,
470    };
471    pub use crate::pauli::{PauliOperator, PauliOperatorSum, PauliString, PauliUtils};
472    pub use crate::performance_benchmark::{
473        run_comprehensive_benchmark, run_quick_benchmark, BenchmarkComparison, BenchmarkConfig,
474        BenchmarkResult, MemoryStats as BenchmarkMemoryStats, QuantumBenchmarkSuite,
475        ScalabilityAnalysis, ThroughputStats, TimingStats,
476    };
477    pub use crate::performance_prediction::{
478        create_performance_predictor, predict_circuit_execution_time, ComplexityMetrics,
479        ExecutionDataPoint, ModelType, PerformanceHardwareSpecs, PerformancePredictionConfig,
480        PerformancePredictionEngine, PerformanceTimingStatistics, PredictionMetadata,
481        PredictionResult, PredictionStatistics, PredictionStrategy, ResourceMetrics, TrainedModel,
482        TrainingStatistics,
483    };
484    pub use crate::photonic::{
485        benchmark_photonic_methods, FockState, PhotonicConfig, PhotonicMethod, PhotonicOperator,
486        PhotonicResult, PhotonicSimulator, PhotonicState, PhotonicStats, PhotonicUtils,
487    };
488    pub use crate::precision::{
489        benchmark_precisions, AdaptivePrecisionConfig, AdaptiveStateVector, ComplexAmplitude,
490        ComplexF16, Precision, PrecisionStats, PrecisionTracker,
491    };
492    pub use crate::qaoa_optimization::{
493        benchmark_qaoa, LevelTransitionCriteria, MultiLevelQAOAConfig, QAOAConfig, QAOAConstraint,
494        QAOAGraph, QAOAInitializationStrategy, QAOALevel, QAOAMixerType, QAOAOptimizationStrategy,
495        QAOAOptimizer, QAOAProblemType, QAOAResult, QAOAStats,
496        QuantumAdvantageMetrics as QAOAQuantumAdvantageMetrics, SolutionQuality,
497    };
498    pub use crate::qmc::{DMCResult, PIMCResult, VMCResult, Walker, WaveFunction, DMC, PIMC, VMC};
499    pub use crate::qml_integration::{
500        AdamOptimizer, LossFunction, OptimizerType, QMLBenchmarkResults, QMLFramework,
501        QMLIntegration, QMLIntegrationConfig, QMLLayer, QMLLayerType, QMLOptimizer,
502        QMLTrainingStats, QMLUtils, QuantumNeuralNetwork, SGDOptimizer, TrainingConfig,
503        TrainingExample, TrainingResult,
504    };
505    pub use crate::quantum_advantage_demonstration::{
506        benchmark_quantum_advantage, ClassicalAlgorithm, ClassicalAlgorithmType,
507        ClassicalHardwareSpecs, ClassicalResources, CostAnalysis, DetailedResult,
508        FutureProjections, HardwareSpecs, MarketImpact, OperationalCosts, ProblemDomain,
509        ProblemInstance, QuantumAdvantageConfig, QuantumAdvantageDemonstrator,
510        QuantumAdvantageMetrics, QuantumAdvantageResult, QuantumAdvantageType, QuantumAlgorithm,
511        QuantumHardwareSpecs, QuantumResources, ScalingAnalysis, StatisticalAnalysis,
512        TechnologyProjection, TimelineProjection, VerificationResult,
513    };
514    pub use crate::quantum_algorithms::{
515        benchmark_quantum_algorithms, AlgorithmResourceStats, EnhancedPhaseEstimation,
516        GroverResult, OptimizationLevel as AlgorithmOptimizationLevel, OptimizedGroverAlgorithm,
517        OptimizedShorAlgorithm, PhaseEstimationResult, QuantumAlgorithmConfig, ShorResult,
518    };
519    pub use crate::quantum_annealing::{
520        AnnealingBenchmarkResults, AnnealingResult, AnnealingScheduleType, AnnealingSolution,
521        AnnealingStats, AnnealingTopology, IsingProblem, ProblemType, QUBOProblem,
522        QuantumAnnealingConfig, QuantumAnnealingSimulator, QuantumAnnealingUtils,
523    };
524    pub use crate::quantum_cellular_automata::{
525        BoundaryConditions, MeasurementStrategy, NeighborhoodType, QCABenchmarkResults, QCAConfig,
526        QCAEvolutionResult, QCARule, QCARuleType, QCASnapshot, QCAStats, QCAUtils,
527        QuantumCellularAutomaton,
528    };
529    pub use crate::quantum_chemistry_dmrg::{
530        benchmark_quantum_chemistry_dmrg, AccuracyLevel, AccuracyMetrics, ActiveSpaceAnalysis,
531        ActiveSpaceConfig, AtomicCenter, BasisFunction, BasisSetType, BenchmarkPerformanceMetrics,
532        ComputationalCostEstimate, ConvergenceInfo, DMRGResult, DMRGSimulationStats, DMRGState,
533        ElectronicStructureMethod, ExchangeCorrelationFunctional, MemoryStatistics,
534        MolecularHamiltonian, MoleculeBenchmarkResult, OrbitalSelectionStrategy,
535        PointGroupSymmetry, QuantumChemistryBenchmarkResults, QuantumChemistryDMRGConfig,
536        QuantumChemistryDMRGSimulator, QuantumChemistryDMRGUtils, QuantumNumberSector,
537        ScalingBehavior, SpectroscopicProperties, TestMolecule, TimingStatistics, ValidationResult,
538    };
539    pub use crate::quantum_field_theory::{
540        ActionEvaluator, ActionType, CorrelationFunction, FieldOperator, FieldOperatorType,
541        FieldTheoryType, FixedPoint, FixedPointType, GaugeFieldConfig, GaugeFixing, GaugeGroup,
542        LatticeParameters, MonteCarloAlgorithm, MonteCarloState, ParticleState,
543        PathIntegralConfig as QFTPathIntegralConfig, PathIntegralSampler, QFTBoundaryConditions,
544        QFTConfig as QuantumFieldTheoryConfig, QFTStats as QuantumFieldTheoryStats,
545        QuantumFieldTheorySimulator, RGFlow, RenormalizationScheme, ScatteringProcess,
546        TimeOrdering, WilsonLoop,
547    };
548    pub use crate::quantum_gravity_simulation::{
549        benchmark_quantum_gravity_simulation, AdSCFTConfig, AsymptoticSafetyConfig,
550        BackgroundMetric, BoundaryRegion, BoundaryTheory, BulkGeometry, CDTConfig,
551        ConvergenceInfo as GravityConvergenceInfo, EntanglementStructure,
552        FixedPoint as GravityFixedPoint, FixedPointStability, GeometryMeasurements,
553        GravityApproach, GravityBenchmarkResults, GravitySimulationResult, GravitySimulationStats,
554        HolographicDuality, Intertwiner, LQGConfig, QuantumGravityConfig, QuantumGravitySimulator,
555        QuantumGravityUtils, RGTrajectory, RTSurface, SU2Element, Simplex, SimplexType,
556        SimplicialComplex, SpacetimeState, SpacetimeVertex, SpinNetwork, SpinNetworkEdge,
557        SpinNetworkNode, TimeSlice, TopologyMeasurements,
558    };
559    pub use crate::quantum_inspired_classical::{
560        benchmark_quantum_inspired_algorithms, ActivationFunction, AlgorithmCategory,
561        AlgorithmConfig, BenchmarkingConfig, BenchmarkingResults, CommunityDetectionParams,
562        ComparisonStats, ConstraintMethod, ContractionMethod, ConvergenceAnalysis, ExecutionStats,
563        GraphAlgorithm, GraphConfig, GraphMetrics, GraphResult, LinalgAlgorithm, LinalgConfig,
564        LinalgResult, MLAlgorithm, MLConfig, MLTrainingResult, NetworkArchitecture,
565        ObjectiveFunction, OptimizationAlgorithm, OptimizationConfig as QIOptimizationConfig,
566        OptimizationResult as QIOptimizationResult, OptimizerType as QIOptimizerType,
567        PerformanceAnalysisConfig, ProposalDistribution,
568        QuantumAdvantageMetrics as QIQuantumAdvantageMetrics, QuantumInspiredConfig,
569        QuantumInspiredFramework, QuantumInspiredStats, QuantumInspiredUtils, QuantumParameters,
570        QuantumWalkParams, RuntimeStats, SampleStatistics, SamplingAlgorithm, SamplingConfig,
571        SamplingResult, StatisticalAnalysis as QIStatisticalAnalysis, TemperatureSchedule,
572        TensorNetworkConfig, TensorTopology as QITensorTopology,
573        TrainingConfig as QITrainingConfig, WalkStatistics, WaveFunctionConfig, WaveFunctionType,
574    };
575    pub use crate::quantum_ldpc_codes::{
576        benchmark_quantum_ldpc_codes, BPDecodingResult, BeliefPropagationAlgorithm, CheckNode,
577        LDPCConfig, LDPCConstructionMethod, LDPCStats, QuantumLDPCCode, TannerGraph, VariableNode,
578    };
579    pub use crate::quantum_machine_learning_layers::{
580        benchmark_quantum_ml_layers, AdversarialAttackMethod, AdversarialDefenseMethod,
581        AdversarialTrainingConfig, AlternatingSchedule, AnsatzType, AttentionHead,
582        BenchmarkingProtocols, CachingConfig, CalibrationFrequency, ClassicalArchitecture,
583        ClassicalPreprocessingConfig, ComputationOptimizationConfig, ConnectivityConstraints,
584        ConvolutionalFilter, DataEncodingMethod, DenseConnection,
585        DistillationProtocol as QMLDistillationProtocol, EarlyStoppingConfig, EnsembleMethod,
586        EnsembleMethodsConfig, EntanglementPattern, ErrorMitigationConfig, FeatureSelectionConfig,
587        FeatureSelectionMethod, GradientFlowConfig, GradientMethod as QMLGradientMethod,
588        HardwareOptimizationConfig, HardwareOptimizationLevel, HybridTrainingConfig, LSTMGate,
589        LSTMGateType, LearningRateSchedule,
590        MemoryOptimizationConfig as QMLMemoryOptimizationConfig, NoiseAwareTrainingConfig,
591        NoiseCharacterizationConfig, NoiseCharacterizationMethod, NoiseInjectionConfig,
592        NoiseParameters, NoiseType, OptimizerType as QMLOptimizerType, PQCGate, PQCGateType,
593        ParallelizationConfig, ParameterizedQuantumCircuitLayer, PerformanceOptimizationConfig,
594        QMLArchitectureType, QMLBenchmarkResults as QMLLayersQMLBenchmarkResults, QMLConfig,
595        QMLEpochMetrics, QMLLayer as QMLLayersQMLLayer, QMLLayerConfig,
596        QMLLayerType as QMLLayersQMLLayerType, QMLStats, QMLTrainingAlgorithm, QMLTrainingConfig,
597        QMLTrainingResult, QMLTrainingState, QMLUtils as QMLLayersQMLUtils,
598        QuantumAdvantageMetrics as QMLQuantumAdvantageMetrics, QuantumAttentionLayer,
599        QuantumClassicalInterface, QuantumConvolutionalLayer, QuantumDenseLayer,
600        QuantumHardwareTarget, QuantumLSTMLayer, QuantumMLFramework, RegularizationConfig,
601        RobustTrainingConfig, RotationGate, ScalingMethod, TwoQubitGate, VirtualDistillationConfig,
602        VotingStrategy,
603    };
604    pub use crate::quantum_ml_algorithms::{
605        benchmark_quantum_ml_algorithms, GradientMethod as QMLAlgorithmsGradientMethod,
606        HardwareArchitecture, HardwareAwareCompiler, HardwareMetrics, HardwareOptimizations,
607        OptimizerState, OptimizerType as QMLAlgorithmsOptimizerType, ParameterizedQuantumCircuit,
608        QMLAlgorithmType, QMLConfig as QMLAlgorithmsConfig, QuantumMLTrainer, TrainingHistory,
609        TrainingResult as QMLAlgorithmsTrainingResult,
610    };
611    pub use crate::quantum_reservoir_computing::{
612        benchmark_quantum_reservoir_computing, InputEncoding, OutputMeasurement,
613        QuantumReservoirArchitecture, QuantumReservoirComputer, QuantumReservoirConfig,
614        QuantumReservoirState, ReservoirDynamics, ReservoirMetrics, ReservoirTrainingData,
615        TrainingResult as ReservoirTrainingResult,
616    };
617    pub use crate::quantum_reservoir_computing_enhanced::{
618        benchmark_enhanced_quantum_reservoir_computing, ARIMAParams,
619        ActivationFunction as ReservoirActivationFunction, AdvancedLearningConfig, IPCFunction,
620        LearningAlgorithm, MemoryAnalysisConfig, MemoryAnalyzer, MemoryKernel, MemoryMetrics,
621        MemoryTask, NARState, QuantumReservoirComputerEnhanced,
622        ReservoirTrainingData as EnhancedReservoirTrainingData, TimeSeriesConfig,
623        TimeSeriesPredictor, TrainingExample as ReservoirTrainingExample,
624        TrainingResult as EnhancedTrainingResult, TrendModel,
625    };
626    pub use crate::quantum_supremacy::{
627        benchmark_quantum_supremacy, verify_supremacy_claim, CircuitLayer, CostComparison,
628        CrossEntropyResult, GateSet, HOGAnalysis, PorterThomasResult, QuantumGate,
629        QuantumSupremacyVerifier, RandomCircuit, VerificationParams,
630    };
631    pub use crate::quantum_volume::{
632        benchmark_quantum_volume, calculate_quantum_volume_with_params, QVCircuit, QVGate,
633        QVParams, QVStats, QuantumVolumeCalculator, QuantumVolumeResult,
634    };
635    pub use crate::qulacs_backend::{
636        gates as qulacs_gates, QubitIndex, QulacsStateVector, StateIndex,
637    };
638    pub use crate::scirs2_complex_simd::{
639        apply_cnot_complex_simd, apply_hadamard_gate_complex_simd,
640        apply_single_qubit_gate_complex_simd, benchmark_complex_simd_operations, ComplexSimdOps,
641        ComplexSimdVector,
642    };
643    pub use crate::scirs2_eigensolvers::{
644        benchmark_spectral_analysis, BandStructureResult, EntanglementSpectrumResult,
645        PhaseTransitionResult, QuantumHamiltonianLibrary, SciRS2SpectralAnalyzer,
646        SpectralAnalysisResult, SpectralConfig, SpectralDensityResult, SpectralStatistics,
647    };
648    pub use crate::scirs2_integration::{
649        BackendStats as SciRS2BackendStats, SciRS2Backend, SciRS2Matrix, SciRS2MemoryAllocator,
650        SciRS2ParallelContext, SciRS2SimdConfig, SciRS2SimdContext, SciRS2Vector,
651        SciRS2VectorizedFFT,
652    };
653    // SciRS2Backend already exported above with scirs2_integration module
654    pub use crate::scirs2_qft::{
655        benchmark_qft_methods, compare_qft_accuracy, QFTConfig, QFTMethod, QFTStats, QFTUtils,
656        SciRS2QFT,
657    };
658    pub use crate::scirs2_sparse::{
659        benchmark_sparse_solvers, compare_sparse_solver_accuracy, Preconditioner,
660        SciRS2SparseSolver, SparseEigenResult, SparseFormat, SparseMatrix, SparseMatrixUtils,
661        SparseSolverConfig, SparseSolverMethod, SparseSolverStats,
662    };
663    pub use crate::shot_sampling::{
664        analysis, BitString, ComparisonResult, ConvergenceResult, ExpectationResult,
665        MeasurementStatistics, NoiseModel as SamplingNoiseModel, QuantumSampler,
666        SamplingConfig as ShotSamplingConfig, ShotResult, SimpleReadoutNoise,
667    };
668    #[allow(unused_imports)]
669    pub use crate::simulator::*;
670    pub use crate::simulator::{Simulator, SimulatorResult};
671    pub use crate::sparse::{apply_sparse_gate, CSRMatrix, SparseGates, SparseMatrixBuilder};
672    pub use crate::specialized_gates::{
673        specialize_gate, CNOTSpecialized, CPhaseSpecialized, CZSpecialized, FredkinSpecialized,
674        HadamardSpecialized, PauliXSpecialized, PauliYSpecialized, PauliZSpecialized,
675        PhaseSpecialized, RXSpecialized, RYSpecialized, RZSpecialized, SGateSpecialized,
676        SWAPSpecialized, SpecializedGate, TGateSpecialized, ToffoliSpecialized,
677    };
678    pub use crate::specialized_simulator::{
679        benchmark_specialization, SpecializationStats, SpecializedSimulatorConfig,
680        SpecializedStateVectorSimulator,
681    };
682    pub use crate::stabilizer::{is_clifford_circuit, StabilizerGate, StabilizerSimulator};
683    pub use crate::statevector::StateVectorSimulator;
684    pub use crate::stim_dem::{DEMError, DetectorErrorModel};
685    pub use crate::stim_executor::{
686        DetectorRecord, ExecutionResult, ObservableRecord, StimExecutor,
687    };
688    pub use crate::stim_sampler::{
689        compile_sampler, compile_sampler_with_dem, CompiledStimCircuit, DetectorSampler,
690        SampleStatistics as StimSampleStatistics,
691    };
692    pub use crate::telemetry::{
693        benchmark_telemetry, Alert, AlertLevel, AlertThresholds, DiskIOStats, MetricsSummary,
694        NetworkIOStats, PerformanceSnapshot, QuantumMetrics, TelemetryCollector, TelemetryConfig,
695        TelemetryExportFormat, TelemetryMetric,
696    };
697    pub use crate::topological_quantum_simulation::{
698        AnyonModel, AnyonType, LatticeType, TopologicalBoundaryConditions, TopologicalConfig,
699        TopologicalErrorCode, TopologicalQuantumSimulator,
700    };
701    pub use crate::tpu_acceleration::{
702        benchmark_tpu_acceleration, CommunicationBackend, DistributedContext, MemoryOptimization,
703        TPUConfig, TPUDataType, TPUDeviceInfo, TPUDeviceType, TPUMemoryManager,
704        TPUQuantumSimulator, TPUStats, TPUTensorBuffer, TPUTopology, XLAComputation,
705    };
706    pub use crate::trotter::{
707        Hamiltonian, HamiltonianLibrary, HamiltonianTerm, TrotterDecomposer, TrotterMethod,
708    };
709    pub use crate::visualization_hooks::{
710        benchmark_visualization, ASCIIVisualizationHook, ColorScheme, GateVisualizationData,
711        JSONVisualizationHook, VisualizationConfig, VisualizationData, VisualizationFramework,
712        VisualizationHook, VisualizationManager,
713    };
714
715    #[cfg(all(feature = "gpu", not(target_os = "macos")))]
716    pub use crate::gpu_linalg::{benchmark_gpu_linalg, GpuLinearAlgebra};
717    #[allow(unused_imports)]
718    pub use crate::statevector::*;
719    pub use crate::tensor::*;
720    pub use crate::utils::*;
721    pub use scirs2_core::Complex64;
722}
723
724/// A placeholder for future error correction code implementations
725#[derive(Debug, Clone)]
726pub struct ErrorCorrection;
727
728// For backward compatibility, also re-export the prelude at the top level
729#[deprecated(since = "1.0.0", note = "Use api::prelude modules for new code")]
730pub use prelude::*;
731
732/// Convenient access to the new organized simulation API
733///
734/// # Examples
735///
736/// ```rust
737/// // For basic simulation
738/// use quantrs2_sim::v1::essentials::*;
739///
740/// // For GPU simulation
741/// use quantrs2_sim::v1::gpu::*;
742///
743/// // For distributed simulation
744/// use quantrs2_sim::v1::distributed::*;
745/// ```
746pub mod v1 {
747    pub use crate::api::prelude::*;
748}
749
750// CUDA-based GPU implementation (Linux/Windows with NVIDIA GPU)
751#[cfg(all(feature = "gpu", not(target_os = "macos")))]
752pub mod gpu;
753
754#[cfg(all(feature = "gpu", not(target_os = "macos")))]
755pub mod gpu_linalg;
756
757// Metal-based GPU implementation for macOS (future implementation)
758#[cfg(all(feature = "gpu", target_os = "macos"))]
759pub mod gpu_metal;
760
761#[cfg(all(feature = "gpu", target_os = "macos"))]
762pub mod gpu_linalg_metal;
763
764pub use crate::tensor_network::*;
765
766// Old monolithic optimization modules have been refactored into specialized implementations
767// (optimized_chunked, optimized_simd, optimized_simple, optimized_simulator, etc.)
768// These comments preserved for reference - the functionality is available through the new modules
quantrs2_sim/lib.rs

quantrs2_sim/
lib.rs
