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
7fn 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 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 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 if equiv_0(alpha, 2.0) {
248 return;
249 }
250 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 let beta_half_pis = cliff_angle(beta).unwrap();
260 if beta_half_pis == 1 {
261 postcompose_rotation(self, Pauli::Y, data.get_args()[0], alpha)
263 } else if beta_half_pis == 3 {
264 postcompose_rotation(self, Pauli::Y, data.get_args()[0], -alpha)
266 } else if beta_half_pis == 0 {
267 postcompose_rotation(self, Pauli::X, data.get_args()[0], alpha)
269 } else {
270 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 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 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 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}