Skip to main content

tk_pg_qm_tableau/
converter.rs

1use crate::Tableau;
2use ::tk_pg_bitpacked::{bools_to_u64_vec, paulis_to_u64s, u64s_to_paulis};
3use ::tk_pg_core::{GateType, Op, Pauli, RotationData, TableauData};
4use ::tk_pg_ir_kernels::{PGTableau, is_clifford};
5use ::tk_pg_utils::{cliff_angle, equiv_0};
6
7/// postcompose a Clifford angle rotation
8fn postcompose_rotation(tableau: &mut Tableau, axis: Pauli, qubit: usize, angle: f64) {
9    if let Some(half_pis) = cliff_angle(angle) {
10        if half_pis == 1 {
11            tableau.postcompose_half_pi(axis, qubit, false);
12        } else if half_pis == 3 {
13            tableau.postcompose_half_pi(axis, qubit, true);
14        } else if half_pis == 2 {
15            tableau.postcompose_pauli(axis, qubit);
16        }
17    } else {
18        panic!(
19            "Cannot postcompose non-Clifford rotation: angle = {}",
20            angle
21        );
22    }
23}
24
25impl PGTableau for Tableau {
26    fn eye(n_qubits: usize) -> Self {
27        Tableau::eye(n_qubits)
28    }
29    fn get_n_qubits(&self) -> usize {
30        self.get_n_qubits()
31    }
32    fn x_image(&self, qubit: usize) -> (Vec<Pauli>, bool) {
33        Tableau::x_image(self, qubit)
34    }
35    fn z_image(&self, qubit: usize) -> (Vec<Pauli>, bool) {
36        Tableau::z_image(self, qubit)
37    }
38    fn get_dagger(&self) -> Self {
39        self.invert()
40    }
41
42    fn precompose_op(&mut self, op: &Op) {
43        if !is_clifford(op) {
44            panic!("Cannot precompose non-Clifford operation: {:?}", op);
45        }
46        match op {
47            Op::Gate { data } => {
48                if !data.get_conditional_bits().is_empty() {
49                    panic!("Conditional gates cannot be precomposed.");
50                }
51                match data.get_gate_type() {
52                    GateType::H => self.precompose_h(data.get_args()[0]),
53                    GateType::S => self.precompose_half_pi(Pauli::Z, data.get_args()[0], false),
54                    GateType::V => self.precompose_half_pi(Pauli::X, data.get_args()[0], false),
55                    GateType::Sdg => self.precompose_half_pi(Pauli::Z, data.get_args()[0], true),
56                    GateType::Vdg => self.precompose_half_pi(Pauli::X, data.get_args()[0], true),
57                    GateType::X => self.precompose_pauli(Pauli::X, data.get_args()[0]),
58                    GateType::Y => self.precompose_pauli(Pauli::Y, data.get_args()[0]),
59                    GateType::Z => self.precompose_pauli(Pauli::Z, data.get_args()[0]),
60                    GateType::XX => self.precompose_tqe(
61                        Pauli::X,
62                        Pauli::X,
63                        data.get_args()[0],
64                        data.get_args()[1],
65                    ),
66                    GateType::XY => self.precompose_tqe(
67                        Pauli::X,
68                        Pauli::Y,
69                        data.get_args()[0],
70                        data.get_args()[1],
71                    ),
72                    GateType::XZ => self.precompose_tqe(
73                        Pauli::X,
74                        Pauli::Z,
75                        data.get_args()[0],
76                        data.get_args()[1],
77                    ),
78                    GateType::YX => self.precompose_tqe(
79                        Pauli::Y,
80                        Pauli::X,
81                        data.get_args()[0],
82                        data.get_args()[1],
83                    ),
84                    GateType::YY => self.precompose_tqe(
85                        Pauli::Y,
86                        Pauli::Y,
87                        data.get_args()[0],
88                        data.get_args()[1],
89                    ),
90                    GateType::YZ => self.precompose_tqe(
91                        Pauli::Y,
92                        Pauli::Z,
93                        data.get_args()[0],
94                        data.get_args()[1],
95                    ),
96                    GateType::ZX => self.precompose_tqe(
97                        Pauli::Z,
98                        Pauli::X,
99                        data.get_args()[0],
100                        data.get_args()[1],
101                    ),
102                    GateType::ZY => self.precompose_tqe(
103                        Pauli::Z,
104                        Pauli::Y,
105                        data.get_args()[0],
106                        data.get_args()[1],
107                    ),
108                    GateType::ZZ => self.precompose_tqe(
109                        Pauli::Z,
110                        Pauli::Z,
111                        data.get_args()[0],
112                        data.get_args()[1],
113                    ),
114                    GateType::SWAP => self.precompose_swap(data.get_args()[0], data.get_args()[1]),
115                    GateType::RX
116                    | GateType::RY
117                    | GateType::RZ
118                    | GateType::ZZPHASE
119                    | GateType::PHASEDX => {
120                        // TODO: Replace with direct precomposition implementations.
121                        let mut tab = Tableau::eye(self.get_n_qubits());
122                        tab.postcompose_op(op);
123                        self.precompose_tableau(&tab);
124                    }
125                    _ => panic!("Unexpected gate type: {:?}", data.get_gate_type()),
126                }
127            }
128            Op::Rotation { .. } => {
129                // TODO: Replace with a direct precomposition implementation.
130                let mut tab = Tableau::eye(self.get_n_qubits());
131                tab.postcompose_op(op);
132                self.precompose_tableau(&tab);
133            }
134            Op::Tableau { data } => {
135                self.precompose_tableau(&data.clone().into());
136            }
137            _ => {
138                panic!("Unexpected operation type: {:?}", op);
139            }
140        }
141    }
142
143    fn postcompose_op(&mut self, op: &Op) {
144        if !is_clifford(op) {
145            panic!("Cannot postcompose non-Clifford operation: {:?}", op);
146        }
147        match op {
148            Op::Gate { data } => {
149                if !data.get_conditional_bits().is_empty() {
150                    panic!("Conditional gates cannot be postcomposed.");
151                }
152                match data.get_gate_type() {
153                    GateType::H => self.postcompose_h(data.get_args()[0]),
154                    GateType::S => self.postcompose_half_pi(Pauli::Z, data.get_args()[0], false),
155                    GateType::V => self.postcompose_half_pi(Pauli::X, data.get_args()[0], false),
156                    GateType::Sdg => self.postcompose_half_pi(Pauli::Z, data.get_args()[0], true),
157                    GateType::Vdg => self.postcompose_half_pi(Pauli::X, data.get_args()[0], true),
158                    GateType::X => self.postcompose_pauli(Pauli::X, data.get_args()[0]),
159                    GateType::Y => self.postcompose_pauli(Pauli::Y, data.get_args()[0]),
160                    GateType::Z => self.postcompose_pauli(Pauli::Z, data.get_args()[0]),
161                    GateType::XX => self.postcompose_tqe(
162                        Pauli::X,
163                        Pauli::X,
164                        data.get_args()[0],
165                        data.get_args()[1],
166                    ),
167                    GateType::XY => self.postcompose_tqe(
168                        Pauli::X,
169                        Pauli::Y,
170                        data.get_args()[0],
171                        data.get_args()[1],
172                    ),
173                    GateType::XZ => self.postcompose_tqe(
174                        Pauli::X,
175                        Pauli::Z,
176                        data.get_args()[0],
177                        data.get_args()[1],
178                    ),
179                    GateType::YX => self.postcompose_tqe(
180                        Pauli::Y,
181                        Pauli::X,
182                        data.get_args()[0],
183                        data.get_args()[1],
184                    ),
185                    GateType::YY => self.postcompose_tqe(
186                        Pauli::Y,
187                        Pauli::Y,
188                        data.get_args()[0],
189                        data.get_args()[1],
190                    ),
191                    GateType::YZ => self.postcompose_tqe(
192                        Pauli::Y,
193                        Pauli::Z,
194                        data.get_args()[0],
195                        data.get_args()[1],
196                    ),
197                    GateType::ZX => self.postcompose_tqe(
198                        Pauli::Z,
199                        Pauli::X,
200                        data.get_args()[0],
201                        data.get_args()[1],
202                    ),
203                    GateType::ZY => self.postcompose_tqe(
204                        Pauli::Z,
205                        Pauli::Y,
206                        data.get_args()[0],
207                        data.get_args()[1],
208                    ),
209                    GateType::ZZ => self.postcompose_tqe(
210                        Pauli::Z,
211                        Pauli::Z,
212                        data.get_args()[0],
213                        data.get_args()[1],
214                    ),
215                    GateType::SWAP => self.postcompose_swap(data.get_args()[0], data.get_args()[1]),
216                    GateType::RX => postcompose_rotation(
217                        self,
218                        Pauli::X,
219                        data.get_args()[0],
220                        data.get_params()[0],
221                    ),
222                    GateType::RY => postcompose_rotation(
223                        self,
224                        Pauli::Y,
225                        data.get_args()[0],
226                        data.get_params()[0],
227                    ),
228                    GateType::RZ => postcompose_rotation(
229                        self,
230                        Pauli::Z,
231                        data.get_args()[0],
232                        data.get_params()[0],
233                    ),
234                    GateType::ZZPHASE => {
235                        let mut string = vec![Pauli::I; self.get_n_qubits()];
236                        string[data.get_args()[0]] = Pauli::Z;
237                        string[data.get_args()[1]] = Pauli::Z;
238                        self.postcompose_op(&Op::Rotation {
239                            data: (RotationData::new(string, data.get_params()[0])),
240                        })
241                    }
242                    GateType::PHASEDX => {
243                        let alpha = data.get_params()[0];
244                        let beta = data.get_params()[1];
245                        // handle special cases
246                        // if alpha is a multiple of 2pi, then this is identity
247                        if equiv_0(alpha, 2.0) {
248                            return;
249                        }
250                        // if alpha is a multiple of pi and beta is a multiple of pi/4, then this is a Clifford gate
251                        if equiv_0(alpha, 1.0) {
252                            assert!(equiv_0(beta, 0.25), "is_clifford should guarantee this");
253                            postcompose_rotation(self, Pauli::X, data.get_args()[0], alpha);
254                            postcompose_rotation(self, Pauli::Z, data.get_args()[0], 2.0 * beta);
255                            return;
256                        }
257                        // alpha is an odd number of half-pis (i.e. 0.5, 1.5)
258                        // beta can be any clifford angle
259                        let beta_half_pis = cliff_angle(beta).unwrap();
260                        if beta_half_pis == 1 {
261                            // RZ(-0.5);RX(alpha);RZ(0.5) = RY(alpha)
262                            postcompose_rotation(self, Pauli::Y, data.get_args()[0], alpha)
263                        } else if beta_half_pis == 3 {
264                            //  RZ(0.5);RX(alpha);RZ(-0.5) = RY(-alpha)
265                            postcompose_rotation(self, Pauli::Y, data.get_args()[0], -alpha)
266                        } else if beta_half_pis == 0 {
267                            //  RZ(0.0);RX(alpha);RZ(-0.0) = RX(alpha)
268                            postcompose_rotation(self, Pauli::X, data.get_args()[0], alpha)
269                        } else {
270                            //  RZ(1.0);RX(alpha);RZ(-1.0) ~= RX(-alpha)
271                            postcompose_rotation(self, Pauli::X, data.get_args()[0], -alpha)
272                        }
273                    }
274                    _ => panic!("Unexpected gate type: {:?}", data.get_gate_type()),
275                }
276            }
277            Op::Rotation { data } => {
278                let (pauli_z_bits, pauli_x_bits) = paulis_to_u64s(data.get_string());
279                self.postcompose_pauli_gadget(
280                    &pauli_z_bits,
281                    &pauli_x_bits,
282                    cliff_angle(data.get_angle()).expect("Pauli gadget has non clifford angle"),
283                );
284            }
285            Op::Tableau { data } => {
286                self.postcompose_tableau(&data.clone().into());
287            }
288            _ => {
289                panic!("Unexpected operation type: {:?}", op);
290            }
291        }
292    }
293
294    fn precompose_tableau(&mut self, other: &Self) {
295        let mut tab = other.clone();
296        tab.compose(self);
297        *self = tab;
298    }
299
300    fn postcompose_tableau(&mut self, other: &Self) {
301        self.compose(other);
302    }
303
304    fn conjugate_string(&self, paulis: &[Pauli]) -> (Vec<Pauli>, bool) {
305        let (input_z_bits, input_x_bits) = paulis_to_u64s(paulis);
306        let (result_z_bits, result_x_bits, result_sign_bit) =
307            self.apply_to_pauli(&input_z_bits, &input_x_bits);
308        (
309            u64s_to_paulis(&result_z_bits, &result_x_bits, self.get_n_qubits()),
310            result_sign_bit,
311        )
312    }
313}
314
315impl From<TableauData> for Tableau {
316    fn from(data: TableauData) -> Self {
317        let n_qubits = data.get_x_images().len();
318        let mut qubit_slices_z_bits = Vec::with_capacity(n_qubits);
319        let mut qubit_slices_x_bits = Vec::with_capacity(n_qubits);
320        for output_q in 0..n_qubits {
321            let mut slice = vec![Pauli::I; 2 * n_qubits];
322            for input_q in 0..n_qubits {
323                slice[2 * input_q] = data.get_z_images()[input_q].0[output_q];
324                slice[2 * input_q + 1] = data.get_x_images()[input_q].0[output_q];
325            }
326            let (slice_z_bits, slice_x_bits) = paulis_to_u64s(&slice);
327            qubit_slices_z_bits.push(slice_z_bits);
328            qubit_slices_x_bits.push(slice_x_bits);
329        }
330        let mut sign_bits = vec![false; 2 * n_qubits];
331        for input_q in 0..n_qubits {
332            sign_bits[2 * input_q] = data.get_z_images()[input_q].1;
333            sign_bits[2 * input_q + 1] = data.get_x_images()[input_q].1;
334        }
335        Tableau::from_packed_qubit_slices(
336            qubit_slices_z_bits,
337            qubit_slices_x_bits,
338            bools_to_u64_vec(&sign_bits),
339            n_qubits,
340        )
341    }
342}
343
344impl From<Tableau> for TableauData {
345    fn from(tab: Tableau) -> Self {
346        let n_qubits = tab.get_n_qubits();
347        let mut z_images = Vec::with_capacity(n_qubits);
348        let mut x_images = Vec::with_capacity(n_qubits);
349        for input_q in 0..n_qubits {
350            z_images.push(tab.z_image(input_q));
351            x_images.push(tab.x_image(input_q));
352        }
353        TableauData::new(z_images, x_images)
354    }
355}
356
357#[cfg(test)]
358mod tests {
359    use super::*;
360    use rand::{RngExt, SeedableRng};
361    use rstest::rstest;
362    use tk_pg_converter::compare_unitaries_via_tk;
363    use tk_pg_core::{GateData, PauliGraph, TableauData};
364
365    fn random_paulis(length: usize, seed: u64) -> Vec<Pauli> {
366        let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
367        (0..length)
368            .map(|_| match rng.random_range(0..4) {
369                0 => Pauli::I,
370                1 => Pauli::X,
371                2 => Pauli::Y,
372                _ => Pauli::Z,
373            })
374            .collect()
375    }
376
377    #[test]
378    fn test_conversion() {
379        let z_images = vec![
380            (vec![Pauli::X, Pauli::I, Pauli::Z], false),
381            (vec![Pauli::I, Pauli::Y, Pauli::I], true),
382            (vec![Pauli::Z, Pauli::I, Pauli::X], false),
383        ];
384        let x_images = vec![
385            (vec![Pauli::I, Pauli::X, Pauli::I], true),
386            (vec![Pauli::Y, Pauli::I, Pauli::Z], false),
387            (vec![Pauli::I, Pauli::Z, Pauli::I], true),
388        ];
389        let tableau_data = TableauData::new(z_images.clone(), x_images.clone());
390        let qm_tableau: Tableau = tableau_data.into();
391        let converted_back = TableauData::from(qm_tableau);
392        assert_eq!(converted_back.get_z_images(), &z_images);
393        assert_eq!(converted_back.get_x_images(), &x_images);
394    }
395
396    #[test]
397    fn test_identity_tableau_conversion() {
398        let identity_tableau = Tableau::eye(2);
399        let tableau_data: TableauData = identity_tableau.into();
400        assert_eq!(
401            tableau_data.get_z_images(),
402            &vec![
403                (vec![Pauli::Z, Pauli::I], false),
404                (vec![Pauli::I, Pauli::Z], false),
405            ]
406        );
407        assert_eq!(
408            tableau_data.get_x_images(),
409            &vec![
410                (vec![Pauli::X, Pauli::I], false),
411                (vec![Pauli::I, Pauli::X], false),
412            ]
413        );
414    }
415
416    #[test]
417    fn test_random_pg_qm_tableau_round_trip() {
418        for (n_qubits, seed) in [(5, 0), (63, 1), (64, 2), (65, 3)] {
419            let random_tableau = Tableau::random(n_qubits, seed, 20, 20);
420            let tableau_data = TableauData::from(random_tableau.clone());
421            let converted_back: Tableau = tableau_data.into();
422            assert_eq!(
423                random_tableau.qubit_slices_z_bits(),
424                converted_back.qubit_slices_z_bits()
425            );
426            assert_eq!(
427                random_tableau.qubit_slices_x_bits(),
428                converted_back.qubit_slices_x_bits()
429            );
430            assert_eq!(random_tableau.get_n_qubits(), converted_back.get_n_qubits());
431            assert_eq!(
432                random_tableau.get_sign_bits(),
433                converted_back.get_sign_bits()
434            );
435        }
436    }
437    #[test]
438    fn test_conjugation() {
439        let mut tableau = Tableau::eye(2);
440        let input_paulis = vec![Pauli::X, Pauli::Z];
441        let rotation = Op::Rotation {
442            data: RotationData::new(input_paulis.clone(), 0.1),
443        };
444        let results = tableau.conjugate(&rotation);
445        assert_eq!(results.len(), 1);
446        match &results[0] {
447            Op::Rotation { data } => {
448                assert_eq!(data.get_string(), &vec![Pauli::X, Pauli::Z]);
449                assert_eq!(data.get_angle(), 0.1);
450            }
451            _ => panic!("Expected a rotation op"),
452        }
453        // Conjugate by H on the first qubit
454        tableau.precompose_op(&Op::Gate {
455            data: GateData::new(GateType::H, vec![0]),
456        });
457        let results = tableau.conjugate(&rotation);
458        assert_eq!(results.len(), 1);
459        match &results[0] {
460            Op::Rotation { data } => {
461                assert_eq!(data.get_string(), &vec![Pauli::Z, Pauli::Z]);
462                assert_eq!(data.get_angle(), 0.1);
463            }
464            _ => panic!("Expected a rotation op"),
465        }
466    }
467
468    #[test]
469    fn test_identity_tableau() {
470        let tableau = Tableau::eye(2);
471        let z0 = tableau.z_image(0);
472        assert_eq!(z0, (vec![Pauli::Z, Pauli::I], false));
473        let x0 = tableau.x_image(0);
474        assert_eq!(x0, (vec![Pauli::X, Pauli::I], false));
475        let z1 = tableau.z_image(1);
476        assert_eq!(z1, (vec![Pauli::I, Pauli::Z], false));
477        let x1 = tableau.x_image(1);
478        assert_eq!(x1, (vec![Pauli::I, Pauli::X], false));
479    }
480
481    #[rstest]
482    #[case(0.0, 0.0)]
483    #[case(2.0, 1.7)]
484    #[case(0.0, 1.7)]
485    #[case(-2.0, 1.7)]
486    #[case(-1.0, 0.5)]
487    #[case(3.0, 0.25)]
488    #[case(1.0, -0.25)]
489    #[case(0.5, -0.5)]
490    #[case(0.5, 0.0)]
491    #[case(0.5, 1.0)]
492    fn test_postcompose_phasedx(#[case] alpha: f64, #[case] beta: f64) {
493        let op = Op::Gate {
494            data: GateData::new(GateType::PHASEDX, vec![0]).with_params(vec![alpha, beta]),
495        };
496        let mut tab = Tableau::eye(1);
497        tab.postcompose_op(&op);
498        let tab_pg = PauliGraph::new(1).with_ops(vec![Op::Tableau { data: tab.into() }]);
499        let gate_pg = PauliGraph::new(1).with_ops(vec![op]);
500        assert!(
501            compare_unitaries_via_tk(&gate_pg, &tab_pg),
502            "Postcomposition failed for alpha: {}, beta: {}",
503            alpha,
504            beta
505        );
506    }
507
508    #[rstest]
509    #[case(GateType::H, vec![0])]
510    #[case(GateType::X, vec![0])]
511    #[case(GateType::Y, vec![0])]
512    #[case(GateType::Z, vec![0])]
513    #[case(GateType::S, vec![0])]
514    #[case(GateType::Sdg, vec![0])]
515    #[case(GateType::V, vec![0])]
516    #[case(GateType::Vdg, vec![0])]
517    #[case(GateType::XX, vec![0, 1])]
518    #[case(GateType::XY, vec![0, 1])]
519    #[case(GateType::XZ, vec![0, 1])]
520    #[case(GateType::YX, vec![0, 1])]
521    #[case(GateType::YY, vec![0, 1])]
522    #[case(GateType::YZ, vec![0, 1])]
523    #[case(GateType::ZX, vec![0, 1])]
524    #[case(GateType::ZY, vec![0, 1])]
525    #[case(GateType::ZZ, vec![0, 1])]
526    #[case(GateType::SWAP, vec![0, 1])]
527    fn test_tableau_gate_correctness(#[case] gate_type: GateType, #[case] qubits: Vec<usize>) {
528        let op = Op::Gate {
529            data: GateData::new(gate_type.clone(), qubits),
530        };
531        let gate_pg = PauliGraph::new(2).with_ops(vec![op.clone()]);
532        // precompose
533        let mut tab = Tableau::eye(2);
534        tab.precompose_op(&op);
535        let tab_pg = PauliGraph::new(2).with_ops(vec![Op::Tableau { data: tab.into() }]);
536        assert!(
537            compare_unitaries_via_tk(&gate_pg, &tab_pg),
538            "Precomposition failed for gate type: {:?}",
539            gate_type
540        );
541        // postcompose
542        let mut tab = Tableau::eye(2);
543        tab.postcompose_op(&op);
544        let tab_pg = PauliGraph::new(2).with_ops(vec![Op::Tableau { data: tab.into() }]);
545        assert!(
546            compare_unitaries_via_tk(&gate_pg, &tab_pg),
547            "Postcomposition failed for gate type: {:?}",
548            gate_type
549        );
550    }
551
552    #[rstest]
553    #[case(GateType::XX)]
554    #[case(GateType::XY)]
555    #[case(GateType::XZ)]
556    #[case(GateType::YX)]
557    #[case(GateType::YY)]
558    #[case(GateType::YZ)]
559    #[case(GateType::ZX)]
560    #[case(GateType::ZY)]
561    #[case(GateType::ZZ)]
562    fn test_tableau_tqe_precompose_correctness_on_random_tableau(#[case] gate_type: GateType) {
563        let op = Op::Gate {
564            data: GateData::new(gate_type.clone(), vec![0, 1]),
565        };
566        for seed in 0..10 {
567            let mut tab = Tableau::random(2, seed, 10, 10);
568            let random_tab_op = Op::Tableau {
569                data: tab.clone().into(),
570            };
571            let expected_pg = PauliGraph::new(2).with_ops(vec![op.clone(), random_tab_op]);
572
573            tab.precompose_op(&op);
574            let tab_pg = PauliGraph::new(2).with_ops(vec![Op::Tableau { data: tab.into() }]);
575
576            assert!(
577                compare_unitaries_via_tk(&expected_pg, &tab_pg),
578                "Precomposition onto a random tableau failed for gate type: {:?}, seed: {}",
579                gate_type,
580                seed
581            );
582        }
583    }
584
585    #[rstest]
586    #[case(Op::Gate {
587        data: GateData::new(GateType::RX, vec![0]).with_params(vec![0.5]),
588    })]
589    #[case(Op::Gate {
590        data: GateData::new(GateType::RY, vec![1]).with_params(vec![0.5]),
591    })]
592    #[case(Op::Gate {
593        data: GateData::new(GateType::RZ, vec![2]).with_params(vec![0.5]),
594    })]
595    #[case(Op::Gate {
596        data: GateData::new(GateType::ZZPHASE, vec![0, 2]).with_params(vec![0.5]),
597    })]
598    #[case(Op::Gate {
599        data: GateData::new(GateType::PHASEDX, vec![0]).with_params(vec![0.5, 0.5]),
600    })]
601    #[case(Op::Gate {
602        data: GateData::new(GateType::PHASEDX, vec![1]).with_params(vec![3.0, 0.25]),
603    })]
604    #[case(Op::Gate {
605        data: GateData::new(GateType::PHASEDX, vec![2]).with_params(vec![2.0, 1.7]),
606    })]
607    #[case(Op::Rotation {
608        data: RotationData::new(vec![Pauli::X, Pauli::Y, Pauli::Z], 0.5),
609    })]
610    fn test_parameterized_clifford_op_correctness(#[case] op: Op) {
611        let op_pg = PauliGraph::new(3).with_ops(vec![op.clone()]);
612
613        let mut tab = Tableau::eye(3);
614        tab.precompose_op(&op);
615        let tab_pg = PauliGraph::new(3).with_ops(vec![Op::Tableau { data: tab.into() }]);
616        assert!(
617            compare_unitaries_via_tk(&op_pg, &tab_pg),
618            "Precomposition failed for operation: {op:?}"
619        );
620
621        let mut tab = Tableau::eye(3);
622        tab.postcompose_op(&op);
623        let tab_pg = PauliGraph::new(3).with_ops(vec![Op::Tableau { data: tab.into() }]);
624        assert!(
625            compare_unitaries_via_tk(&op_pg, &tab_pg),
626            "Postcomposition failed for operation: {op:?}"
627        );
628    }
629
630    fn panic_message(payload: Box<dyn std::any::Any + Send>) -> String {
631        if let Some(message) = payload.downcast_ref::<String>() {
632            message.clone()
633        } else if let Some(message) = payload.downcast_ref::<&str>() {
634            (*message).to_owned()
635        } else {
636            "non-string panic payload".to_owned()
637        }
638    }
639
640    #[rstest]
641    #[case(Op::Gate {
642        data: GateData::new(GateType::RX, vec![0]).with_params(vec![0.25]),
643    })]
644    #[case(Op::Gate {
645        data: GateData::new(GateType::RY, vec![1]).with_params(vec![0.25]),
646    })]
647    #[case(Op::Gate {
648        data: GateData::new(GateType::RZ, vec![2]).with_params(vec![0.25]),
649    })]
650    #[case(Op::Gate {
651        data: GateData::new(GateType::ZZPHASE, vec![0, 2]).with_params(vec![0.25]),
652    })]
653    #[case(Op::Gate {
654        data: GateData::new(GateType::PHASEDX, vec![1]).with_params(vec![0.5, 0.25]),
655    })]
656    #[case(Op::Rotation {
657        data: RotationData::new(vec![Pauli::X, Pauli::Y, Pauli::Z], 0.25),
658    })]
659    fn test_non_clifford_parameterized_ops_are_rejected(#[case] op: Op) {
660        let mut tab = Tableau::eye(3);
661        let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
662            tab.precompose_op(&op);
663        }))
664        .expect_err("precomposing a non-Clifford operation should panic");
665        assert!(
666            panic_message(panic).contains("Cannot precompose non-Clifford operation"),
667            "unexpected precomposition panic for {op:?}"
668        );
669
670        let mut tab = Tableau::eye(3);
671        let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
672            tab.postcompose_op(&op);
673        }))
674        .expect_err("postcomposing a non-Clifford operation should panic");
675        assert!(
676            panic_message(panic).contains("Cannot postcompose non-Clifford operation"),
677            "unexpected postcomposition panic for {op:?}"
678        );
679    }
680
681    #[test]
682    fn test_conjugation_correctness() {
683        let tab = Tableau::random(5, 0, 100, 100);
684        let tab_op = Op::Tableau {
685            data: tab.clone().into(),
686        };
687        for seed in 0..10 {
688            let paulis = random_paulis(5, seed);
689            let rotation = Op::Rotation {
690                data: RotationData::new(paulis.clone(), 0.1),
691            };
692            let results = tab.conjugate(&rotation);
693            let pg_before = PauliGraph::new(5).with_ops(vec![rotation, tab_op.clone()]);
694            let pg_after = PauliGraph::new(5).with_ops([vec![tab_op.clone()], results].concat());
695            assert!(
696                compare_unitaries_via_tk(&pg_before, &pg_after),
697                "Conjugation failed for paulis: {:?}",
698                paulis
699            );
700        }
701    }
702}