Extend RemoveIdentityEquivalent and CommutativeOptimization with PauliProductRotations (#15810)

* Coercing integer types to floats when appending a PPR to a circuit

* Extending RemoveIdentityEquiv and CommutativeOptimization to handle PPRs

* reno

* fix comment

* review comments

* Review comments

* canonicalizing PPRs in CommutativeOptimization

Author: alexanderivrii

crates/circuit/src/operations.rs

@@ -3532,7 +3532,7 @@ impl UnitaryGate {
     }
 }
 
-/// A Pauli-based gate model, consisting of PauliProductRotation and PauliProductMeasurement ops.
+/// A Pauli-based gate model, consisting of [PauliProductRotation] and [PauliProductMeasurement] ops.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PauliBased {
     PauliProductRotation(PauliProductRotation),
@@ -3587,6 +3587,45 @@ impl PauliProductRotation {
             )?;
         Ok(gate.unbind())
     }
+
+    /// Attempts to merge `self` and `other`.
+    /// If successful, returns the merged [PauliProductRotation].
+    /// If not successful, returns `None`.
+    pub fn merge_with(&self, other: &Self) -> Option<Self> {
+        if self.x == other.x && self.z == other.z {
+            Some(PauliProductRotation {
+                z: self.z.clone(),
+                x: self.x.clone(),
+                angle: radd_param(self.angle.clone(), other.angle.clone()),
+            })
+        } else {
+            None
+        }
+    }
+
+    /// For a [PauliProductRotation] gate with a floating-point angle return a tuple `(Tr(gate) / dim, dim)`.
+    /// Return `None` if the angle is parameterized.
+    pub fn rotation_trace_and_dim(&self) -> Option<(Complex64, f64)> {
+        let Param::Float(angle) = self.angle else {
+            return None;
+        };
+
+        let num_qubits = self
+            .z
+            .iter()
+            .zip(self.x.iter())
+            .filter(|(z, x)| **z || **x)
+            .count();
+        let dim = 2u32.pow(num_qubits as u32);
+        let tr_over_dim = if num_qubits == 0 {
+            // This is an identity Pauli rotation.
+            (Complex64::new(0.0, -angle / 2.)).exp()
+        } else {
+            Complex64::new((angle / 2.).cos(), 0.)
+        };
+
+        Some((tr_over_dim, dim as f64))
+    }
 }
 
 impl PartialEq for PauliProductRotation {

crates/transpiler/src/passes/commutative_optimization.rs

@@ -10,6 +10,8 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
+use itertools::Itertools;
+
 use std::f64::consts::PI;
 
 use num_complex::Complex64;
@@ -23,7 +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, StandardGate, multiply_param, radd_param,
+    Operation, OperationRef, Param, PauliBased, PauliProductRotation, StandardGate, multiply_param,
+    radd_param,
 };
 use qiskit_circuit::{BlocksMode, Clbit, NoBlocks, Qubit, imports};
 
@@ -192,6 +195,40 @@ fn canonicalize(
             }
         }
     }
+
+    if let OperationRef::PauliProductRotation(ppr) = inst.op.view() {
+        let qargs = dag.get_qargs(inst.qubits);
+        let mut paired = qargs
+            .iter()
+            .zip(ppr.z.iter())
+            .zip(ppr.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_ppr = PauliProductRotation {
+            z: sorted_z,
+            x: sorted_x,
+            angle: ppr.angle.clone(),
+        };
+
+        let sorted_qubits = dag.add_qargs(&sorted_qargs);
+
+        let canonical_instruction = PackedInstruction {
+            op: PauliBased::PauliProductRotation(sorted_ppr).into(),
+            qubits: sorted_qubits,
+            clbits: Default::default(),
+            params: inst.params.clone(),
+            label: None,
+            #[cfg(feature = "cache_pygates")]
+            py_op: std::sync::OnceLock::new(),
+        };
+        return Some((canonical_instruction, Param::Float(0.)));
+    }
+
     None
 }
 
@@ -309,6 +346,34 @@ fn try_merge(
         }
     }
 
+    // Special handling for PauliProductRotations.
+    if let (OperationRef::PauliProductRotation(ppr1), OperationRef::PauliProductRotation(ppr2)) =
+        (inst1.op.view(), inst2.op.view())
+    {
+        let merge_result = ppr1.merge_with(ppr2);
+
+        if let Some(merged_ppr) = merge_result {
+            let angle = merged_ppr.angle.clone();
+            let merged_params = Some(Box::new(Parameters::Params(smallvec![angle])));
+
+            let packed = PackedInstruction {
+                op: PauliBased::PauliProductRotation(merged_ppr).into(),
+                qubits: inst1.qubits,
+                clbits: inst1.clbits,
+                params: merged_params,
+                label: None,
+                #[cfg(feature = "cache_pygates")]
+                py_op: std::sync::OnceLock::new(),
+            };
+
+            if let Some(phase_update) = is_identity_equiv(&packed, false, None, error_cutoff_fn)? {
+                return Ok((true, None, phase_update));
+            } else {
+                return Ok((true, Some(packed), 0.));
+            }
+        }
+    }
+
     // Special handling for PauliEvolutionGates.
     if inst1.op.name() == "PauliEvolution" && inst2.op.name() == "PauliEvolution" {
         if let (OperationRef::Gate(py_gate1), OperationRef::Gate(py_gate2)) =

crates/transpiler/src/passes/remove_identity_equiv.rs

@@ -179,7 +179,21 @@ where
         ));
     }
 
