Fixed commutation checking between two Pauli product measurements

crates/transpiler/src/commutation_checker.rs

@@ -496,6 +496,24 @@ impl CommutationChecker {
             _ => (),
         };
 
+        // Special handling for commutativity of two pauli product measurements
+        if let (
+            OperationRef::PauliProductMeasurement(ppm1),
+            OperationRef::PauliProductMeasurement(ppm2),
+        ) = (op1, op2)
+        {
+            if cargs1 == cargs2 {
+                // If both PPMs write to the same classical bit, it's generally incorrect to interchange them.
+                // So we return true only if both PPMs are identical.
+                return Ok(qargs1 == qargs2 && ppm1 == ppm2);
+            } else {
+                // PPMs write to different classical bits, and they commute if and only if their pauli generators do.
+                let size = qargs1.iter().chain(qargs2.iter()).max().unwrap().0 + 1;
+                let pauli1 =  try_pauli_generator(op1, qargs1, size).expect("extracting sparse observable generator from pauli product measurement in infallible");
+                let pauli2 =  try_pauli_generator(op2, qargs2, size).expect("extracting sparse observable generator from pauli product measurement in infallible");
+                return Ok(pauli1.commutes(&pauli2, tol));
+            }
+        }
         // Handle commutations between Pauli-based gates among themselves, and with standard gates
         // TODO Support trivial commutations of standard gates with identities in the Paulis
         let size = qargs1.iter().chain(qargs2.iter()).max().unwrap().0 + 1;

releasenotes/notes/fix-ppm-commutation-ddcde0bf8b20a9f8.yaml

@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Fixed commutativity check between two :class:`.PauliProductMeasurement` instructions
+    in the case that both instructions measure to the same classical bit. In this case,
+    the later measurement overwrites the result of the earlier measurement, and consequently,
+    interchanging the two measurement instructions inside the quantum circuit is generally
+    invalid.

test/python/circuit/test_commutation_checker.py

@@ -525,10 +525,11 @@ def test_pauli_based_gates(self, gate_type):
         for p1, q1, p2, q2, expected in cases:
             if p1 == "I" and gate_type == "measure":
                 continue  # PPM doesn't support all-identity gates
+            c1, c2 = ([0], [1]) if gate_type == "measure" else ([], [])
 
             gate1 = build_pauli_gate(p1, gate_type)
             gate2 = build_pauli_gate(p2, gate_type)
-            self.assertEqual(expected, scc.commute(gate1, q1, [], gate2, q2, []))
+            self.assertEqual(expected, scc.commute(gate1, q1, c1, gate2, q2, c2))
 
     @data(
         ("pauli", "measure"),
@@ -544,10 +545,26 @@ def test_mix_pauli_gates(self, gate_type1, gate_type2):
         ]
 
         for p1, q1, p2, q2, expected in cases:
+            c1 = [0] if gate_type1 == "measure" else []
+            c2 = [1] if gate_type2 == "measure" else []
+
             gate1 = build_pauli_gate(p1, gate_type1)
             gate2 = build_pauli_gate(p2, gate_type2)
+
             with self.subTest(p1=p1, p2=p2):
-                self.assertEqual(expected, scc.commute(gate1, q1, [], gate2, q2, []))
+                self.assertEqual(expected, scc.commute(gate1, q1, c1, gate2, q2, c2))
+
+    def test_ppms_with_same_clbit(self):
+        """Test commutativity of two Pauli product measurements with the same clbit."""
+        ppm1 = build_pauli_gate("XXII", "measure")
+        ppm2 = build_pauli_gate("IIZZ", "measure")
+
+        with self.subTest("different paulis"):
+            self.assertFalse(scc.commute(ppm1, [0, 1, 2, 3], [0], ppm2, [0, 1, 2, 3], [0]))
+        with self.subTest("same paulis, different qubits"):
+            self.assertFalse(scc.commute(ppm1, [0, 1, 2, 3], [0], ppm1, [1, 0, 2, 3], [0]))
+        with self.subTest("same paulis and qubits"):
+            self.assertTrue(scc.commute(ppm1, [0, 1, 2, 3], [0], ppm1, [0, 1, 2, 3], [0]))
 
     def test_pauli_evolution_sums(self):
         """Test PauliEvolutionGate commutations for operators that are sums of Paulis."""
@@ -585,7 +602,8 @@ def test_pauli_and_standard_gate(self, pauli_type):
         """Test Pauli-based gates and standard gate commutations are efficiently supported."""
         # 40-qubit Pauli gate with following terms: X: 0-9, Y: 10-19, Z: 20-29, I: 30-39
         pauli = 10 * "I" + 10 * "Z" + 10 * "Y" + 10 * "X"
-        pauli_indices = list(range(len(pauli)))
+        pauli_qubits = list(range(len(pauli)))
+        pauli_clbits = [0] if pauli_type == "measure" else []
         pauli_gate = build_pauli_gate(pauli, pauli_type)
 
         # Test cases in the format: (gate, indices, commutes)
@@ -607,7 +625,9 @@ def test_pauli_and_standard_gate(self, pauli_type):
 
         for std_gate, indices, expected in cases:
             with self.subTest(std_gate=std_gate, indices=indices):
-                commutes = scc.commute(pauli_gate, pauli_indices, [], std_gate, indices, [])
+                commutes = scc.commute(
+                    pauli_gate, pauli_qubits, pauli_clbits, std_gate, indices, []
+                )
                 self.assertEqual(expected, commutes)