Remove control flow instruction filter when use_fractional_gates=true (#2366)

* Remove control flow instruction filter when `use_fractional_gates=true`

* Update test and add reno

* Fix unit tests

* address comments

* Use `dynamic_circuits` in backends filter

* Update docstring

* Add new plugin

* Address comments & deprecate old plugins

* Update qiskit_ibm_runtime/ibm_backend.py

Co-authored-by: Elena Peña Tapia <[email protected]>

* undeprecate IBMDynamicTranslationPlugin

---------

Co-authored-by: Elena Peña Tapia <[email protected]>

Author: kt474

pyproject.toml

@@ -98,6 +98,7 @@ dependencies = [
 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"
+ibm_dynamic_and_fractional = "qiskit_ibm_runtime.transpiler.plugin:IBMDynamicFractionalTranslationPlugin"
 
 [project.urls]
 documentation = "https://quantum.cloud.ibm.com/docs/"

qiskit_ibm_runtime/ibm_backend.py

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

qiskit_ibm_runtime/qiskit_runtime_service.py

@@ -528,14 +528,12 @@ def backends(
                         filters=lambda x: ("rz" in x.basis_gates )
                     )
             use_fractional_gates: Set True to allow for the backends to include
-                fractional gates. Currently this feature cannot be used
-                simultaneously with dynamic circuits, PEC, PEA, or gate
-                twirling.  When this flag is set, control flow instructions are
-                automatically removed from the backend.
-                When you use a dynamic circuits feature (e.g. ``if_else``) in your
-                algorithm, you must disable this flag to create executable ISA circuits.
-                This flag might be modified or removed when our backend
-                supports dynamic circuits and fractional gates simultaneously.
+                fractional gates. Note that our backends now
+                support dynamic circuits and fractional gates simultaneously.
+                You no longer have to disable this flag when
+                using dynamic circuits features (e.g. ``if_else``) in your
+                algorithm. Control flow instructions are not removed from the
+                backend when this flag is set to True.
                 If ``None``, then both fractional gates and control flow operations are
                 included in the backends.
 
@@ -562,12 +560,6 @@ def backends(
             IBMInputValueError: If an input is invalid.
             QiskitBackendNotFoundError: If the backend is not in any instance.
         """
-        if dynamic_circuits is True and use_fractional_gates:
-            raise QiskitBackendNotFoundError(
-                "Currently fractional_gates and dynamic_circuits feature cannot be "
-                "simulutaneously enabled. Consider disabling one or the other."
-            )
-
         backends: List[IBMBackend] = []
 
         unique_backends = set()
@@ -613,7 +605,9 @@ def backends(
         if dynamic_circuits is not None:
             backends = list(
                 filter(
-                    lambda b: ("qasm3" in getattr(b.configuration(), "supported_features", []))
+                    lambda b: (
+                        "dynamic_circuits" in getattr(b.configuration(), "supported_features", [])
+                    )
                     == dynamic_circuits,
                     backends,
                 )

qiskit_ibm_runtime/transpiler/plugin.py

@@ -28,6 +28,8 @@
     FoldRzzAngle,
 )
 
+from ..utils.deprecation import issue_deprecation_msg
+
 _TERRA_VERSION = tuple(
     int(x) for x in re.match(r"\d+\.\d+\.\d", _terra_version_string).group(0).split(".")[:3]
 )
@@ -114,13 +116,22 @@ def pass_manager(
 
 
 class IBMFractionalTranslationPlugin(PassManagerStagePlugin):
-    """A translation stage plugin for targeting Qiskit circuits
+    """(DEPRECATED) A translation stage plugin for targeting Qiskit circuits
     to IBM Quantum systems with fractional gate support.
 
     Currently coexistence of fractional gate operations and
     dynamic circuits is not assumed.
     """
 
+    def __new__(cls, *args, **kwargs):
+        issue_deprecation_msg(
+            msg="Since backends now support running jobs that contain both "
+            "fractional gates and dynamic circuit, IBMFractionalTranslationPlugin is deprecated",
+            version="0.42.0",
+            remedy="Use IBMDynamicFractionalTranslationPlugin instead.",
+        )
+        return super().__new__(cls, *args, **kwargs)
+
     def pass_manager(
         self,
         pass_manager_config: PassManagerConfig,
@@ -154,3 +165,47 @@ def pass_manager(
             # Apply this pass after SU4 is translated.
             post_passes.append(FoldRzzAngle())
         return PassManager(pre_passes) + translator_pm + PassManager(post_passes)
+
+
+class IBMDynamicFractionalTranslationPlugin(PassManagerStagePlugin):
+    """A translation stage plugin for targeting Qiskit circuits
+    to IBM Quantum systems with both dynamic circuits and fractional gate support.
+    """
+
+    def pass_manager(
+        self,
+        pass_manager_config: PassManagerConfig,
+        optimization_level: Optional[int] = None,
+    ) -> PassManager:
+        """Build IBMTranslationPlugin PassManager."""
+
+        if _TERRA_VERSION[0] == 1:
+            legacy_options = {"backend_props": pass_manager_config.backend_properties}
+        else:
+            legacy_options = {}
+
+        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,
+            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,
+            **legacy_options,
+        )
+
+        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())
+
+        if (convert_pass := getattr(passes, "ConvertConditionsToIfOps", None)) is not None:
+            # If `None`, we're dealing with Qiskit 2.0+ where it's unnecessary anyway.
+            pre_passes += [convert_pass()]  # pylint: disable=not-callable
+        return PassManager(pre_passes) + translator_pm + PassManager(post_passes)

qiskit_ibm_runtime/utils/backend_decoder.py

@@ -19,8 +19,6 @@
 import dateutil.parser
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
 
-from qiskit.circuit import CONTROL_FLOW_OP_NAMES
-
 from ..models import (
     BackendProperties,
     QasmBackendConfiguration,
@@ -85,17 +83,7 @@ def filter_raw_configuration(
         return
 
     gate_map = get_standard_gate_name_mapping()
-    if use_fractional_gates:
-        raw_config["conditional"] = False
-        if "supported_instructions" in raw_config:
-            raw_config["supported_instructions"] = [
-                i for i in raw_config["supported_instructions"] if i not in CONTROL_FLOW_OP_NAMES
-            ]
-        if "supported_features" in raw_config:
-            raw_config["supported_features"] = [
-                g for g in raw_config["supported_features"] if g != "qasm3"
-            ]
-    else:
+    if not use_fractional_gates:
         if "basis_gates" in raw_config:
             raw_config["basis_gates"] = [
                 g

release-notes/unreleased/2366.feat.rst

@@ -0,0 +1,7 @@
+Since backends now support running jobs that contain both fractional gates and dynamic circuits, control flow 
+instructions are no longer filtered out when using ``use_fractional_gates=True``. As a result, there is a new translation state plugin, 
+:class:`~.IBMDynamicFractionalTranslationPlugin`, for targeting circuits with both 
+dynamic circuits and fractional gates.
+
+:class:`~.IBMFractionalTranslationPlugin` is deprecated 
+since it is no longer necessary.

test/unit/test_backend_retrieval.py

@@ -235,14 +235,8 @@ def test_get_backend_with_fractional_optin(self, use_fractional):
             "rzz" in test_backend.target,
             use_fractional or use_fractional is None,
         )
-        self.assertEqual(
-            "if_else" in test_backend.target.operation_names,
-            not use_fractional or use_fractional is None,
-        )
-        self.assertEqual(
-            "while_loop" in test_backend.target.operation_names,
-            not use_fractional or use_fractional is None,
-        )
+        self.assertTrue("if_else" in test_backend.target.operation_names)
+        self.assertTrue("while_loop" in test_backend.target.operation_names)
 
         if use_fractional or use_fractional is None:
             self.assertAlmostEqual(test_backend.target["rx"][(0,)].error, 0.00019, places=5)

test/unit/test_sampler.py

@@ -162,7 +162,7 @@ def test_sampler_validations(self):
                 inst.run([(circ,)])
 
     def test_run_dynamic_circuit_with_fractional_opted(self):
-        """Fractional opted backend cannot run dynamic circuits."""
+        """Fractional opted backend can run dynamic circuits."""
         service = FakeRuntimeService(
             channel="ibm_quantum_platform",
             token="my_token",
@@ -177,8 +177,7 @@ def test_run_dynamic_circuit_with_fractional_opted(self):
         )
 
         inst = SamplerV2(mode=backend)
-        with self.assertRaises(IBMInputValueError):
-            inst.run([dynamic_circuit])
+        inst.run([dynamic_circuit])
 
     def test_run_fractional_circuit_without_fractional_opted(self):
         """Fractional non-opted backend cannot run fractional circuits."""
@@ -198,7 +197,6 @@ def test_run_fractional_circuit_without_fractional_opted(self):
             inst.run([fractional_circuit])
 
     @named_data(
-        ("with_fractional", True),
         ("without_fractional", False),
     )
     def test_run_fractional_dynamic_mix(self, use_fractional):