Improve commutation checking of Pauli product rotations and measurements

crates/transpiler/src/commutation_checker.rs

@@ -234,7 +234,7 @@ fn try_extract_op_from_ppr(
     Some(out.compose_map(&local, |i| qubits[i as usize].0))
 }
 
-fn try_pauli_generator(
+fn try_sparse_observable_generator(
     operation: &OperationRef,
     qubits: &[Qubit],
     num_qubits: u32,
@@ -248,6 +248,18 @@ fn try_pauli_generator(
     }
 }
 
+/// Checks if the generator can be represented as a single Pauli term.
+/// If so, returns the generator in the (Z, X) form.
+pub fn try_pauli_generator<'a>(
+    operation: &'a OperationRef,
+) -> Option<(&'a Vec<bool>, &'a Vec<bool>)> {
+    match operation {
+        OperationRef::PauliProductRotation(ppr) => Some((&ppr.z, &ppr.x)),
+        OperationRef::PauliProductMeasurement(ppm) => Some((&ppm.z, &ppm.x)),
+        _ => None,
+    }
+}
+
 fn get_bits_from_py<T>(
     py_bits1: &Bound<'_, PyTuple>,
     py_bits2: &Bound<'_, PyTuple>,
@@ -521,10 +533,27 @@ impl CommutationChecker {
             _ => (),
         };
 
+        if let (Some((z1, x1)), Some((z2, x2))) =
+            (try_pauli_generator(op1), try_pauli_generator(op2))
+        {
+            let max_q1 = qargs1.iter().map(|q| q.index()).max().unwrap_or(0);
+            let mut in_q1 = vec![usize::MAX; max_q1 + 1];
+            for (i, &q) in qargs1.iter().enumerate() {
+                in_q1[q.index()] = i;
+            }
+            let mut parity = false;
+            for (j, &q) in qargs2.iter().enumerate() {
+                if let Some(&i) = in_q1.get(q.index()).filter(|&&i| i != usize::MAX) {
+                    parity ^= (x1[i] && z2[j]) ^ (z1[i] && x2[j]);
+                }
+            }
+            return Ok(!parity);
+        }
+
         // Handle commutations in between Pauli-based gates, like PauliGate or PauliEvolutionGate
         let size = qargs1.iter().chain(qargs2.iter()).max().unwrap().0 + 1;
-        if let Some(obs1) = try_pauli_generator(op1, qargs1, size) {
-            if let Some(obs2) = try_pauli_generator(op2, qargs2, size) {
+        if let Some(obs1) = try_sparse_observable_generator(op1, qargs1, size) {
+            if let Some(obs2) = try_sparse_observable_generator(op2, qargs2, size) {
                 return Ok(obs1.commutes(&obs2, tol));
             }
         }

crates/transpiler/src/passes/commutative_optimization.rs

@@ -20,13 +20,15 @@ use pyo3::{Bound, PyResult, pyfunction, wrap_pyfunction};
 use qiskit_circuit::instruction::Parameters;
 use smallvec::smallvec;
 
-use crate::commutation_checker::{CommutationChecker, try_matrix_with_definition};
+use crate::commutation_checker::{
+    CommutationChecker, try_matrix_with_definition, try_pauli_generator,
+};
 use crate::passes::remove_identity_equiv::{average_gate_fidelity_below_tol, is_identity_equiv};
 use qiskit_circuit::circuit_instruction::OperationFromPython;
 use qiskit_circuit::dag_circuit::DAGCircuit;
 use qiskit_circuit::operations::{
-    Operation, OperationRef, Param, PauliBased, PauliProductRotation, StandardGate, multiply_param,
-    radd_param,
+    Operation, OperationRef, Param, PauliBased, PauliProductMeasurement, PauliProductRotation,
+    StandardGate, multiply_param, radd_param,
 };
 use qiskit_circuit::{BlocksMode, Clbit, NoBlocks, Qubit, imports};
 
@@ -229,6 +231,39 @@ fn canonicalize(
         return Some((canonical_instruction, Param::Float(0.)));
     }
 
+    if let OperationRef::PauliProductMeasurement(ppm) = inst.op.view() {
+        let qargs = dag.get_qargs(inst.qubits);
+        let mut paired = qargs
+            .iter()
+            .zip(ppm.z.iter())
+            .zip(ppm.x.iter())
+            .map(|((q, z), x)| (q, z, x))
+            .collect::<Vec<_>>();
+        paired.sort_by_key(|(q, _, _)| **q);
+        let (sorted_qargs, sorted_z, sorted_x) =
+            paired
+                .into_iter()
+                .multiunzip::<(Vec<Qubit>, Vec<bool>, Vec<bool>)>();
+        let sorted_ppm = PauliProductMeasurement {
+            z: sorted_z,
+            x: sorted_x,
+            neg: ppm.neg,
+        };
+
+        let sorted_qubits = dag.add_qargs(&sorted_qargs);
+
+        let canonical_instruction = PackedInstruction {
+            op: PauliBased::PauliProductMeasurement(sorted_ppm).into(),
+            qubits: sorted_qubits,
+            clbits: inst.clbits,
+            params: inst.params.clone(),
+            label: None,
+            #[cfg(feature = "cache_pygates")]
+            py_op: std::sync::OnceLock::new(),
+        };
+        return Some((canonical_instruction, Param::Float(0.)));
+    }
+
     None
 }
 
@@ -256,6 +291,27 @@ fn commute(
     let op1 = inst1.op.view();
     let op2 = inst2.op.view();
 
+    if let (Some((z1, x1)), Some((z2, x2))) = (try_pauli_generator(&op1), try_pauli_generator(&op2))
+    {
+        let mut parity = false;
+
+        // The qubits in PPRs and PPMs are known to be sorted by qubit index.
+        let (n1, n2) = (qargs1.len(), qargs2.len());
+        let (mut i1, mut i2) = (0, 0);
+        while i1 < n1 && i2 < n2 {
+            match qargs1[i1].cmp(&qargs2[i2]) {
+                std::cmp::Ordering::Less => i1 += 1,
+                std::cmp::Ordering::Greater => i2 += 1,
+                std::cmp::Ordering::Equal => {
+                    parity ^= (x1[i1] && z2[i2]) ^ (z1[i1] && x2[i2]);
+                    i1 += 1;
+                    i2 += 1;
+                }
+            }
+        }
+        return Ok(!parity);
+    }
+
     Ok(commutation_checker.commute(
         &op1,
         inst1.params.as_deref(),

releasenotes/notes/speedup-pauli-rotations-commutation-checking-c9b65ad1e3d0c453.yaml

@@ -0,0 +1,4 @@
+---
+features_transpiler:
+  - Improved the performance of commutation checking for :class:`.PauliProductRotationGate` and
+    :class:`.PauliProductMeasurement`.