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,16 @@ 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.
+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>,
@@ -332,6 +342,7 @@ impl CommutationChecker {
             max_num_qubits,
             matrix_max_num_qubits,
             approximation_degree,
+            false,
         )?)
     }
 
@@ -364,6 +375,7 @@ impl CommutationChecker {
             max_num_qubits,
             matrix_max_num_qubits,
             approximation_degree,
+            false,
         )?)
     }
 
@@ -456,6 +468,7 @@ impl CommutationChecker {
         max_num_qubits: Option<u32>,
         matrix_max_num_qubits: u32,
         approximation_degree: f64,
+        assume_sorted_pp: bool, // true if qubits in PPRs and PPMs cab be assumed to be sorted
     ) -> Result<bool, CommutationError> {
         // If the average gate infidelity is below this tolerance, they commute. The tolerance
         // is set to max(1e-12, 1 - approximation_degree), to account for roundoffs and for
@@ -521,10 +534,50 @@ impl CommutationChecker {
             _ => (),
         };
 
+        if let (Some((z1, x1)), Some((z2, x2))) =
+            (try_pauli_generator(op1), try_pauli_generator(op2))
+        {
+            let mut parity = false;
+            let mut adjust_parity = |i1: usize, i2: usize| {
+                parity ^= (x1[i1] && z2[i2]) ^ (z1[i1] && x2[i2]);
+            };
+
+            if assume_sorted_pp {
+                // 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 => {
+                            adjust_parity(i1, i2);
+                            i1 += 1;
+                            i2 += 1;
+                        }
+                    }
+                }
+            } else {
+                // The qubits in PPRs and PPMs are not known to be sorted by qubit index.
+                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;
+                }
+                for (i2, &q) in qargs2.iter().enumerate() {
+                    if let Some(&i1) = in_q1.get(q.index()).filter(|&&i1| i1 != usize::MAX) {
+                        adjust_parity(i1, i2);
+                    }
+                }
+            }
+            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/commutation_analysis.rs

@@ -109,6 +109,7 @@ pub fn analyze_commutations(
                             None,
                             MAX_NUM_QUBITS,
                             approximation_degree,
+                            false,
                         )?;
                         if !all_commute {
                             break;

crates/transpiler/src/passes/commutative_optimization.rs

@@ -25,8 +25,8 @@ use crate::passes::remove_identity_equiv::{average_gate_fidelity_below_tol, is_i
 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 +229,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
 }
 
@@ -268,6 +301,7 @@ fn commute(
         None,
         matrix_max_num_qubits,
         approximation_degree,
+        true, // PPRs and PPMs are sorted in canonicalize
     )?)
 }
 

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`.