Treat measure as Z-observable in CommutationChecker

Author: Adithyaphani

crates/transpiler/src/commutation_checker.rs

@@ -17,7 +17,7 @@ use num_complex::Complex64;
 use num_complex::ComplexFloat;
 use qiskit_circuit::object_registry::PyObjectAsKey;
 use qiskit_circuit::standard_gate::standard_generators::standard_gate_exponent;
-use qiskit_quantum_info::sparse_observable::{PySparseObservable, SparseObservable};
+use qiskit_quantum_info::sparse_observable::{BitTerm, PySparseObservable, SparseObservable};
 use smallvec::SmallVec;
 use std::fmt::Debug;
 
@@ -34,7 +34,7 @@ use qiskit_circuit::imports::QI_OPERATOR;
 use qiskit_circuit::instruction::{Instruction, Parameters};
 use qiskit_circuit::object_registry::ObjectRegistry;
 use qiskit_circuit::operations::{
-    Operation, OperationRef, Param, STANDARD_GATE_SIZE, StandardGate,
+    Operation, OperationRef, Param, STANDARD_GATE_SIZE, StandardGate, StandardInstruction,
 };
 use qiskit_circuit::{Clbit, Qubit};
 use qiskit_quantum_info::unitary_compose;
@@ -240,6 +240,20 @@ fn try_extract_op_from_ppr(
     Some(out.compose_map(&local, |i| qubits[i as usize].0))
 }
 
+fn try_extract_op_from_measure(qubits: &[Qubit], num_qubits: u32) -> Option<SparseObservable> {
+    let local = unsafe {
+        SparseObservable::new_unchecked(
+            1,
+            vec![Complex64::new(1., 0.)],
+            vec![BitTerm::Z],
+            vec![0],
+            vec![0, 1],
+        )
+    };
+    let out = SparseObservable::identity(num_qubits);
+    Some(out.compose_map(&local, |i| qubits[i as usize].0))
+}
+
 fn try_pauli_generator(
     operation: &OperationRef,
     qubits: &[Qubit],
@@ -250,6 +264,7 @@ fn try_pauli_generator(
         "PauliEvolution" => try_extract_op_from_pauli_evo(operation, qubits, num_qubits),
         "pauli_product_measurement" => try_extract_op_from_ppm(operation, qubits, num_qubits),
         "pauli_product_rotation" => try_extract_op_from_ppr(operation, qubits, num_qubits),
+        "measure" => try_extract_op_from_measure(qubits, num_qubits),
         _ => None,
     }
 }
@@ -830,14 +845,18 @@ fn commutation_precheck(
         }
     }
 
