autotune: specialize PauliSum single-qubit Clifford and rotation gate closures to operate directly on raw xbit/zbit instead of round-tripping through PhasedPauliWord and Pauli enums

Both files look correct. The `PauliWordTrait` import in `clifford.rs` is needed but since `use crate::traits::*` is already used in `rot1.rs`, let me verify the import chain for `clifford.rs` — we import `PauliWordTrait` explicitly in the traits list, which is correct for calling `get_xbit`/`get_zbit`/`get_lbit`/`set_xbit`/`set_zbit`/`rehash`.

The implementation is complete and correct:

- **`clifford.rs`**: `x`/`y`/`z` now use `scale` with direct bit reads (no clone, no PhasedPauliWord); `h`/`s` and all `CliffordExtensions` single-qubit gates use `map_add` with direct bit manipulation, skipping the `PhasedPauliWord` round-trip and generic Clifford dispatch. Two-qubit gates (`cnot`, `cz`, `cy`) retain the existing macro path.

- **`rot1.rs`**: `rotate_1_map_insert_closure` now reads bits directly (`get_lbit`/`get_xbit`/`get_zbit`) instead of calling `k.get()` which constructs a `Pauli` enum. The `RotationOne` impl adds specialized `rx`/`ry`/`rz` overrides that skip `levi_civita` entirely, using hardcoded bit formulas for commutation and sign derived from the known axis.

SUMMARY: specialize PauliSum single-qubit Clifford and rotation gate closures to operate directly on raw xbit/zbit instead of round-tripping through PhasedPauliWord and Pauli enums

Author: Roger-luo

crates/ppvm-runtime/src/sum/clifford.rs

@@ -2,24 +2,10 @@ use crate::{
     config::Config,
     phase::PhasedPauliWord,
     sum::PauliSum,
-    traits::{Clifford, CliffordExtensions, PauliStorage},
+    traits::{Clifford, CliffordExtensions, PauliStorage, PauliWordTrait},
 };
 use std::hash::BuildHasher;
 
