quizx 0.3.0

Quantum Circuit Optimisation and Compilation using the ZX-calculus
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
194

use approx::abs_diff_eq;
use num::Complex;

use crate::circuit::Circuit;
use crate::graph::GraphLike;
use crate::simplify::full_simp;
use crate::tensor::ToTensor;
use crate::vec_graph::Graph;

/// Checks if two graphs have the same number of input qubits and output qubits respectively.
/// This check is computationally inexpensive and suitable for any number of qubits.
pub fn equal_graph_dim(g1: &Graph, g2: &Graph) -> bool {
    if g1.inputs().len() != g2.inputs().len() {
        // both graphs have an unequal number of input qubits
        return false;
    }
    if g1.outputs().len() != g2.outputs().len() {
        // both graphs have an unequal number of output qubits
        return false;
    }
    true
}

/// Checks if two circuits have the same number of input qubits and output qubits respectively.
/// This check is computationally inexpensive and suitable for any number of qubits.
pub fn equal_circuit_dim(c1: &Circuit, c2: &Circuit) -> bool {
    let g1: Graph = c1.to_graph();
    let g2: Graph = c2.to_graph();
    equal_graph_dim(&g1, &g2)
}

/// Checks the equality of two circuit graphs by comparing the linear maps they represent.
/// This approach is only feasible for a small number of qubits. (up to 7)
pub fn equal_graph_tensor(g1: &Graph, g2: &Graph) -> bool {
    // First, quickly check if both tensors have the same dimension
    if !equal_graph_dim(g1, g2) {
        return false;
    }
    g1.to_tensorf() == g2.to_tensorf()
}

/// Checks the equality of two circuits by comparing the linear maps they represent.
/// This approach is only feasible for a small number of qubits. (up to 7)
pub fn equal_circuit_tensor(c1: &Circuit, c2: &Circuit) -> bool {
    let g1: Graph = c1.to_graph();
    let g2: Graph = c2.to_graph();
    equal_graph_tensor(&g1, &g2)
}

/// Implements `Circuit.verify_equality` from pyzx.
///
/// Verifies the equality of two circuit graphs by investigating whether they "cancel each other out".
/// This is done by composing one circuit graph with the adjoint of the other. If simplifying the
/// result yields the identity, then the two circuit graphs are verifiably equal.
///
/// Note that the simplification may not yield the identity even if both circuit graphs are equal,
/// which is why this approch gives an inconclusive answer if the resulting circuit is not
/// the identity. In general, this approach can't verify that two circuits are unequal.
///
/// This approach is feasible even for a high number of qubits.
pub fn equal_graph_with_options(g1: &Graph, g2: &Graph, up_to_global_phase: bool) -> Option<bool> {
    if !equal_graph_dim(g1, g2) {
        // both graphs are verifiably unequal due to an unequal number of input qubits or output qubits
        return Some(false);
    }
    let mut g = g1.to_adjoint();
    g.plug(g2);
    full_simp(&mut g);
    if g.is_identity() {
        if !up_to_global_phase {
            // both graphs are verifiably equal if the resulting global phase is zero
            // otherwise, they are verifiably unequal / only equal up to global phase
            let c: Complex<f64> = g.scalar().into();
            return Some(abs_diff_eq!(c.arg(), 0.0));
        }
        // both graphs are verifiably equal up to global phase
        return Some(true);
    }
    // both graphs are neither verifiably equal nor verifiably unequal
    None
}

/// Verifies the equality of two graphs up to global phase.
pub fn equal_graph(g1: &Graph, g2: &Graph) -> Option<bool> {
    equal_graph_with_options(g1, g2, true)
}

/// Verifies the equality of two circuits.
pub fn equal_circuit_with_options(
    c1: &Circuit,
    c2: &Circuit,
    up_to_global_phase: bool,
) -> Option<bool> {
    let g1: Graph = c1.to_graph();
    let g2: Graph = c2.to_graph();
    equal_graph_with_options(&g1, &g2, up_to_global_phase)
}

