rustiq-core 0.0.11

Quantum circuit synthesis library in rust
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

use crate::routines::decoding::information_set_decoding;
/// This module contains the necessary methods to synthesize graph states
use crate::structures::clifford_circuit::{CliffordCircuit, CliffordGate};
use crate::structures::graph_state::GraphState;
use crate::structures::pauli_like::PauliLike;

#[derive(Clone, Copy)]
enum Type {
    Cz,
    Cnot,
    SCnotS,
}

type Parities = (Vec<Vec<bool>>, Vec<(Type, usize, usize)>);

fn gather_parities(circuit: &CliffordCircuit, n: usize) -> Parities {
    let mut graph_state = GraphState::new(n);
    let mut parities = Vec::new();
    let mut moves = Vec::new();
    let mut ei = vec![false; n];
    for i in 0..n {
        ei[i] = true;
        parities.push(ei.clone());
        ei[i] = false;
        moves.push((Type::Cz, 0, i));
    }
    for (index, gate) in circuit.gates.iter().enumerate() {
        graph_state.conjugate_with_gate(gate);
        match gate {
            CliffordGate::CNOT(i, j) => {
                for parity in parities.iter_mut() {
                    parity[*i] ^= parity[*j];
                }
                ei[*j] = true;
                parities.push(ei.clone());
                ei[*j] = false;
                moves.push((Type::Cz, index + 1, *j));

                parities.push(graph_state.adj[*i].clone());
                moves.push((Type::Cnot, index + 1, *i));

                graph_state.s(*i);
                parities.push(graph_state.adj[*i].clone());
                graph_state.s(*i);
                moves.push((Type::SCnotS, index + 1, *i));
            }

            CliffordGate::CZ(i, j) => {
                parities.push(graph_state.adj[*i].clone());
                moves.push((Type::Cnot, index + 1, *i));

                graph_state.s(*i);
                parities.push(graph_state.adj[*i].clone());
                graph_state.s(*i);
                moves.push((Type::SCnotS, index + 1, *i));

                parities.push(graph_state.adj[*j].clone());
                moves.push((Type::Cnot, index + 1, *j));

                graph_state.s(*j);
                parities.push(graph_state.adj[*j].clone());
                graph_state.s(*j);
                moves.push((Type::SCnotS, index + 1, *j));
            }
            _ => {}
        }
    }

    (parities, moves)
}

pub fn synthesize_graph_state_count(graph: &GraphState, niter: usize) -> CliffordCircuit {
    let mut circuit = CliffordCircuit::new(graph.n);
    for i in 0..graph.n {
        if i > 0 {
            let (parities, moves) = gather_parities(&circuit, i);
            let mut target = vec![false; i];
            target[..i].copy_from_slice(&graph.adj[i][..i]);
            let solution = information_set_decoding(&parities, &target, niter, true);
            let solution = solution.expect("Something went wrong during syndrome decoding :/");
            let mut new_circuit = CliffordCircuit::new(graph.n);
            let moves: Vec<(Type, usize, usize)> = solution
                .iter()
                .enumerate()
                .filter(|(_a, b)| **b)
                .map(|(a, _)| moves[a])
                .collect();
            for (ty, index, qbit) in moves.iter() {
                if *index == 0 {
                    match ty {
                        Type::Cnot => {
                            new_circuit.gates.push(CliffordGate::CNOT(i, *qbit));
                        }
                        Type::Cz => {
                            new_circuit.gates.push(CliffordGate::CZ(i, *qbit));
                        }
                        Type::SCnotS => {
                            new_circuit.gates.push(CliffordGate::S(*qbit));
                            new_circuit.gates.push(CliffordGate::CNOT(i, *qbit));
                            new_circuit.gates.push(CliffordGate::S(*qbit));
                        }
                    }
                }
            }
            for k in 0..circuit.gates.len() {
                new_circuit.gates.push(circuit.gates[k]);
                for (ty, index, qbit) in moves.iter() {
                    if *index == k + 1 {
                        match ty {
                            Type::Cnot => {
                                new_circuit.gates.push(CliffordGate::CNOT(i, *qbit));
                            }
                            Type::Cz => {
                                new_circuit.gates.push(CliffordGate::CZ(i, *qbit));
                            }
                            Type::SCnotS => {
                                new_circuit.gates.push(CliffordGate::S(*qbit));
                                new_circuit.gates.push(CliffordGate::CNOT(i, *qbit));
                                new_circuit.gates.push(CliffordGate::S(*qbit));
                            }
                        }
                    }
                }
            }
            circuit = new_circuit;
        }
    }

    let mut simulated = GraphState::new(graph.n);
    simulated.conjugate_with_circuit(&circuit);
    for i in 0..graph.n {
        if simulated.adj[i][i] != graph.adj[i][i] {
            circuit.gates.push(CliffordGate::S(i));
        }
    }
    circuit
}