-macro_rules! map_scale {
-    ($name:ident, $($index:ident),*) => {
-        fn $name(&mut self, $($index: usize),*) {
-            self.scale(|k, v| {
-                let mut p: PhasedPauliWord<T::Storage, T::BuildHasher, <T as Config>::PauliWordType> = k.clone().into();
-                p.$name($($index),*);
-                if !p.is_positive() {
-                    *v *= -1.0;
-                }
-            })
-        }
-    };
-}
-
 macro_rules! map_word {
     ($name:ident, $($index:ident),*) => {
         fn $name(&mut self, $($index: usize),*) {
@@ -44,11 +30,77 @@ where
     T: Config<Storage = S, BuildHasher = H>,
     T::PauliWordType: Clifford,
 {
-    map_scale!(x, index);
-    map_scale!(y, index);
-    map_scale!(z, index);
-    map_word!(h, index);
-    map_word!(s, index);
+    #[inline]
+    fn x(&mut self, index: usize) {
+        // X conjugation: only flips sign for Z and Y (zbit set); word unchanged
+        self.scale(|k, v| {
+            if !k.get_lbit(index) && k.get_zbit(index) {
+                *v *= -1.0;
+            }
+        })
+    }
+
+    #[inline]
+    fn y(&mut self, index: usize) {
+        // Y conjugation: flips sign for X and Z (xbit XOR zbit); word unchanged
+        self.scale(|k, v| {
+            if !k.get_lbit(index) && (k.get_xbit(index) ^ k.get_zbit(index)) {
+                *v *= -1.0;
+            }
+        })
+    }
+
+    #[inline]
+    fn z(&mut self, index: usize) {
+        // Z conjugation: only flips sign for X and Y (xbit set); word unchanged
+        self.scale(|k, v| {
+            if !k.get_lbit(index) && k.get_xbit(index) {
+                *v *= -1.0;
+            }
+        })
+    }
+
+    #[inline]
+    fn h(&mut self, index: usize) {
+        // H swaps x and z bits; phase flip only for Y (both bits set)
+        self.map_add(|k, v| {
+            if k.get_lbit(index) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(index);
+            let zbit = k.get_zbit(index);
+            let mut new_word = k.clone();
+            new_word.set_xbit(index, zbit);
+            new_word.set_zbit(index, xbit);
+            new_word.rehash();
+            if xbit & zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
+    #[inline]
+    fn s(&mut self, index: usize) {
+        // S: zbit = xbit XOR zbit; phase flip only for X (xbit set, zbit clear)
+        self.map_add(|k, v| {
+            if k.get_lbit(index) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(index);
+            let zbit = k.get_zbit(index);
+            let mut new_word = k.clone();
+            new_word.set_zbit(index, xbit ^ zbit);
+            new_word.rehash();
+            if xbit & !zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
     map_word!(cnot, a, b);
     map_word!(cz, a, b);
 }
@@ -60,10 +112,107 @@ where
     T: Config<Storage = S, BuildHasher = H>,
     T::PauliWordType: Clifford + CliffordExtensions,
 {
-    map_word!(s_adj, index);
-    map_word!(sqrt_x, index);
-    map_word!(sqrt_y, index);
-    map_word!(sqrt_x_adj, index);
-    map_word!(sqrt_y_adj, index);
+    #[inline]
+    fn s_adj(&mut self, addr0: usize) {
+        // S†: same bit map as S; phase flip for Y (both bits set)
+        self.map_add(|k, v| {
+            if k.get_lbit(addr0) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            let mut new_word = k.clone();
+            new_word.set_zbit(addr0, xbit ^ zbit);
+            new_word.rehash();
+            if xbit & zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
+    #[inline]
+    fn sqrt_x(&mut self, addr0: usize) {
+        // √X: xbit = xbit XOR zbit; phase flip for Y (both bits set)
+        self.map_add(|k, v| {
+            if k.get_lbit(addr0) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, xbit ^ zbit);
+            new_word.rehash();
+            if xbit & zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
+    #[inline]
+    fn sqrt_y(&mut self, addr0: usize) {
+        // √Y: swap x and z bits; phase flip for Z (zbit set, xbit clear)
+        self.map_add(|k, v| {
+            if k.get_lbit(addr0) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, zbit);
+            new_word.set_zbit(addr0, xbit);
+            new_word.rehash();
+            if !xbit & zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
+    #[inline]
+    fn sqrt_x_adj(&mut self, addr0: usize) {
+        // √X†: xbit = xbit XOR zbit; phase flip for Z (zbit set, xbit clear)
+        self.map_add(|k, v| {
+            if k.get_lbit(addr0) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, xbit ^ zbit);
+            new_word.rehash();
+            if !xbit & zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
+    #[inline]
+    fn sqrt_y_adj(&mut self, addr0: usize) {
+        // √Y†: swap x and z bits; phase flip for X (xbit set, zbit clear)
+        self.map_add(|k, v| {
+            if k.get_lbit(addr0) {
+                return (k.clone(), v.clone());
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, zbit);
+            new_word.set_zbit(addr0, xbit);
+            new_word.rehash();
+            if xbit & !zbit {
+                (new_word, -v.clone())
+            } else {
+                (new_word, v.clone())
+            }
+        })
+    }
+
     map_word!(cy, a, b);
 }

crates/ppvm-runtime/src/sum/rot1.rs

@@ -9,15 +9,18 @@ pub(crate) fn rotate_1_map_insert_closure<T: Config>(
     sin: &T::Coeff,
     cos: &T::Coeff,
 ) -> Option<(T::PauliWordType, T::Coeff)> {
-    let p_g = k.get(addr0);
     if axis == Pauli::L {
         panic!("Rotation axis cannot be L");
     }
-    if p_g == Pauli::L {
-        // Rotation does nothing on lost qubits
+    // Check loss first — avoids reading xbit/zbit on lost qubits
+    if k.get_lbit(addr0) {
         return None;
     }
-    let (eps, p_q) = levi_civita(p_g as u8, axis as u8);
+    let xbit = k.get_xbit(addr0);
+    let zbit = k.get_zbit(addr0);
+    // Reconstruct 2-bit Pauli code (I=00, X=01, Z=10, Y=11) from bits
+    let p_g = (zbit as u8) << 1 | (xbit as u8);
+    let (eps, p_q) = levi_civita(p_g, axis as u8);
     if eps == 0 {
         None
     } else {
@@ -45,6 +48,82 @@ where
         let (sin, cos) = theta.sin_cos();
         self.map_insert(|k, v| rotate_1_map_insert_closure::<T>(k, v, axis, addr0, &sin, &cos));
     }
+
+    #[inline]
+    fn rx(&mut self, addr0: usize, theta: impl Into<T::Coeff>) {
+        // Axis = X (xbit=1, zbit=0). Commutes when zbit==false (I or X).
+        // Anticommuting: Z(xbit=0)→new Y, eps=+1; Y(xbit=1)→new Z, eps=-1
+        let (sin, cos) = theta.into().sin_cos();
+        self.map_insert(|k, v| {
+            if k.get_lbit(addr0) {
+                return None;
+            }
+            let zbit = k.get_zbit(addr0);
+            if !zbit {
+                return None;
+            }
+            let xbit = k.get_xbit(addr0);
+            let mut coeff = v.clone();
+            *v *= cos.clone();
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, !xbit);
+            new_word.rehash();
+            let eps: i8 = if xbit { -1 } else { 1 };
+            coeff *= sin.mul_sign(eps);
+            Some((new_word, coeff))
+        });
+    }
+
+    #[inline]
+    fn ry(&mut self, addr0: usize, theta: impl Into<T::Coeff>) {
+        // Axis = Y (xbit=1, zbit=1). Commutes when xbit==zbit (I or Y).
+        // Anticommuting: X(zbit=0)→new Z, eps=+1; Z(zbit=1)→new X, eps=-1
+        let (sin, cos) = theta.into().sin_cos();
+        self.map_insert(|k, v| {
+            if k.get_lbit(addr0) {
+                return None;
+            }
+            let xbit = k.get_xbit(addr0);
+            let zbit = k.get_zbit(addr0);
+            if xbit == zbit {
+                return None;
+            }
+            let mut coeff = v.clone();
+            *v *= cos.clone();
+            let mut new_word = k.clone();
+            new_word.set_xbit(addr0, !xbit);
+            new_word.set_zbit(addr0, !zbit);
+            new_word.rehash();
+            let eps: i8 = if zbit { -1 } else { 1 };
+            coeff *= sin.mul_sign(eps);
+            Some((new_word, coeff))
+        });
+    }
+
+    #[inline]
+    fn rz(&mut self, addr0: usize, theta: impl Into<T::Coeff>) {
+        // Axis = Z (xbit=0, zbit=1). Commutes when xbit==false (I or Z).
+        // Anticommuting: X(zbit=0)→new Y, eps=-1; Y(zbit=1)→new X, eps=+1
+        let (sin, cos) = theta.into().sin_cos();
+        self.map_insert(|k, v| {
+            if k.get_lbit(addr0) {
+                return None;
+            }
+            let xbit = k.get_xbit(addr0);
+            if !xbit {
+                return None;
+            }
+            let zbit = k.get_zbit(addr0);
+            let mut coeff = v.clone();
+            *v *= cos.clone();
+            let mut new_word = k.clone();
+            new_word.set_zbit(addr0, !zbit);
+            new_word.rehash();
+            let eps: i8 = if zbit { 1 } else { -1 };
+            coeff *= sin.mul_sign(eps);
+            Some((new_word, coeff))
+        });
+    }
 }
 
 /// 2-bit Pauli code: 00 I, 01 X, 10 Z, 11 Y