stabilizer_qec 1.1.0

Quantum error-correction simulation and decoding: Stim-format circuits and error models, a bit-parallel sampler, sparse-blossom, correlated and belief matching, BP+OSD, window decoders, bivariate bicycle codes and lattice surgery.
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

use crate::tableau::Tableau;

#[derive(Clone)]
pub struct StabilizerSimulator {
    tableau: Tableau,
}

impl StabilizerSimulator {
    pub fn new(n: usize) -> Self {
        StabilizerSimulator {
            tableau: Tableau::new(n),
        }
    }

    /// Build a simulator whose measurement randomness comes from `seed`.
    /// Circuit-level simulation must use this — see `Tableau::with_seed`.
    pub fn with_seed(n: usize, seed: u64) -> Self {
        StabilizerSimulator {
            tableau: Tableau::with_seed(n, seed),
        }
    }

    pub fn n(&self) -> usize {
        self.tableau.n
    }

    pub fn apply_h(&mut self, qubit: usize) {
        self.tableau.apply_h(qubit);
    }

    pub fn apply_s(&mut self, qubit: usize) {
        self.tableau.apply_s(qubit);
    }

    pub fn apply_s_dag(&mut self, qubit: usize) {
        // S^dag = S^3
        self.tableau.apply_s(qubit);
        self.tableau.apply_s(qubit);
        self.tableau.apply_s(qubit);
    }

    pub fn apply_cnot(&mut self, control: usize, target: usize) {
        self.tableau.apply_cnot(control, target);
    }

    pub fn apply_x(&mut self, qubit: usize) {
        // X gate on qubit k: r_i = r_i ^ z_{i,k} for all rows i
        for i in 0..(2 * self.tableau.n) {
            let z_val = self.tableau.get_z(i, qubit);
            self.tableau.set_r(i, self.tableau.get_r(i) ^ (z_val as u8));
        }
    }

    pub fn apply_z(&mut self, qubit: usize) {
        // Z gate on qubit k: r_i = r_i ^ x_{i,k} for all rows i
        for i in 0..(2 * self.tableau.n) {
            let x_val = self.tableau.get_x(i, qubit);
            self.tableau.set_r(i, self.tableau.get_r(i) ^ (x_val as u8));
        }
    }

    pub fn apply_y(&mut self, qubit: usize) {
        // Y = i X Z. Up to global phase (which does not affect stabilizers), Y is X then Z.
        // r_i = r_i ^ x_{i,k} ^ z_{i,k}
        for i in 0..(2 * self.tableau.n) {
            let x_val = self.tableau.get_x(i, qubit);
            let z_val = self.tableau.get_z(i, qubit);
            self.tableau.set_r(i, self.tableau.get_r(i) ^ (x_val as u8) ^ (z_val as u8));
        }
    }

    pub fn measure_z(&mut self, qubit: usize) -> u8 {
        self.tableau.measure(qubit)
    }

    pub fn measure_x(&mut self, qubit: usize) -> u8 {
        // Measure X: H, measure Z, H
        self.apply_h(qubit);
        let outcome = self.measure_z(qubit);
        self.apply_h(qubit);
        outcome
    }

    pub fn measure_y(&mut self, qubit: usize) -> u8 {
        // Measure Y: S^dag, H, measure Z, H, S
        self.apply_s_dag(qubit);
        self.apply_h(qubit);
        let outcome = self.measure_z(qubit);
        self.apply_h(qubit);
        self.apply_s(qubit);
        outcome
    }

    // Helper for debugging: prints the stabilizer rows
    pub fn print_stabilizers(&self) {
        let n = self.tableau.n;
        println!("Stabilizer Generators:");
        for i in n..(2 * n) {
            let phase = if self.tableau.get_r(i) == 1 { "-" } else { "+" };
            print!("Row {}: {} ", i, phase);
            for qubit in 0..n {
                let x = self.tableau.get_x(i, qubit);
                let z = self.tableau.get_z(i, qubit);
                match (x, z) {
                    (false, false) => print!("I"),
                    (true, false) => print!("X"),
                    (false, true) => print!("Z"),
                    (true, true) => print!("Y"),
                }
            }
            println!();
        }
    }
}