quantrs2-sim 0.1.3

Quantum circuit simulators for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193

//! Auto-generated module
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use scirs2_core::ndarray::{Array1, Array2, Array3, Array4, Axis};
use scirs2_core::Complex64;

use super::topologicalquantumsimulator_type::TopologicalQuantumSimulator;
use super::types::{
    AnyonType, BraidingType, FibonacciAnyons, IsingAnyons, LatticeType, TopologicalConfig,
    TopologicalUtils,
};

/// Trait for anyon model implementations
pub trait AnyonModelImplementation {
    /// Get anyon types for this model
    fn get_anyon_types(&self) -> Vec<AnyonType>;
    /// Compute fusion coefficients
    fn fusion_coefficients(&self, a: &AnyonType, b: &AnyonType, c: &AnyonType) -> Complex64;
    /// Compute braiding matrix
    fn braiding_matrix(&self, a: &AnyonType, b: &AnyonType) -> Array2<Complex64>;
    /// Compute F-matrix
    fn f_matrix(
        &self,
        a: &AnyonType,
        b: &AnyonType,
        c: &AnyonType,
        d: &AnyonType,
    ) -> Array2<Complex64>;
    /// Check if model is Abelian
    fn is_abelian(&self) -> bool;
    /// Get model name
    fn name(&self) -> &str;
}
#[cfg(test)]
#[allow(clippy::field_reassign_with_default)]
mod tests {
    use super::*;
    use approx::assert_abs_diff_eq;
    #[test]
    fn test_topological_config_default() {
        let config = TopologicalConfig::default();
        assert_eq!(config.lattice_type, LatticeType::SquareLattice);
        assert_eq!(config.dimensions, vec![8, 8]);
        assert!(config.topological_protection);
    }
    #[test]
    fn test_anyon_type_creation() {
        let vacuum = AnyonType::vacuum();
        assert_eq!(vacuum.label, "vacuum");
        assert_eq!(vacuum.quantum_dimension, 1.0);
        assert!(vacuum.is_abelian);
        let sigma = AnyonType::sigma();
        assert_eq!(sigma.label, "sigma");
        assert_abs_diff_eq!(sigma.quantum_dimension, 2.0_f64.sqrt(), epsilon = 1e-10);
        assert!(!sigma.is_abelian);
    }
    #[test]
    fn test_topological_simulator_creation() {
        let config = TopologicalConfig::default();
        let simulator = TopologicalQuantumSimulator::new(config);
        assert!(simulator.is_ok());
    }
    #[test]
    fn test_square_lattice_creation() {
        let dimensions = vec![3, 3];
        let lattice = TopologicalQuantumSimulator::create_square_lattice(&dimensions)
            .expect("failed to create square lattice");
        assert_eq!(lattice.sites.len(), 9);
        assert_eq!(lattice.coordination_number, 4);
        assert!(!lattice.bonds.is_empty());
        assert!(!lattice.plaquettes.is_empty());
    }
    #[test]
    fn test_anyon_placement() {
        let config = TopologicalConfig::default();
        let mut simulator =
            TopologicalQuantumSimulator::new(config).expect("failed to create simulator");
        let vacuum = AnyonType::vacuum();
        let anyon_id = simulator
            .place_anyon(vacuum, vec![2, 3])
            .expect("failed to place anyon");
        assert_eq!(anyon_id, 0);
        assert_eq!(simulator.state.anyon_config.anyons.len(), 1);
        assert_eq!(simulator.state.anyon_config.anyons[0].0, vec![2, 3]);
    }
    #[test]
    fn test_braiding_operation() {
        let mut config = TopologicalConfig::default();
        config.enable_braiding = true;
        let mut simulator =
            TopologicalQuantumSimulator::new(config).expect("failed to create simulator");
        let sigma = AnyonType::sigma();
        let anyon_a = simulator
            .place_anyon(sigma.clone(), vec![1, 1])
            .expect("failed to place anyon A");
        let anyon_b = simulator
            .place_anyon(sigma, vec![2, 2])
            .expect("failed to place anyon B");
        let braiding_phase = simulator.braid_anyons(anyon_a, anyon_b, BraidingType::Clockwise);
        assert!(braiding_phase.is_ok());
        assert_eq!(simulator.braiding_history.len(), 1);
        assert_eq!(simulator.stats.braiding_operations, 1);
    }
    #[test]
    fn test_anyon_fusion() {
        let config = TopologicalConfig::default();
        let mut simulator =
            TopologicalQuantumSimulator::new(config).expect("failed to create simulator");
        let sigma = AnyonType::sigma();
        let anyon_a = simulator
            .place_anyon(sigma.clone(), vec![1, 1])
            .expect("failed to place anyon A");
        let anyon_b = simulator
            .place_anyon(sigma, vec![1, 2])
            .expect("failed to place anyon B");
        let fusion_outcomes = simulator.fuse_anyons(anyon_a, anyon_b);
        assert!(fusion_outcomes.is_ok());
    }
    #[test]
    fn test_fibonacci_anyons() {
        let fibonacci_model = FibonacciAnyons::new();
        let anyon_types = fibonacci_model.get_anyon_types();
        assert_eq!(anyon_types.len(), 2);
        assert!(!fibonacci_model.is_abelian());
        assert_eq!(fibonacci_model.name(), "Fibonacci Anyons");
    }
    #[test]
    fn test_ising_anyons() {
        let ising_model = IsingAnyons::new();
        let anyon_types = ising_model.get_anyon_types();
        assert_eq!(anyon_types.len(), 3);
        assert!(!ising_model.is_abelian());
        assert_eq!(ising_model.name(), "Ising Anyons");
    }
    #[test]
    fn test_surface_code_creation() {
        let dimensions = vec![4, 4];
        let surface_code = TopologicalQuantumSimulator::create_toric_surface_code(&dimensions)
            .expect("failed to create surface code");
        assert_eq!(surface_code.distance, 4);
        assert!(!surface_code.data_qubits.is_empty());
        assert!(!surface_code.x_stabilizers.is_empty());
        assert!(!surface_code.z_stabilizers.is_empty());
    }
    #[test]
    fn test_topological_invariants() {
        let config = TopologicalConfig::default();
        let mut simulator =
            TopologicalQuantumSimulator::new(config).expect("failed to create simulator");
        let invariants = simulator.calculate_topological_invariants();
        assert!(invariants.is_ok());
        let inv = invariants.expect("failed to calculate invariants");
        assert!(inv.chern_number.abs() >= 0);
        assert!(inv.hall_conductivity.is_finite());
    }
    #[test]
    fn test_triangular_lattice() {
        let dimensions = vec![3, 3];
        let lattice = TopologicalQuantumSimulator::create_triangular_lattice(&dimensions)
            .expect("failed to create triangular lattice");
        assert_eq!(lattice.lattice_type, LatticeType::TriangularLattice);
        assert_eq!(lattice.sites.len(), 9);
        assert_eq!(lattice.coordination_number, 6);
    }
    #[test]
    fn test_honeycomb_lattice() {
        let dimensions = vec![2, 2];
        let lattice = TopologicalQuantumSimulator::create_honeycomb_lattice(&dimensions)
            .expect("failed to create honeycomb lattice");
        assert_eq!(lattice.lattice_type, LatticeType::HoneycombLattice);
        assert_eq!(lattice.coordination_number, 3);
        assert!(!lattice.bonds.is_empty());
    }
    #[test]
    fn test_error_detection_and_correction() {
        let mut config = TopologicalConfig::default();
        config.topological_protection = true;
        let mut simulator =
            TopologicalQuantumSimulator::new(config).expect("failed to create simulator");
        let syndrome = simulator.detect_and_correct_errors();
        assert!(syndrome.is_ok());
    }
    #[test]
    fn test_predefined_configs() {
        let configs = vec!["toric_code", "fibonacci_system", "majorana_system"];
        for config_type in configs {
            let config = TopologicalUtils::create_predefined_config(config_type, 4);
            let simulator = TopologicalQuantumSimulator::new(config);
            assert!(simulator.is_ok());
        }
    }
}