Add local Pauli matrix helper for PauliProductRotation

Author: Adithyaphani

crates/circuit/src/gate_matrix.rs

@@ -16,7 +16,6 @@ use std::f64::consts::FRAC_1_SQRT_2;
 // Ensure necessary imports are present
 use ndarray::Array2;
 
-
 use crate::util::{
     C_M_ONE, C_ONE, C_ZERO, GateArray0Q, GateArray1Q, GateArray2Q, GateArray3Q, GateArray4Q, IM,
     M_IM, c64,
@@ -531,63 +530,55 @@ pub fn xx_plus_yy_gate(theta: f64, beta: f64) -> GateArray2Q {
 ///
 /// # Returns
 /// Dense 2^n × 2^n complex unitary matrix as `Array2<Complex64>`
-pub fn pauli_product_rotation_matrix(
-    angle: f64,
-    z: &[bool],
-    x: &[bool],
-) -> Array2<Complex64> {
 
-    let n = z.len();
-    let dim = 1usize << n;
+pub fn pauli_zx_to_dense_matrix(z: &[bool], x: &[bool]) -> Array2<Complex64> {
+    assert_eq!(z.len(), x.len());
 
     let pauli_i = Array2::from_shape_vec(
         (2, 2),
-        vec![c64(1.,0.), c64(0.,0.), c64(0.,0.), c64(1.,0.)],
-    ).unwrap();
+        vec![c64(1., 0.), c64(0., 0.), c64(0., 0.), c64(1., 0.)],
+    )
+    .unwrap();
     let pauli_x = Array2::from_shape_vec(
         (2, 2),
-        vec![c64(0.,0.), c64(1.,0.), c64(1.,0.), c64(0.,0.)],
-    ).unwrap();
+        vec![c64(0., 0.), c64(1., 0.), c64(1., 0.), c64(0., 0.)],
+    )
+    .unwrap();
     let pauli_y = Array2::from_shape_vec(
         (2, 2),
-        vec![c64(0.,0.), c64(0.,-1.), c64(0.,1.), c64(0.,0.)],
-    ).unwrap();
+        vec![c64(0., 0.), c64(0., -1.), c64(0., 1.), c64(0., 0.)],
+    )
+    .unwrap();
     let pauli_z = Array2::from_shape_vec(
         (2, 2),
-        vec![c64(1.,0.), c64(0.,0.), c64(0.,0.), c64(-1.,0.)],
-    ).unwrap();
-
-    // Build full tensor product using z/x symplectic representation:
-    // z=false x=false → I
-    // z=false x=true  → X
-    // z=true  x=true  → Y
-    // z=true  x=false → Z
-    let first = match (z[0], x[0]) {
+        vec![c64(1., 0.), c64(0., 0.), c64(0., 0.), c64(-1., 0.)],
+    )
+    .unwrap();
+
+    let single_pauli = |z_bit: bool, x_bit: bool| match (z_bit, x_bit) {
         (false, false) => pauli_i.clone(),
-        (false, true)  => pauli_x.clone(),
-        (true,  true)  => pauli_y.clone(),
-        (true,  false) => pauli_z.clone(),
+        (false, true) => pauli_x.clone(),
+        (true, true) => pauli_y.clone(),
+        (true, false) => pauli_z.clone(),
     };
 
-    let full_pauli = (1..n).fold(first, |acc, i| {
-        let single = match (z[i], x[i]) {
-            (false, false) => pauli_i.clone(),
-            (false, true)  => pauli_x.clone(),
-            (true,  true)  => pauli_y.clone(),
-            (true,  false) => pauli_z.clone(),
-        };
-        kron(&single, &acc)
-    });
+    let first = single_pauli(z[0], x[0]);
 
-    let cos_val = (angle / 2.0).cos();
-    let sin_val = (angle / 2.0).sin();
+    (1..z.len()).fold(first, |acc, i| {
+        let next = single_pauli(z[i], x[i]);
+        kron(&next, &acc)
+    })
+}
 
-    let identity: Array2<Complex64> = Array2::eye(dim)
-        .mapv(|x: f64| c64(x, 0.));
+pub fn pauli_product_rotation_matrix(angle: f64, z: &[bool], x: &[bool]) -> Array2<Complex64> {
+    let pauli_mat = pauli_zx_to_dense_matrix(z, x);
+    let dim = pauli_mat.shape()[0];
+    let identity: Array2<Complex64> = Array2::eye(dim).mapv(|v: f64| c64(v, 0.));
 
-    identity.mapv(|v| v * c64(cos_val, 0.))
-        + full_pauli.mapv(|v| v * c64(0., -sin_val))
+    let cos_val = (angle / 2.0).cos();
+    let sin_val = (angle / 2.0).sin();
 
+    identity.mapv(|v| v * c64(cos_val, 0.)) + pauli_mat.mapv(|v| v * c64(0., -sin_val))
 }
 
 /// Kronecker (tensor) product of two complex matrices.
@@ -607,4 +598,3 @@ fn kron(a: &Array2<Complex64>, b: &Array2<Complex64>) -> Array2<Complex64> {
     }
     out
 }
-

crates/circuit/src/operations.rs

@@ -9,7 +9,6 @@
 // Any modifications or derivative works of this code must retain this
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
-
 use approx::relative_eq;
 use std::f64::consts::PI;
 use std::fmt::Debug;
@@ -3262,7 +3261,6 @@ impl PyInstruction {
         })
     }
 
-
     pub fn definition(&self) -> Option<CircuitData> {
         Python::attach(|py| -> Option<CircuitData> {
             match self.instruction.getattr(py, intern!(py, "definition")) {
@@ -3551,7 +3549,6 @@ pub struct PauliProductRotation {
     pub angle: Param,
 }
 
-
 impl PauliProductRotation {
     pub fn create_py_op(&self, py: Python, label: Option<&str>) -> PyResult<Py<PyAny>> {
         let z = self.z.to_pyarray(py);
@@ -3576,20 +3573,16 @@ impl PauliProductRotation {
             Param::Float(f) => f,
             _ => return None,
         };
-        let pauli_mat = gate_matrix::pauli_zx_to_dense_matrix(
-            &self.z,
-            &self.x,
-        );
+        let pauli_mat = gate_matrix::pauli_zx_to_dense_matrix(&self.z, &self.x);
         let cos_val = (angle / 2.0).cos();
         let sin_val = (angle / 2.0).sin();
         let dim = pauli_mat.shape()[0];
         let identity = Array2::<Complex64>::eye(dim);
         Some(
             identity.mapv(|v| Complex64::new(v.re * cos_val, 0.))
-                + pauli_mat.mapv(|v| Complex64::new(0., -sin_val) * v)
+                + pauli_mat.mapv(|v| Complex64::new(0., -sin_val) * v),
         )
     }
-
 }
 
 impl Operation for PauliProductRotation {
@@ -3614,7 +3607,6 @@ impl Operation for PauliProductRotation {
     }
 }
 
-
 impl PartialEq for PauliProductRotation {
     fn eq(&self, other: &Self) -> bool {
         self.x == other.x