Add plugin pass to support non-calibrated rzz angles

qiskit_ibm_runtime/ibm_backend.py

@@ -919,7 +919,9 @@ def close_session(self) -> None:
 
     def get_translation_stage_plugin(self) -> str:
         """Return the default translation stage plugin name for IBM backends."""
-        return "ibm_dynamic_circuits"
+        if not self.options.use_fractional_gates:
+            return "ibm_dynamic_circuits"
+        return "ibm_fractional"
 
 
 class IBMRetiredBackend(IBMBackend):

qiskit_ibm_runtime/transpiler/passes/basis/__init__.py

@@ -13,3 +13,4 @@
 """Passes to layout circuits to IBM backend's instruction sets."""
 
 from .convert_id_to_delay import ConvertIdToDelay
+from .fold_rzz_angle import FoldRzzAngle

qiskit_ibm_runtime/transpiler/passes/basis/fold_rzz_angle.py

@@ -0,0 +1,185 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Pass to wrap Rzz gate angle in calibrated range of 0-pi/2."""
+
+from typing import Tuple
+from math import pi
+
+from qiskit.circuit.library.standard_gates import RZZGate, RZGate, XGate
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.circuit import Qubit
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+
+import numpy as np
+
+
+class FoldRzzAngle(TransformationPass):
+    """Fold Rzz gate angle into calibrated range of 0-pi/2 with
+    local gate tweaks.
+
+    This pass preserves the number of Rzz gates, but it may add
+    extra single qubit gate operations.
+    These gates might be reduced by the following
+    single qubit optimization passes.
+    """
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        # Currently control flow ops and Rzz cannot live in the same circuit.
+        # Once it's supported, we need to recursively check subroutines.
+        for node in dag.op_nodes():
+            if not isinstance(node.op, RZZGate) or isinstance(
+                angle := node.op.params[0], ParameterExpression
+            ):
+                continue
+            wrap_angle = np.angle(np.exp(1j * angle))
+            if -pi <= wrap_angle <= -pi / 2:
+                replace = _quad3(wrap_angle, node.qargs)
+            elif -pi / 2 < wrap_angle < 0:
+                replace = _quad4(wrap_angle, node.qargs)
+            elif pi / 2 < wrap_angle <= pi:
+                replace = _quad2(wrap_angle, node.qargs)
+            else:
+                if angle != wrap_angle:
+                    dag.substitute_node(
+                        node,
+                        RZZGate(wrap_angle),
+                        inplace=True,
+                    )
+                continue
+            dag.substitute_node_with_dag(node, replace)
+        return dag
+
+
+def _quad2(angle: float, qubits: Tuple[Qubit, ...]) -> DAGCircuit:
+    """Handle angle between (pi/2, pi].
+
+    Circuit is transformed into following form:
+
+             ┌───────┐┌───┐            ┌───┐
+        q_0: ┤ Rz(π) ├┤ X ├─■──────────┤ X ├
+             ├───────┤└───┘ │ZZ(π - θ) └───┘
+        q_1: ┤ Rz(π) ├──────■───────────────
+             └───────┘
+
+    Returns:
+        New dag to replace Rzz gate.
+    """
+    new_dag = DAGCircuit()
+    new_dag.add_qubits(qubits=qubits)
+    new_dag.apply_operation_back(
+        RZGate(pi),
+        qargs=(qubits[0],),
+        cargs=(),
+        check=False,
+    )
+    new_dag.apply_operation_back(
+        RZGate(pi),
+        qargs=(qubits[1],),
+        cargs=(),
+        check=False,
+    )
+    if not np.isclose(new_angle := (pi - angle), 0.0):
+        new_dag.apply_operation_back(
+            XGate(),
+            qargs=(qubits[0],),
+            cargs=(),
+            check=False,
+        )
+        new_dag.apply_operation_back(
+            RZZGate(new_angle),
+            qargs=qubits,
+            cargs=(),
+            check=False,
+        )
+        new_dag.apply_operation_back(
+            XGate(),
+            qargs=(qubits[0],),
+            cargs=(),
+            check=False,
+        )
+    return new_dag
+
+
+def _quad3(angle: float, qubits: Tuple[Qubit, ...]) -> DAGCircuit:
+    """Handle angle between [-pi, -pi/2].
+
+    Circuit is transformed into following form:
+
+             ┌───────┐
+        q_0: ┤ Rz(π) ├─■───────────────
+             ├───────┤ │ZZ(π - Abs(θ))
+        q_1: ┤ Rz(π) ├─■───────────────
+             └───────┘
+
+    Returns:
+        New dag to replace Rzz gate.
+    """
+    new_dag = DAGCircuit()
+    new_dag.add_qubits(qubits=qubits)
+    new_dag.apply_operation_back(
+        RZGate(pi),
+        qargs=(qubits[0],),
+        cargs=(),
+        check=False,
+    )
+    new_dag.apply_operation_back(
+        RZGate(pi),
+        qargs=(qubits[1],),
+        cargs=(),
+        check=False,
+    )
+    if not np.isclose(new_angle := (pi - np.abs(angle)), 0.0):
+        new_dag.apply_operation_back(
+            RZZGate(new_angle),
+            qargs=qubits,
+            cargs=(),
+            check=False,
+        )
+    return new_dag
+
+
+def _quad4(angle: float, qubits: Tuple[Qubit, ...]) -> DAGCircuit:
+    """Handle angle between (-pi/2, 0).
+
+    Circuit is transformed into following form:
+
+             ┌───┐             ┌───┐
+        q_0: ┤ X ├─■───────────┤ X ├
+             └───┘ │ZZ(Abs(θ)) └───┘
+        q_1: ──────■────────────────
+
+    Returns:
+        New dag to replace Rzz gate.
+    """
+    new_dag = DAGCircuit()
+    new_dag.add_qubits(qubits=qubits)
+    new_dag.apply_operation_back(
+        XGate(),
+        qargs=(qubits[0],),
+        cargs=(),
+        check=False,
+    )
+    new_dag.apply_operation_back(
+        RZZGate(abs(angle)),
+        qargs=qubits,
+        cargs=(),
+        check=False,
+    )
+    new_dag.apply_operation_back(
+        XGate(),
+        qargs=(qubits[0],),
+        cargs=(),
+        check=False,
+    )
+    return new_dag

qiskit_ibm_runtime/transpiler/plugin.py

@@ -20,8 +20,9 @@
 from qiskit.transpiler.preset_passmanagers import common
 from qiskit.transpiler.passes import ConvertConditionsToIfOps
 
-from qiskit_ibm_runtime.transpiler.passes.basis.convert_id_to_delay import (
+from qiskit_ibm_runtime.transpiler.passes.basis import (
     ConvertIdToDelay,
+    FoldRzzAngle,
 )
 
 
@@ -96,3 +97,41 @@ def pass_manager(
             plugin_passes += [ConvertConditionsToIfOps()]
 
         return PassManager(plugin_passes) + translator_pm
+
+
+class IBMFractionalTranslationPlugin(PassManagerStagePlugin):
+    """A translation stage plugin for targeting Qiskit circuits
+    to IBM Quantum system with fractional gate support.
+
+    Currently coexistense of fractional gate operations and
+    dynamic circuit is not assumed.
+    """
+
+    def pass_manager(
+        self,
+        pass_manager_config: PassManagerConfig,
+        optimization_level: Optional[int] = None,
+    ) -> PassManager:
+        """Build IBMTranslationPlugin PassManager."""
+
+        translator_pm = common.generate_translation_passmanager(
+            target=pass_manager_config.target,
+            basis_gates=pass_manager_config.basis_gates,
+            approximation_degree=pass_manager_config.approximation_degree,
+            coupling_map=pass_manager_config.coupling_map,
+            backend_props=pass_manager_config.backend_properties,
+            unitary_synthesis_method=pass_manager_config.unitary_synthesis_method,
+            unitary_synthesis_plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+            hls_config=pass_manager_config.hls_config,
+        )
+
+        instruction_durations = pass_manager_config.instruction_durations
+        pre_passes = []
+        post_passes = []
+        target = pass_manager_config.target or pass_manager_config.basis_gates
+        if instruction_durations and not "id" in target:
+            pre_passes.append(ConvertIdToDelay(instruction_durations))
+        if "rzz" in target:
+            # Apply this pass after SU4 is translated.
+            post_passes.append(FoldRzzAngle())
+        return PassManager(pre_passes) + translator_pm + PassManager(post_passes)

release-notes/unreleased/2043.feat.rst

@@ -0,0 +1,9 @@
+Add new transpiler translation plugin :class:`IBMFractionalTranslationPlugin` 
+and a pass :class:`FoldRzzAngle`.
+This plugin is automatically appled for backends
+retrieved with the `use_fractional_gates` optin,
+and the folding pass is added when the backend target includes the `RZZ` gate.
+
+New pass modifies the input quantum circuit so that all `RZZ` gates in the
+circuit has an angle parameter within [0, pi/2] which is supported 
+by IBM Quantum processors.

setup.py

@@ -82,6 +82,7 @@
         "qiskit.transpiler.translation": [
             "ibm_backend = qiskit_ibm_runtime.transpiler.plugin:IBMTranslationPlugin",
             "ibm_dynamic_circuits = qiskit_ibm_runtime.transpiler.plugin:IBMDynamicTranslationPlugin",
+            "ibm_fractional = qiskit_ibm_runtime.transpiler.plugin:IBMFractionalTranslationPlugin",
         ]
     },
     extras_require={"visualization": ["plotly>=5.23.0"]},

test/unit/transpiler/passes/basis/test_fold_rzz_angle.py

@@ -0,0 +1,63 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Test folding Rzz angle into calibrated range."""
+
+from math import pi
+from ddt import ddt, named_data
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Operator
+from qiskit.transpiler.passmanager import PassManager
+from qiskit.circuit.parameter import Parameter
+
+from qiskit_ibm_runtime.transpiler.passes.basis import FoldRzzAngle
+from .....ibm_test_case import IBMTestCase
+
+
+@ddt
+class TestFoldRzzAngle(IBMTestCase):
+    """Test FoldRzzAngle pass"""
+
+    @named_data(
+        ("large_positive_number", 12345),
+        ("large_negative_number", -12345),
+        ("pi/2_pos", pi / 2),
+        ("pi/2_neg", -pi / 2),
+        ("pi_pos", pi),
+        ("pi_neg", -pi),
+        ("quad1", 0.1),
+        ("quad2", pi / 2 + 0.1),
+        ("quad3", -pi + 0.1),
+        ("quad4", -0.1),
+    )
+    def test_folding_rzz_angles(self, angle):
+        """Test folding gate angle into calibrated range."""
+        qc = QuantumCircuit(2)
+        qc.rzz(angle, 0, 1)
+        pm = PassManager([FoldRzzAngle()])
+        isa = pm.run(qc)
+
+        self.assertTrue(Operator.from_circuit(qc).equiv(Operator.from_circuit(isa)))
+        for inst_data in isa.data:
+            if inst_data.operation.name == "rzz":
+                fold_angle = inst_data.operation.params[0]
+                self.assertGreaterEqual(fold_angle, 0.0)
+                self.assertLessEqual(fold_angle, pi / 2)
+
+    def test_folding_rzz_angle_unbound(self):
+        """Test skip folding unbound gate angle."""
+        qc = QuantumCircuit(2)
+        qc.rzz(Parameter("θ"), 0, 1)
+        pm = PassManager([FoldRzzAngle()])
+        isa = pm.run(qc)
+        self.assertEqual(qc, isa)