-    // Special handling for large pauli rotation gates.
+    // Special handling for pauli product rotation gates.
+    if let OperationRef::PauliProductRotation(ppr) = view {
+        if let Some((tr_over_dim, dim)) = ppr.rotation_trace_and_dim() {
+            return Ok(average_gate_fidelity_below_tol(
+                tr_over_dim,
+                dim,
+                error_cutoff_fn(inst),
+            ));
+        } else {
+            // Parameterized rotation
+            return Ok(None);
+        }
+    }
+
+    // Special handling for pauli evolution gates.
     if view.name() == "PauliEvolution" {
         if let OperationRef::Gate(py_gate) = view {
             let result = Python::attach(|py| -> PyResult<Option<(Complex64, usize)>> {

releasenotes/notes/extend-passes-with-pprs-0f33bc1c0e15a6b2.yaml

@@ -0,0 +1,4 @@
+features_transpiler:
+  - |
+    The transpiler passes :class:`.RemoveIdentityEquivalent` and :class:`.CommutativeOptimization`
+    have been extended to handle :class:`.PauliProductRotationGate` gates.

test/python/transpiler/test_commutative_optimization.py

@@ -26,6 +26,7 @@
     PhaseGate,
     UnitaryGate,
     PauliEvolutionGate,
+    PauliProductRotationGate,
     Initialize,
     U2Gate,
     CZGate,
@@ -43,7 +44,7 @@
 )
 from qiskit.circuit.parameter import Parameter
 from qiskit.transpiler.passes import CommutativeOptimization
-from qiskit.quantum_info import Operator, SparsePauliOp, Clifford
+from qiskit.quantum_info import Operator, SparsePauliOp, Clifford, Pauli
 
 from test import QiskitTestCase
 
@@ -313,6 +314,48 @@ def test_not_merge_pauli_evolutions(self):
 
         self.assertEqual(qct, qc)
 
+    def test_merge_pauli_product_rotations(self):
+        """Test that the pass merges PauliProductRotationGates."""
+
+        qc = QuantumCircuit(4)
+        qc.append(PauliProductRotationGate(Pauli("XXII"), -1), [0, 1, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("ZZIY"), 1), [0, 1, 3, 2])
+        qc.append(PauliProductRotationGate(Pauli("ZZYI"), 1), [1, 0, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("YYXX"), 1), [0, 1, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("XXII"), 1), [0, 1, 2, 3])
+
+        # The two "XXII" rotations should cancel.
+        # The two "ZZIY" rotations (after canonicalizing) should get combined.
+        qct = CommutativeOptimization()(qc)
+
+        expected = QuantumCircuit(4)
+        expected.append(PauliProductRotationGate(Pauli("ZZIY"), 2), [0, 1, 2, 3])
+        expected.append(PauliProductRotationGate(Pauli("YYXX"), 1), [0, 1, 2, 3])
+
+        self.assertEqual(Operator(expected), Operator(qc))
+        self.assertEqual(qct, expected)
+
+    def test_merge_parameterized_pauli_product_rotations(self):
+        """Test that the pass merges parameterized PauliProductRotationGates."""
+
+        p = Parameter("p")
+        q = Parameter("q")
+        r = Parameter("r")
+
+        qc = QuantumCircuit(4)
+        qc.append(PauliProductRotationGate(Pauli("YYXX"), p), [0, 1, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("YYXX"), q), [0, 1, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("ZXXX"), r), [0, 1, 2, 3])
+        qc.append(PauliProductRotationGate(Pauli("YYXX"), -1), [0, 1, 2, 3])
+
+        qct = CommutativeOptimization()(qc)
+
+        expected = QuantumCircuit(4)
+        expected.append(PauliProductRotationGate(Pauli("ZXXX"), r), [0, 1, 2, 3])
+        expected.append(PauliProductRotationGate(Pauli("YYXX"), p + q - 1), [0, 1, 2, 3])
+
+        self.assertEqual(qct, expected)
+
     def test_2pi_multiples(self):
         """Test 2pi multiples are handled with the correct phase they introduce."""
         for eps in [0, 1e-10, -1e-10]:

test/python/transpiler/test_remove_identity_equivalent.py

@@ -28,6 +28,7 @@
     XXPlusYYGate,
     GlobalPhaseGate,
     UnitaryGate,
+    PauliProductRotationGate,
     PauliEvolutionGate,
 )
 from qiskit.quantum_info import Operator, Pauli
@@ -192,6 +193,7 @@ def to_matrix(self):
         UnitaryGate(np.exp(-0.123j) * np.eye(2)),
         UnitaryGate(np.exp(-0.123j) * np.eye(4)),
         UnitaryGate(np.exp(-0.123j) * np.eye(8)),
+        PauliProductRotationGate(Pauli("XYIZ"), 0),
     )
     def test_remove_identity_up_to_global_phase(self, gate):
         """Test that gates equivalent to identity up to a global phase are removed from the circuit,