-    if matches!(
-        op1,
-        OperationRef::StandardInstruction(_) | OperationRef::Instruction(_)
-    ) || matches!(
-        op2,
-        OperationRef::StandardInstruction(_) | OperationRef::Instruction(_)
-    ) {
-        return PrecheckStatus::NonCommuting;
+    match (op1, op2) {
+        (
+            OperationRef::StandardInstruction(StandardInstruction::Measure),
+            OperationRef::StandardInstruction(StandardInstruction::Measure),
+        ) => return PrecheckStatus::NonCommuting,
+        (OperationRef::StandardInstruction(StandardInstruction::Measure), _)
+        | (_, OperationRef::StandardInstruction(StandardInstruction::Measure)) => {}
+        (OperationRef::StandardInstruction(_), _)
+        | (_, OperationRef::StandardInstruction(_))
+        | (OperationRef::Instruction(_), _)
+        | (_, OperationRef::Instruction(_)) => return PrecheckStatus::NonCommuting,
+        _ => {}
     }
 
     if is_parameterized(params1) || is_parameterized(params2) {

releasenotes/notes/measure-commutation-1dc0d625.yaml

@@ -0,0 +1,9 @@
+---
+fixes:
+  - |
+    The :class:`.CommutationChecker` now treats a standard ``measure`` instruction
+    as a Z-basis measurement when checking commutation against gates. Previously it
+    was conservatively reported as non-commuting with everything. This also fixes
+    the :class:`.LightCone` pass so that Z-diagonal gates preceding a measurement
+    are correctly pruned from the light cone.
+    Fixed `#15938 <https://github.com/Qiskit/qiskit/issues/15938>`__.

test/python/circuit/test_commutation_checker.py

@@ -286,9 +286,11 @@ def test_measure(self):
         # We should be able to swap these.
         self.assertTrue(scc.commute(Measure(), [0], [0], CXGate(), [1, 2], []))
 
-        # Measure and gate have intersecting set of qubits
-        # We should not be able to swap these.
-        self.assertFalse(scc.commute(Measure(), [0], [0], CXGate(), [0, 2], []))
+        # Measure on the control of CX: CX is Z-diagonal on its control
+        self.assertTrue(scc.commute(Measure(), [0], [0], CXGate(), [0, 2], []))
+
+        # Measure on the target of CX: X on the target , doesn't commute with Z
+        self.assertFalse(scc.commute(Measure(), [0], [0], CXGate(), [1, 0], []))
 
         # Measures over different qubits and clbits
         self.assertTrue(scc.commute(Measure(), [0], [0], Measure(), [1], [1]))
@@ -302,6 +304,15 @@ def test_measure(self):
         # Currently checker takes the safe approach and returns False.
         self.assertFalse(scc.commute(Measure(), [0], [0], Measure(), [0], [1]))
 
+        # Z-diagonal gates commute with Z-measures
+        self.assertTrue(scc.commute(Measure(), [0], [0], ZGate(), [0], []))
+        self.assertTrue(scc.commute(Measure(), [0], [0], SGate(), [0], []))
+        self.assertTrue(scc.commute(Measure(), [0], [0], RZGate(0.5), [0], []))
+
+        # Non-Z Diagonal Gates Don't
+        self.assertFalse(scc.commute(Measure(), [0], [0], HGate(), [0], []))
+        self.assertFalse(scc.commute(Measure(), [0], [0], XGate(), [0], []))
+
     def test_barrier(self):
         """Check commutativity involving barriers."""
         # A gate should not commute with a barrier
@@ -566,6 +577,14 @@ def test_mix_pauli_gates(self, gate_type1, gate_type2):
             with self.subTest(p1=p1, p2=p2):
                 self.assertEqual(expected, scc.commute(gate1, q1, [], gate2, q2, []))
 
+    def test_measure_vs_pauli_product_measurement(self):
+        """Standard measure and single-Z PPM should agree on computation."""
+        ppmz = PauliProductMeasurement(Pauli("Z"))
+        self.assertTrue(scc.commute(Measure(), [0], [0], ppmz, [0], []))
+
+        ppmx = PauliProductMeasurement(Pauli("X"))
+        self.assertFalse(scc.commute(Measure(), [0], [0], ppmx, [0], []))
+
     def test_pauli_evolution_sums(self):
         """Test PauliEvolutionGate commutations for operators that are sums of Paulis."""
         xxyy = PauliEvolutionGate(SparsePauliOp(["XX", "YY"]))

test/python/transpiler/test_light_cone.py

@@ -227,10 +227,29 @@ def test_measurement_barriers(self):
         expected.barrier()
         expected.cx(0, 1)
         expected.barrier()
-        expected.measure(0, 0)
 
         self.assertEqual(expected, new_circuit)
 
+    def test_measure_commutes_with_z_diagonal(self):
+        """CZ should be pruned from the light cone when measuring in Z-basis.
+
+        Regression test for https://github.com/Qiskit/qiskit/issues/15938.
+        """
+
+        # observable-based: CZ  commutes with Z on qubit 0
+        qc1 = QuantumCircuit(2, 2)
+        qc1.cz(0, 1)
+        qct1 = LightCone("Z", [0])(qc1)
+
+        # measurement-based:m should give the same pruning
+        qc2 = QuantumCircuit(2, 2)
+        qc2.cz(0, 1)
+        qc2.measure(0, 0)
+        qct2 = LightCone()(qc2)
+
+        self.assertEqual(qct1.size(), 0)
+        self.assertEqual(qct2.size(), 0)  # only measure is left
+
     @ddt.data(SparsePauliOp("IX"), SparseObservable("I+"))
     def test_parameter_expression(self, sparse_object):
         """Test for Parameter expressions."""