/// Verifies the equality of two circuits up to global phase.
pub fn equal_circuit(c1: &Circuit, c2: &Circuit) -> Option<bool> {
    equal_circuit_with_options(c1, c2, true)
}

#[cfg(test)]
mod tests {
    use num::Rational64;

    use super::equal_circuit_tensor;
    use super::equal_circuit_with_options;
    use crate::circuit::Circuit;

    /// Inspired by `BothCircuitsEmptyZXChecker` found in `test_equality.cpp` from mqt-qcec
    #[test]
    fn both_circuits_empty() {
        let c1 = Circuit::new(1);
        let c2 = Circuit::new(1);

        // c1 and c2 are equal
        assert!(equal_circuit_tensor(&c1, &c2));
        assert!(equal_circuit_with_options(&c1, &c2, false).unwrap());
    }

    /// Inspired by `CloseButNotEqualConstruction` found in `test_equality.cpp` from mqt-qcec
    #[test]
    fn close_but_not_equal() {
        let mut c1 = Circuit::new(1);
        let mut c2 = Circuit::new(1);

        c1.add_gate("x", vec![0]);
        c2.add_gate("x", vec![0]);

        // slightly change c2
        c2.add_gate_with_phase("rz", vec![0], Rational64::new(1, 1024));

        // c1 and c2 are unequal
        assert!(!equal_circuit_tensor(&c1, &c2));
        // c1 and c2 are not verifiably unequal with a simplification-based approach
        assert!(equal_circuit_with_options(&c1, &c2, true).is_none());
    }

    #[test]
    fn cx_with_ancilla_as_x() {
        let mut c1 = Circuit::new(1);
        c1.add_gate("x", vec![0]);

        let mut c2 = Circuit::new(2);
        c2.add_gate("init_anc", vec![1]); // initiualize ancilla: |0⟩
        c2.add_gate("x", vec![1]); // flip ancilla: |1⟩
        c2.add_gate("cx", vec![1, 0]); // CX controlling for ancilla now behaves like X
        c2.add_gate("x", vec![1]); // flip ancilla back: |0⟩ (otherwise the tensor zeros out!)
        c2.add_gate("post_sel", vec![1]); // remove ancilla

        assert!(equal_circuit_tensor(&c1, &c2));
        assert!(equal_circuit_with_options(&c1, &c2, true).unwrap());
    }

    /// Inspired by `GlobalPhase` found in `test_equality.cpp` from mqt-qcec
    #[test]
    fn global_phase() {
        let mut c1 = Circuit::new(1);
        let mut c2 = Circuit::new(1);

        c1.add_gate("x", vec![0]);
        c2.add_gate("x", vec![0]);

        // flip the global phase of c2
        c2.add_gate("z", vec![0]);
        c2.add_gate("x", vec![0]);
        c2.add_gate("z", vec![0]);
        c2.add_gate("x", vec![0]);

        // c1 and c2 are equal up to global phase
        assert!(equal_circuit_with_options(&c1, &c2, true).unwrap());
        // c1 and c2 are unequal
        assert!(!equal_circuit_tensor(&c1, &c2));
        assert!(!equal_circuit_with_options(&c1, &c2, false).unwrap());
    }

    /// Inspired by `SimulationMoreThan64Qubits` found in `test_equality.cpp` from mqt-qcec
    #[test]
    fn more_than_64_qubits() {
        let mut c1 = Circuit::new(65);
        c1.add_gate("h", vec![0]);
        for i in 1..65 {
            c1.add_gate("cx", vec![0, i]);
        }
        let c2 = c1.clone();

        // comparing the tensors of c1 and c2 is infeasible due to high number of qubits

        // c1 and c2 are verifiably equal
        assert!(equal_circuit_with_options(&c1, &c2, false).unwrap());
    }
}