1use super::Pauli;
2use crate::kernels::*;
3use crate::u8_encodings::{XX_U8, XY_U8, XZ_U8, YX_U8, YY_U8, YZ_U8, ZX_U8, ZY_U8, ZZ_U8};
4
5#[rustfmt::skip]
9macro_rules! make_slice_sq_gate {
10 ($slice_fn:ident, $gate_fn:ident) => {
11 #[doc = concat!(
12 "Scalar slice version of [`",
13 stringify!($gate_fn),
14 "`], applied in-place.\n\n",
15 "See [`",
16 stringify!($gate_fn),
17 "`] for the Pauli transformation and sign-flip logic."
18 )]
19 pub fn $slice_fn(zs: &mut [u64], xs: &mut [u64], signs: &mut [u64]) {
20 for i in 0..zs.len() {
21 let (new_z, new_x, sign_flip) = $gate_fn(zs[i], xs[i]);
22 zs[i] = new_z;
23 xs[i] = new_x;
24 signs[i] ^= sign_flip;
25 }
26 }
27 };
28}
29
30#[rustfmt::skip]
33macro_rules! make_slice_sq_gate_sign_only {
34 ($slice_fn:ident, $gate_fn:ident) => {
35 #[doc = concat!(
36 "Scalar slice version of [`",
37 stringify!($gate_fn),
38 "`], applied in-place.\n\n",
39 "See [`",
40 stringify!($gate_fn),
41 "`] for the sign-flip logic."
42 )]
43 pub fn $slice_fn(zs: &[u64], xs: &[u64], signs: &mut [u64]) {
44 for i in 0..zs.len() {
45 signs[i] ^= $gate_fn(zs[i], xs[i]);
46 }
47 }
48 };
49}
50
51#[rustfmt::skip]
54macro_rules! make_slice_tq_gate {
55 ($slice_fn:ident, $gate_fn:ident) => {
56 #[doc = concat!(
57 "Scalar slice version of [`",
58 stringify!($gate_fn),
59 "`], applied in-place.\n\n",
60 "See [`",
61 stringify!($gate_fn),
62 "`] for the Pauli transformation and sign-flip logic."
63 )]
64 pub fn $slice_fn(
65 zs0: &mut [u64],
66 xs0: &mut [u64],
67 zs1: &mut [u64],
68 xs1: &mut [u64],
69 signs: &mut [u64],
70 ) {
71 for i in 0..zs0.len() {
72 let (new_z0, new_x0, new_z1, new_x1, sign_flip) =
73 $gate_fn(zs0[i], xs0[i], zs1[i], xs1[i]);
74 zs0[i] = new_z0;
75 xs0[i] = new_x0;
76 zs1[i] = new_z1;
77 xs1[i] = new_x1;
78 signs[i] ^= sign_flip;
79 }
80 }
81 };
82}
83
84make_slice_sq_gate!(slice_h_gate, h_gate);
85make_slice_sq_gate!(slice_s_gate, s_gate);
86make_slice_sq_gate!(slice_sdg_gate, sdg_gate);
87make_slice_sq_gate!(slice_v_gate, v_gate);
88make_slice_sq_gate!(slice_vdg_gate, vdg_gate);
89make_slice_sq_gate!(slice_ry90_gate, ry90_gate);
90make_slice_sq_gate!(slice_ry270_gate, ry270_gate);
91make_slice_sq_gate!(slice_rz90_gate, rz90_gate);
92make_slice_sq_gate!(slice_rz270_gate, rz270_gate);
93make_slice_sq_gate!(slice_rx90_gate, rx90_gate);
94make_slice_sq_gate!(slice_rx270_gate, rx270_gate);
95
96make_slice_sq_gate_sign_only!(slice_x_gate, x_gate);
97make_slice_sq_gate_sign_only!(slice_y_gate, y_gate);
98make_slice_sq_gate_sign_only!(slice_z_gate, z_gate);
99
100make_slice_tq_gate!(slice_xx_gate, xx_gate);
101make_slice_tq_gate!(slice_xy_gate, xy_gate);
102make_slice_tq_gate!(slice_xz_gate, xz_gate);
103make_slice_tq_gate!(slice_yy_gate, yy_gate);
104make_slice_tq_gate!(slice_yz_gate, yz_gate);
105make_slice_tq_gate!(slice_zz_gate, zz_gate);
106
107pub fn apply_enum_tqe_slice(
120 zs0: &mut [u64],
121 xs0: &mut [u64],
122 zs1: &mut [u64],
123 xs1: &mut [u64],
124 signs: &mut [u64],
125 g0: Pauli,
126 g1: Pauli,
127) {
128 match (g0, g1) {
129 (Pauli::X, Pauli::X) => slice_xx_gate(zs0, xs0, zs1, xs1, signs),
130 (Pauli::X, Pauli::Y) => slice_xy_gate(zs0, xs0, zs1, xs1, signs),
131 (Pauli::X, Pauli::Z) => slice_xz_gate(zs0, xs0, zs1, xs1, signs),
132 (Pauli::Y, Pauli::X) => slice_xy_gate(zs1, xs1, zs0, xs0, signs),
133 (Pauli::Y, Pauli::Y) => slice_yy_gate(zs0, xs0, zs1, xs1, signs),
134 (Pauli::Y, Pauli::Z) => slice_yz_gate(zs0, xs0, zs1, xs1, signs),
135 (Pauli::Z, Pauli::X) => slice_xz_gate(zs1, xs1, zs0, xs0, signs),
136 (Pauli::Z, Pauli::Y) => slice_yz_gate(zs1, xs1, zs0, xs0, signs),
137 (Pauli::Z, Pauli::Z) => slice_zz_gate(zs0, xs0, zs1, xs1, signs),
138 _ => panic!("Invalid TQE gate"),
139 }
140}
141
142pub fn apply_half_pi_gate_slice(
153 zs: &mut [u64],
154 xs: &mut [u64],
155 signs: &mut [u64],
156 axis: Pauli,
157 neg: bool,
158) {
159 match (axis, neg) {
160 (Pauli::X, false) => slice_rx90_gate(zs, xs, signs),
161 (Pauli::X, true) => slice_rx270_gate(zs, xs, signs),
162 (Pauli::Y, false) => slice_ry90_gate(zs, xs, signs),
163 (Pauli::Y, true) => slice_ry270_gate(zs, xs, signs),
164 (Pauli::Z, false) => slice_rz90_gate(zs, xs, signs),
165 (Pauli::Z, true) => slice_rz270_gate(zs, xs, signs),
166 _ => panic!("Invalid axis"),
167 }
168}
169
170pub fn apply_u8_tqe_slice(
193 zs0: &mut [u64],
194 xs0: &mut [u64],
195 zs1: &mut [u64],
196 xs1: &mut [u64],
197 signs: &mut [u64],
198 gate: u8,
199) {
200 match gate {
201 XX_U8 => slice_xx_gate(zs0, xs0, zs1, xs1, signs),
202 XY_U8 => slice_xy_gate(zs0, xs0, zs1, xs1, signs),
203 XZ_U8 => slice_xz_gate(zs0, xs0, zs1, xs1, signs),
204 YX_U8 => slice_xy_gate(zs1, xs1, zs0, xs0, signs),
205 YY_U8 => slice_yy_gate(zs0, xs0, zs1, xs1, signs),
206 YZ_U8 => slice_yz_gate(zs0, xs0, zs1, xs1, signs),
207 ZX_U8 => slice_xz_gate(zs1, xs1, zs0, xs0, signs),
208 ZY_U8 => slice_yz_gate(zs1, xs1, zs0, xs0, signs),
209 ZZ_U8 => slice_zz_gate(zs0, xs0, zs1, xs1, signs),
210 _ => panic!("Invalid TQE gate"),
211 }
212}
213
214#[cfg(test)]
215pub(crate) mod tests {
216 use super::*;
217 use crate::kernels::tests::*;
218 use crate::test_utils::*;
219 use crate::{paulis_to_u64s, u64s_to_paulis, u64s_to_sign_flips};
220 use rstest::rstest;
221
222 pub(crate) type SliceSqGateFn = fn(&mut [u64], &mut [u64], &mut [u64]);
223 pub(crate) type SlicePauliGateFn = fn(&[u64], &[u64], &mut [u64]);
224 pub(crate) type SliceTqeGateFn = fn(&mut [u64], &mut [u64], &mut [u64], &mut [u64], &mut [u64]);
225
226 pub(crate) fn slice_sq_gate_fn(name: &str) -> SliceSqGateFn {
227 match name {
228 "H" => slice_h_gate,
229 "S" => slice_s_gate,
230 "SDG" => slice_sdg_gate,
231 "V" => slice_v_gate,
232 "VDG" => slice_vdg_gate,
233 "RX90" => slice_rx90_gate,
234 "RX270" => slice_rx270_gate,
235 "RY90" => slice_ry90_gate,
236 "RY270" => slice_ry270_gate,
237 "RZ90" => slice_rz90_gate,
238 "RZ270" => slice_rz270_gate,
239 _ => panic!("Invalid gate name"),
240 }
241 }
242
243 pub(crate) fn slice_pauli_gate_fn(name: &str) -> SlicePauliGateFn {
244 match name {
245 "X" => slice_x_gate,
246 "Y" => slice_y_gate,
247 "Z" => slice_z_gate,
248 _ => panic!("Invalid gate name"),
249 }
250 }
251
252 pub(crate) fn slice_tq_gate_fn(name: &str) -> SliceTqeGateFn {
253 match name {
254 "XX" => slice_xx_gate,
255 "XY" => slice_xy_gate,
256 "XZ" => slice_xz_gate,
257 "YY" => slice_yy_gate,
258 "YZ" => slice_yz_gate,
259 "ZZ" => slice_zz_gate,
260 _ => panic!("Invalid gate name"),
261 }
262 }
263
264 #[rstest]
266 #[case(300, 0)]
267 #[case(5, 1)]
268 fn test_slice_sq_gates(#[case] n_paulis: usize, #[case] seed: u64) {
269 let paulis = random_paulis(n_paulis, seed);
270 let (zs, xs) = paulis_to_u64s(&paulis);
271
272 for gate in SQ_GATES.iter() {
273 let gate_func = slice_sq_gate_fn(gate);
274 let mut zs_clone = zs.clone();
275 let mut xs_clone = xs.clone();
276 let mut signs: Vec<u64> = vec![0; zs.len()];
277 gate_func(&mut zs_clone, &mut xs_clone, &mut signs);
278 let new_paulis = u64s_to_paulis(&zs_clone, &xs_clone, paulis.len());
279 let new_signs = u64s_to_sign_flips(&signs, paulis.len());
280 let bool_gate_fn = sq_gate_fn(gate);
282 let mut expected_paulis = Vec::with_capacity(paulis.len());
283 let mut expected_signs: Vec<bool> = Vec::with_capacity(paulis.len());
284 for p in paulis.iter() {
285 let (z, x) = pauli_to_bits(p);
286 let (new_z, new_x, sign_flip) = bool_gate_fn(z, x);
287 let p_prime = bits_to_pauli(new_z, new_x);
288 expected_paulis.push(p_prime);
289 expected_signs.push(sign_flip);
290 }
291 assert_eq!(new_paulis, expected_paulis);
292 assert_eq!(new_signs, expected_signs);
293 }
294 }
295
296 #[rstest]
297 #[case(300, 0)]
298 #[case(5, 1)]
299 fn test_slice_pauli_gates(#[case] n_paulis: usize, #[case] seed: u64) {
300 let paulis = random_paulis(n_paulis, seed);
301 let (zs, xs) = paulis_to_u64s(&paulis);
302
303 for gate in PAULI_GATES.iter() {
304 let gate_func = slice_pauli_gate_fn(gate);
305 let mut signs: Vec<u64> = vec![0; zs.len()];
306 gate_func(&zs, &xs, &mut signs);
307 let new_signs = u64s_to_sign_flips(&signs, paulis.len());
308 let bool_gate_fn = pauli_gate_fn(gate);
310 let mut expected_signs: Vec<bool> = Vec::with_capacity(paulis.len());
311 for p in paulis.iter() {
312 let (z, x) = pauli_to_bits(p);
313 let sign_flip = bool_gate_fn(z, x);
314 expected_signs.push(sign_flip);
315 }
316 assert_eq!(new_signs, expected_signs);
317 }
318 }
319
320 #[rstest]
321 #[case(300, 0, 1)]
322 #[case(5, 1, 2)]
323 fn test_slice_tq_gates(#[case] n_paulis: usize, #[case] seed0: u64, #[case] seed1: u64) {
324 let paulis0 = random_paulis(n_paulis, seed0);
325 let (zs0, xs0) = paulis_to_u64s(&paulis0);
326 let paulis1 = random_paulis(n_paulis, seed1);
327 let (zs1, xs1) = paulis_to_u64s(&paulis1);
328
329 for gate in TQ_GATES.iter() {
330 let gate_func = slice_tq_gate_fn(gate);
331 let mut zs0_clone = zs0.clone();
332 let mut xs0_clone = xs0.clone();
333 let mut zs1_clone = zs1.clone();
334 let mut xs1_clone = xs1.clone();
335 let mut signs: Vec<u64> = vec![0; zs0.len()];
336 gate_func(
337 &mut zs0_clone,
338 &mut xs0_clone,
339 &mut zs1_clone,
340 &mut xs1_clone,
341 &mut signs,
342 );
343 let new_paulis0 = u64s_to_paulis(&zs0_clone, &xs0_clone, paulis0.len());
344 let new_paulis1 = u64s_to_paulis(&zs1_clone, &xs1_clone, paulis1.len());
345 let new_signs = u64s_to_sign_flips(&signs, paulis0.len());
346 let bool_gate_fn = tq_gate_fn(gate);
348 let mut expected_signs: Vec<bool> = Vec::with_capacity(paulis0.len());
349 let mut expected_paulis0: Vec<Pauli> = Vec::with_capacity(paulis0.len());
350 let mut expected_paulis1: Vec<Pauli> = Vec::with_capacity(paulis1.len());
351 for (p0, p1) in paulis0.iter().zip(paulis1.iter()) {
352 let (z0, x0) = pauli_to_bits(p0);
353 let (z1, x1) = pauli_to_bits(p1);
354 let (new_z0, new_x0, new_z1, new_x1, sign_flip) = bool_gate_fn(z0, x0, z1, x1);
355 expected_paulis0.push(bits_to_pauli(new_z0, new_x0));
356 expected_paulis1.push(bits_to_pauli(new_z1, new_x1));
357 expected_signs.push(sign_flip);
358 }
359 assert_eq!(new_paulis0, expected_paulis0);
360 assert_eq!(new_paulis1, expected_paulis1);
361 assert_eq!(new_signs, expected_signs);
362 }
363 }
364
365 pub(crate) fn tq_wrapper_cases() -> [(Pauli, Pauli, u8, SliceTqeGateFn, bool); 9] {
368 [
369 (Pauli::X, Pauli::X, XX_U8, slice_xx_gate, false),
370 (Pauli::X, Pauli::Y, XY_U8, slice_xy_gate, false),
371 (Pauli::X, Pauli::Z, XZ_U8, slice_xz_gate, false),
372 (Pauli::Y, Pauli::X, YX_U8, slice_xy_gate, true),
373 (Pauli::Y, Pauli::Y, YY_U8, slice_yy_gate, false),
374 (Pauli::Y, Pauli::Z, YZ_U8, slice_yz_gate, false),
375 (Pauli::Z, Pauli::X, ZX_U8, slice_xz_gate, true),
376 (Pauli::Z, Pauli::Y, ZY_U8, slice_yz_gate, true),
377 (Pauli::Z, Pauli::Z, ZZ_U8, slice_zz_gate, false),
378 ]
379 }
380
381 pub(crate) fn half_pi_wrapper_cases() -> [(Pauli, bool, SliceSqGateFn); 6] {
382 [
383 (Pauli::X, false, slice_rx90_gate),
384 (Pauli::X, true, slice_rx270_gate),
385 (Pauli::Y, false, slice_ry90_gate),
386 (Pauli::Y, true, slice_ry270_gate),
387 (Pauli::Z, false, slice_rz90_gate),
388 (Pauli::Z, true, slice_rz270_gate),
389 ]
390 }
391
392 pub(crate) fn apply_tq_reference(
393 gate_func: SliceTqeGateFn,
394 swapped: bool,
395 zs0: &mut [u64],
396 xs0: &mut [u64],
397 zs1: &mut [u64],
398 xs1: &mut [u64],
399 signs: &mut [u64],
400 ) {
401 if swapped {
402 gate_func(zs1, xs1, zs0, xs0, signs);
403 } else {
404 gate_func(zs0, xs0, zs1, xs1, signs);
405 }
406 }
407
408 #[rstest]
409 #[case(5, 0)]
410 #[case(64, 1)]
411 #[case(130, 2)]
412 fn test_tqe_wrapper_dispatch_slice(#[case] len: usize, #[case] seed: u64) {
413 for (g0, g1, gate, reference_func, swapped) in tq_wrapper_cases() {
414 let base = (
415 random_u64s(len, seed),
416 random_u64s(len, seed + 1),
417 random_u64s(len, seed + 2),
418 random_u64s(len, seed + 3),
419 random_u64s(len, seed + 4),
420 );
421 let (
422 mut expected_zs0,
423 mut expected_xs0,
424 mut expected_zs1,
425 mut expected_xs1,
426 mut expected_signs,
427 ) = base.clone();
428 let (mut enum_zs0, mut enum_xs0, mut enum_zs1, mut enum_xs1, mut enum_signs) =
429 base.clone();
430 let (mut u8_zs0, mut u8_xs0, mut u8_zs1, mut u8_xs1, mut u8_signs) = base;
431
432 apply_tq_reference(
433 reference_func,
434 swapped,
435 &mut expected_zs0,
436 &mut expected_xs0,
437 &mut expected_zs1,
438 &mut expected_xs1,
439 &mut expected_signs,
440 );
441 apply_enum_tqe_slice(
442 &mut enum_zs0,
443 &mut enum_xs0,
444 &mut enum_zs1,
445 &mut enum_xs1,
446 &mut enum_signs,
447 g0,
448 g1,
449 );
450 apply_u8_tqe_slice(
451 &mut u8_zs0,
452 &mut u8_xs0,
453 &mut u8_zs1,
454 &mut u8_xs1,
455 &mut u8_signs,
456 gate,
457 );
458
459 let expected = (
460 expected_zs0.as_slice(),
461 expected_xs0.as_slice(),
462 expected_zs1.as_slice(),
463 expected_xs1.as_slice(),
464 expected_signs.as_slice(),
465 );
466 assert_eq!(
467 (
468 enum_zs0.as_slice(),
469 enum_xs0.as_slice(),
470 enum_zs1.as_slice(),
471 enum_xs1.as_slice(),
472 enum_signs.as_slice(),
473 ),
474 expected
475 );
476 assert_eq!(
477 (
478 u8_zs0.as_slice(),
479 u8_xs0.as_slice(),
480 u8_zs1.as_slice(),
481 u8_xs1.as_slice(),
482 u8_signs.as_slice(),
483 ),
484 expected
485 );
486 }
487 }
488
489 #[rstest]
490 #[case(5, 0)]
491 #[case(64, 1)]
492 #[case(130, 2)]
493 fn test_half_pi_wrapper_dispatch_slice(#[case] len: usize, #[case] seed: u64) {
494 for (axis, neg, reference_func) in half_pi_wrapper_cases() {
495 let base = (
496 random_u64s(len, seed),
497 random_u64s(len, seed + 1),
498 random_u64s(len, seed + 2),
499 );
500 let (mut expected_zs, mut expected_xs, mut expected_signs) = base.clone();
501 let (mut wrapper_zs, mut wrapper_xs, mut wrapper_signs) = base;
502
503 reference_func(&mut expected_zs, &mut expected_xs, &mut expected_signs);
504 apply_half_pi_gate_slice(
505 &mut wrapper_zs,
506 &mut wrapper_xs,
507 &mut wrapper_signs,
508 axis,
509 neg,
510 );
511
512 assert_eq!(wrapper_zs, expected_zs);
513 assert_eq!(wrapper_xs, expected_xs);
514 assert_eq!(wrapper_signs, expected_signs);
515 }
516 }
517}