Add control flow support to ConvertToPauliRotations (#15941)

* add trivial_recurse to CTPR run method

* allow control flow instructions in the DAG for this pass

* release notes

* test simple and nested control flow

* cargo fmt changes

* lint fixes

* fix control flow and release notes

* rewrite name-based barrier/reset/delay check

* rust file modified

* add parameter to nested control flow test

* release note typo correction

* fix release note typos

* minor fixes to address Julien's comments

* lint fix

* fix parameterized gates test

* lint fix

* remove global phase line

Author: jan-an

crates/transpiler/src/passes/convert_to_pauli_rotations.rs

@@ -20,7 +20,7 @@ use qiskit_circuit::dag_circuit::{DAGCircuit, NodeType};
 use qiskit_circuit::instruction::Parameters;
 use qiskit_circuit::operations::{
     Operation, OperationRef, Param, PauliProductMeasurement, PauliProductRotation, StandardGate,
-    add_param, multiply_param, radd_param,
+    StandardInstruction, add_param, multiply_param, radd_param,
 };
 use qiskit_circuit::{BlocksMode, Qubit, VarsMode};
 use qiskit_quantum_info::sparse_observable::BitTerm;
@@ -469,7 +469,7 @@ fn generate_pauli_product_rotation_gate(paulis: &[BitTerm], angle: Param) -> Pau
 #[pyfunction]
 #[pyo3(name = "convert_to_pauli_rotations")]
 pub fn py_convert_to_pauli_rotations(dag: &DAGCircuit) -> PyResult<DAGCircuit> {
-    let mut new_dag = dag.copy_empty_like(VarsMode::Alike, BlocksMode::Drop)?;
+    let mut new_dag = dag.copy_empty_like(VarsMode::Alike, BlocksMode::Keep)?;
 
     // Iterate over nodes in the DAG and collect nodes
     let mut global_phase = Param::Float(0.0);
@@ -478,7 +478,13 @@ pub fn py_convert_to_pauli_rotations(dag: &DAGCircuit) -> PyResult<DAGCircuit> {
         let NodeType::Operation(inst) = &dag[node_index] else {
             unreachable!("dag.topological_op_nodes only returns Operations");
         };
-        if ["barrier", "reset", "delay"].contains(&inst.op.name()) {
+        if matches!(
+            inst.op.view(),
+            OperationRef::ControlFlow(_)
+                | OperationRef::StandardInstruction(StandardInstruction::Barrier(_))
+                | OperationRef::StandardInstruction(StandardInstruction::Reset)
+                | OperationRef::StandardInstruction(StandardInstruction::Delay(_))
+        ) {
             new_dag.push_back(inst.clone())?;
         } else if inst.op.name() == "measure" {
             let z = vec![true];

qiskit/transpiler/passes/optimization/convert_to_pauli_rotations.py

@@ -14,6 +14,7 @@
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.passes.utils import control_flow
 from qiskit._accelerate.convert_to_pauli_rotations import convert_to_pauli_rotations
 
 
@@ -46,6 +47,7 @@ class ConvertToPauliRotations(TransformationPass):
       assert Operator(qc) == Operator(qct)
     """
 
+    @control_flow.trivial_recurse
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the ConvertToPauliRotations optimization pass on ``dag``.
 

releasenotes/notes/control_flow_for_pauli_rotns_pass.yaml

@@ -0,0 +1,6 @@
+---
+features_transpiler:
+  - The pass :class:`.ConvertToPauliRotations` now supports circuits with
+    :class:`.ControlFlowOp` by recursively applying the pass on each 
+    constituent control flow block. Previously, it did not support transpilation 
+    of circuits with control flow instructions.

test/python/transpiler/test_convert_to_pauli_rotations.py

@@ -13,18 +13,21 @@
 """Test ConvertToPauliRotations pass"""
 
 from ddt import ddt
+import numpy as np
 
-from qiskit.circuit import QuantumCircuit, Gate, Parameter
+from qiskit.circuit import QuantumCircuit, Gate, Parameter, QuantumRegister, ClassicalRegister
 from qiskit.transpiler import TranspilerError
 from qiskit.transpiler.passes import ConvertToPauliRotations
-from qiskit.quantum_info import Operator
+from qiskit.quantum_info import Operator, Pauli
 from qiskit.circuit.random import random_circuit
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
 from qiskit.circuit.library import (
     C3SXGate,
     RC3XGate,
     C4XGate,
     MCXGate,
+    PauliProductMeasurement,
+    PauliProductRotationGate,
 )
 from test import combine, QiskitTestCase
 
@@ -130,3 +133,54 @@ def test_unsupported_gates_raise_error(self, gate):
 
         with self.assertRaises(TranspilerError):
             _ = ConvertToPauliRotations()(qc)
+
+    def test_control_flow(self):
+        """Test that simple control flow circuit works with the pass"""
+        qc = QuantumCircuit(2, 1)
+        qc.h(0)
+        qc.measure(0, 0)
+        qc_true = QuantumCircuit(2, 1)
+        qc_true.h(0)
+        qc.if_else((0, True), qc_true, None, range(2), [0])
+        qct = ConvertToPauliRotations()(qc)
+        qc_exp = QuantumCircuit(2, 1)
+        qc_exp.append(PauliProductRotationGate(Pauli("Y"), np.pi / 2), [0])
+        qc_exp.append(PauliProductRotationGate(Pauli("X"), np.pi), [0])
+        qc_exp.append(PauliProductMeasurement(Pauli("Z")), [0], [0])
+        qc_exp.global_phase = np.pi / 2
+        qc_exp_true = QuantumCircuit(2, 1)
+        qc_exp_true.global_phase = np.pi / 2
+        qc_exp_true.append(PauliProductRotationGate(Pauli("Y"), np.pi / 2), [0])
+        qc_exp_true.append(PauliProductRotationGate(Pauli("X"), np.pi), [0])
+        qc_exp.if_else((0, True), qc_exp_true, None, range(2), [0])
+        self.assertEqual(qct, qc_exp)
+
+    def test_nested_control_flow(self):
+        """Test that nested control flow circuit works with the pass"""
+        # subcircuit with parameterized gate
+        theta = Parameter("theta")
+        qc1 = QuantumCircuit(2)
+        qc1.h(0)
+        qc1.ry(theta, 0)
+        # build input circuit by composing a subcircuit into nested control flow
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        qc = QuantumCircuit(qr, cr)
+        qc.compose(qc1, [0, 1], inplace=True)
+        with qc.for_loop(range(3)):
+            with qc.while_loop((cr, 0)):
+                qc.compose(qc1, [0, 1], inplace=True)
+        qct = ConvertToPauliRotations()(qc)
+        # qc2 is the transpiled equivalent of subcircuit qc1
+        qc2 = QuantumCircuit(2)
+        qc2.append(PauliProductRotationGate(Pauli("Y"), np.pi / 2), [0])
+        qc2.append(PauliProductRotationGate(Pauli("X"), np.pi), [0])
+        qc2.append(PauliProductRotationGate(Pauli("Y"), theta), [0])
+        qc2.global_phase = np.pi / 2
+        # expected output circuit of transpiled qc, should be equivalent to qct
+        qc_exp = QuantumCircuit(qr, cr)
+        qc_exp.compose(qc2, [0, 1], inplace=True)
+        with qc_exp.for_loop(range(3)):
+            with qc_exp.while_loop((cr, 0)):
+                qc_exp.compose(qc2, [0, 1], inplace=True)
+        self.assertEqual(qct, qc_exp)