Skip to main content

tk_pg_bitpacked/
slice.rs

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// ------------ 1Q Clifford gates that mutate the Pauli operators --------------
6
7// skip fmt due to a bug: https://github.com/rust-lang/rustfmt/issues/5489
8#[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// --- 1Q Clifford gates that only mutate the sign bits (i.e. Pauli gates) -----
31
32#[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// ---------------------------- 2Q Clifford gates ------------------------------
52
53#[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
107/// Apply TQE gate where the gate type is encoded in two Pauli enums.
108///
109/// # Arguments
110///
111/// - `zs0` (`&mut [u64]`) - z bits on the first qubit.
112/// - `xs0` (`&mut [u64]`) - x bits on the first qubit.
113/// - `zs1` (`&mut [u64]`) - z bits on the second qubit.
114/// - `xs1` (`&mut [u64]`) - x bits on the second qubit.
115/// - `signs` (`&mut [u64]`) - sign bits for the qubits.
116/// - `g0` (`Pauli`) -  Pauli on the first qubit.
117/// - `g1` (`Pauli`) -  Pauli on the second qubit.
118///
119pub 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
142/// Apply half pi Pauli rotation gate
143///
144/// # Arguments
145///
146/// - `zs` (`&mut [u64]`) - z bits.
147/// - `xs` (`&mut [u64]`) - x bits.
148/// - `signs` (`&mut [u64]`) - sign bits.
149/// - `axis` (`Pauli`) - rotation axis.
150/// - `neg` (`bool`) - whether the angle is negative. You should use this to apply the inverse of the gate.
151///
152pub 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
170/// Apply TQE gate where the gate type is encoded in a u8.
171///
172/// The encoding is as follows:
173/// - 0: XX
174/// - 1: XY
175/// - 2: XZ
176/// - 3: YX
177/// - 4: YY
178/// - 5: YZ
179/// - 6: ZX
180/// - 7: ZY
181/// - 8: ZZ
182///
183/// # Arguments
184///
185/// - `zs0` (`&mut [u64]`) -  z bits on the first qubit.
186/// - `xs0` (`&mut [u64]`) -  x bits on the first qubit.
187/// - `zs1` (`&mut [u64]`) -  z bits on the second qubit.
188/// - `xs1` (`&mut [u64]`) -  x bits on the second qubit.
189/// - `signs` (`&mut [u64]`) -  sign bits for the qubits.
190/// - `gate` (`u8`) -  the encoded gate type.
191///
192pub 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    // ------------------------ Test conjugation for [u64] --------------------------
265    #[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            // compute the expected result using the boolean function
281            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            // compute the expected result using the boolean function
309            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            // compute the expected result using the boolean function
347            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    // ---------------------------- Test dispatching -------------------------------
366
367    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}