qecp 0.2.7

Quantum Error Correction Playground for Surface Code Research
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

//! Simulator that reads from file
//!

use super::noise_model::*;
use super::reproducible_rand::Xoroshiro128StarStar;
use super::simulator::*;
use serde::{Deserialize, Serialize};

#[cfg_attr(feature = "python_binding", cfg_eval)]
#[cfg_attr(feature = "python_binding", pyclass)]
#[derive(Debug, Serialize, Deserialize)]
pub struct SimulatorVec {
    /// the error patterns are periodically constructed
    pub error_patterns: Vec<SparseErrorPattern>,
    /// index
    pub index: usize,
    /// original simulator
    #[serde(skip)]
    simulator: Option<Simulator>,
}

impl Clone for SimulatorVec {
    fn clone(&self) -> Self {
        Self {
            error_patterns: self.error_patterns.clone(),
            index: self.index,
            simulator: self.simulator.clone(),
        }
    }
}

#[cfg(feature = "python_binding")]
bind_trait_simulator_generics! {SimulatorVec}

impl SimulatorGenerics for SimulatorVec {
    fn set_rng(&mut self, _rng: Xoroshiro128StarStar) {}

    fn generate_random_errors(&mut self, noise_model: &NoiseModel) -> (usize, usize) {
        self.index = (self.index + 1) % self.error_patterns.len();
        let sparse_error_pattern = self.generate_sparse_error_pattern();
        let simulator = self.simulator.as_mut().unwrap();
        simulator
            .load_sparse_error_pattern(&sparse_error_pattern, noise_model)
            .unwrap();
        simulator.propagate_errors();
        (sparse_error_pattern.len(), 0)
    }
    fn generate_sparse_detected_erasures(&self) -> SparseErasures {
        SparseErasures::new() // doesn't support erasure errors yet
    }
    fn generate_sparse_error_pattern(&self) -> SparseErrorPattern {
        self.error_patterns[self.index].clone()
    }
    fn generate_sparse_measurement(&self) -> SparseMeasurement {
        self.simulator.as_ref().unwrap().generate_sparse_measurement()
    }
    fn validate_correction(&mut self, correction: &SparseCorrection) -> (bool, bool) {
        self.simulator.as_mut().unwrap().validate_correction(correction)
    }
}

impl SimulatorVec {
    pub fn from_simulator(simulator: Simulator, error_patterns: Vec<SparseErrorPattern>) -> Self {
        assert!(!error_patterns.is_empty());
        Self {
            error_patterns,
            index: 0,
            simulator: Some(simulator),
        }
    }
}