iqm-client 32.0.0__py3-none-any.whl → 33.0.0__py3-none-any.whl

iqm/qiskit_iqm/iqm_provider.py

@@ -21,13 +21,7 @@ from typing import Any
 from uuid import UUID
 import warnings
 
-from iqm.iqm_client import (
-    CircuitBatch,
-    CircuitCompilationOptions,
-    CircuitValidationError,
-    IQMClient,
-    RunRequest,
-)
+from iqm.iqm_client import CircuitCompilationOptions, CircuitValidationError, IQMClient
 from iqm.iqm_client.util import to_json_dict
 from iqm.qiskit_iqm import IQMFakeAphrodite, IQMFakeApollo, IQMFakeBackend, IQMFakeDeneb
 from iqm.qiskit_iqm.fake_backends import IQMFakeAdonis
@@ -39,6 +33,7 @@ from qiskit import QuantumCircuit
 from qiskit.providers import JobStatus, JobV1, Options
 
 from iqm.pulse import Circuit
+from iqm.station_control.interface.models import CircuitBatch, RunRequest
 
 try:
     __version__ = version("qiskit-iqm")
@@ -52,9 +47,9 @@ class IQMBackend(IQMBackendBase):
     """Backend for executing quantum circuits on IQM quantum computers.
 
     Args:
-        client: Client instance for communicating with an IQM server.
+        client: Client instance for communicating with an IQM Server.
         calibration_set_id: ID of the calibration set the backend will use.
-            ``None`` means the IQM server will be queried for the current default
+            ``None`` means the IQM Server will be queried for the current default
             calibration set.
         use_metrics: If True, the backend will query the server for calibration data and related
             quality metrics, and pass these to the transpilation target(s). The default value is set
@@ -80,7 +75,6 @@ class IQMBackend(IQMBackendBase):
         super().__init__(architecture, metrics=metrics, **kwargs)
         self.client: IQMClient = client
         self._max_circuits: int | None = None
-        self.name = "IQM Backend"
         self._calibration_set_id = architecture.calibration_set_id
 
     @classmethod
@@ -110,12 +104,16 @@ class IQMBackend(IQMBackendBase):
     def run(
         self,
         run_input: QuantumCircuit | list[QuantumCircuit],
+        *,
+        use_timeslot: bool = False,
         **options,
     ) -> IQMJob:
         """Run a quantum circuit or a list of quantum circuits on the IQM quantum computer represented by this backend.
 
         Args:
             run_input: The circuits to run.
+            use_timeslot: Submits the job to the timeslot queue if set to ``True``. If set to ``False``,
+                the job is submitted to the normal on-demand queue.
             options: Keyword arguments passed on to :meth:`create_run_request`, and documented there.
 
         Returns:
@@ -123,8 +121,8 @@ class IQMBackend(IQMBackendBase):
 
         """
         run_request = self.create_run_request(run_input, **options)
-        job_id = self.client.submit_run_request(run_request)
-        job = IQMJob(self, str(job_id), shots=run_request.shots)
+        circuit_job = self.client.submit_run_request(run_request, use_timeslot=use_timeslot)
+        job = IQMJob(self, circuit_job)
         job.circuit_metadata = [c.metadata if isinstance(c, Circuit) else {} for c in run_request.circuits]
         return job
 
@@ -134,7 +132,7 @@ class IQMBackend(IQMBackendBase):
         shots: int = 1024,
         circuit_compilation_options: CircuitCompilationOptions | None = None,
         circuit_callback: Callable[[list[QuantumCircuit]], Any] | None = None,
-        qubit_mapping: dict[int, str] | None = None,
+        qubit_index_to_name: dict[int, str] | None = None,
         **unknown_options,
     ) -> RunRequest:
         """Creates a run request without submitting it for execution.
@@ -161,8 +159,8 @@ class IQMBackend(IQMBackendBase):
                 As a side effect, you can also use this callback to modify the transpiled circuits
                 in-place, just before execution; however, we do not recommend to use it for this
                 purpose.
-            qubit_mapping: Mapping from qubit indices in the circuit to qubit names on the device. If ``None``,
-                :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
+            qubit_index_to_name: Mapping from qubit indices in the circuit to qubit names on the device.
+                If ``None``, :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
 
         Returns:
             The created run request object
@@ -195,7 +193,9 @@ class IQMBackend(IQMBackendBase):
         if circuit_callback:
             circuit_callback(circuits)
 
-        circuits_serialized: CircuitBatch = [self.serialize_circuit(circuit, qubit_mapping) for circuit in circuits]
+        circuits_serialized: CircuitBatch = [
+            self.serialize_circuit(circuit, qubit_index_to_name) for circuit in circuits
+        ]
 
         if self._use_default_calibration_set:
             default_calset_id = self.client.get_dynamic_quantum_architecture(None).calibration_set_id
@@ -230,13 +230,10 @@ class IQMBackend(IQMBackendBase):
             corresponding job
 
         """
-        return IQMJob(self, job_id)
-
-    def close_client(self) -> None:
-        """Close IQMClient's session with the authentication server."""
-        self.client.close_auth_session()
+        circuit_job = self.client.get_job(UUID(job_id))
+        return IQMJob(self, circuit_job)
 
-    def serialize_circuit(self, circuit: QuantumCircuit, qubit_mapping: dict[int, str] | None = None) -> Circuit:
+    def serialize_circuit(self, circuit: QuantumCircuit, qubit_index_to_name: dict[int, str] | None = None) -> Circuit:
         """Serialize a quantum circuit into the IQM data transfer format.
 
         Serializing is not strictly bound to the native gateset, i.e. some gates that are not explicitly mentioned in
@@ -254,8 +251,8 @@ class IQMBackend(IQMBackendBase):
 
         Args:
             circuit: quantum circuit to serialize
-            qubit_mapping: Mapping from qubit indices in the circuit to qubit names on the device. If not provided,
-                :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
+            qubit_index_to_name: Mapping from qubit indices in the circuit to qubit names on the device.
+                If ``None``, :attr:`.IQMBackendBase.index_to_qubit_name` will be used.
 
         Returns:
             data transfer object representing the circuit
@@ -264,9 +261,9 @@ class IQMBackend(IQMBackendBase):
             ValueError: circuit contains an unsupported instruction or is not transpiled in general
 
         """
-        if qubit_mapping is None:
-            qubit_mapping = self._idx_to_qb
-        instructions = tuple(serialize_instructions(circuit, qubit_index_to_name=qubit_mapping))
+        if qubit_index_to_name is None:
+            qubit_index_to_name = self._idx_to_qb
+        instructions = tuple(serialize_instructions(circuit, qubit_index_to_name=qubit_index_to_name))
 
         try:
             metadata = to_json_dict(circuit.metadata)
@@ -291,7 +288,7 @@ facade_names: dict[str, IQMFakeBackend] = {
 class IQMFacadeBackend(IQMBackend):
     """Simulates locally the execution of quantum circuits on a remote mock IQM quantum computer.
 
-    This backend is meant to be used to run circuits on a mock IQM server that has no real quantum hardware,
+    This backend is meant to be used to run circuits on a mock IQM Server that has no real quantum hardware,
     and if the mock execution is successful, simulate the circuits locally using an error model that
     is broadly representative of the mocked QPU. Finally it returns the *simulated results*.
 
@@ -299,13 +296,13 @@ class IQMFacadeBackend(IQMBackend):
 
     .. important::
 
-       When using a facade backend, the IQM server URL of :class:`IQMProvider` should always point to a mock environment
+       When using a facade backend, the IQM Server URL of :class:`IQMProvider` should always point to a mock environment
        rather than a real quantum computer, as the execution results from the server will be discarded and replaced by
        a locally simulated result generated by Qiskit Aer. If you use a real quantum computer with a facade backend,
        you will just waste your credits and/or computation time.
 
     Args:
-        client: Client instance for communicating with an IQM server.
+        client: Client instance for communicating with an IQM Server.
         name: Name of the fake backend (simulator instance) to use. If None, will be determined automatically based
             on the static quantum architecture of the server.
         kwargs: Optional arguments to be passed to the parent class.
@@ -341,7 +338,13 @@ class IQMFacadeBackend(IQMBackend):
             return False
         return True
 
-    def run(self, run_input: QuantumCircuit | list[QuantumCircuit], **options) -> JobV1:
+    def run(
+        self,
+        run_input: QuantumCircuit | list[QuantumCircuit],
+        *,
+        use_timeslot: bool = False,
+        **options,
+    ) -> JobV1:
         circuits = [run_input] if isinstance(run_input, QuantumCircuit) else run_input
         circuits_validated_cregs: list[bool] = [self._validate_no_empty_cregs(circuit) for circuit in circuits]
         if not all(circuits_validated_cregs):
@@ -350,7 +353,7 @@ class IQMFacadeBackend(IQMBackend):
                 "see the user guide."
             )
 
-        iqm_backend_job = super().run(run_input, **options)
+        iqm_backend_job = super().run(run_input, use_timeslot=use_timeslot, **options)
         iqm_backend_job.result()  # get and discard results
         if iqm_backend_job.status() == JobStatus.ERROR:
             raise RuntimeError("Remote execution did not succeed.")
@@ -360,18 +363,28 @@ class IQMFacadeBackend(IQMBackend):
 class IQMProvider:
     """Provider for IQM backends.
 
-    IQMProvider connects to a quantum computer through an IQM server.
+    IQMProvider connects to a quantum computer through an IQM Server.
     If the server requires user authentication, you can provide it either using environment
     variables, or as keyword arguments to IQMProvider. The user authentication kwargs are passed
     through to :class:`~iqm.iqm_client.iqm_client.IQMClient` as is, and are documented there.
 
     Args:
-        url: URL of the IQM server (e.g. "https://cocos.resonance.meetiqm.com/garnet")
+        url: URL of the IQM Server (e.g. "https://resonance.meetiqm.com/").
+        quantum_computer: ID or alias of the quantum computer to connect to, if the IQM Server
+            instance controls more than one (e.g. "garnet"). ``None`` means connect to the
+            default one.
 
     """
 
-    def __init__(self, url: str, **user_auth_args):  # contains keyword args token or tokens_file
+    def __init__(
+        self,
+        url: str,
+        *,
+        quantum_computer: str | None = None,
+        **user_auth_args,  # contains keyword args token or tokens_file
+    ):
         self.url = url
+        self.quantum_computer = quantum_computer
         self.user_auth_args = user_auth_args
 
     def get_backend(
@@ -396,7 +409,7 @@ class IQMProvider:
             Backend instance for connecting to a quantum computer.
 
         """
-        client = IQMClient(self.url, **self.user_auth_args)
+        client = IQMClient(self.url, quantum_computer=self.quantum_computer, **self.user_auth_args)
 
         if name and name.startswith("facade_"):
             return IQMFacadeBackend(client, name=name, calibration_set_id=calibration_set_id, use_metrics=use_metrics)

iqm/qiskit_iqm/iqm_target.py

@@ -19,18 +19,15 @@ from collections.abc import Iterable
 import logging
 from typing import TypeAlias
 
-from iqm.iqm_client import (
-    DynamicQuantumArchitecture,
-    GateImplementationInfo,
-    GateInfo,
-    ObservationFinder,
-)
+from iqm.iqm_client import ObservationFinder
 from iqm.qiskit_iqm.move_gate import MoveGate
-from qiskit.circuit import Delay, Gate, Parameter, Reset
+from qiskit.circuit import Delay, Gate, IfElseOp, Parameter, Reset
 from qiskit.circuit.library import CZGate, IGate, Measure, RGate
 from qiskit.providers import QubitProperties
 from qiskit.transpiler import InstructionProperties, Target
 
+from iqm.station_control.interface.models import DynamicQuantumArchitecture, GateImplementationInfo, GateInfo
+
 Locus: TypeAlias = tuple[str, ...]
 """Sequence of QPU component names on which a gate acts."""
 LocusIdx: TypeAlias = tuple[int, ...]
@@ -44,6 +41,7 @@ _QISKIT_IQM_GATE_MAP: dict[str, Gate] = {
     "cz": CZGate(),
     "move": MoveGate(),
     "id": IGate(),
+    "if_else": IfElseOp,
 }
 """Maps IQM native operation names to corresponding Qiskit gate objects."""
 
@@ -82,6 +80,7 @@ class IQMTarget(Target):
         # (2) make all the IQMTarget.__init__ args keyword-only with non-colliding names, and init
         # the necessary superclass attributes ourselves.
         # (1) seems to break pickling during concurrent transpilation using Qiskit's ``transpile``, so we use (2).
+        # (2) is broken from Qiskit 2.2 onwards because Target.__init__ no longer has **kwargs nor *args.
         self.qubit_properties = self._create_qubit_properties(architecture.qubits, metrics)
 
         # Using iqm_ as a prefix to avoid name clashes with the base class.
@@ -126,8 +125,13 @@ class IQMTarget(Target):
         if "prx" in op_loci:
             add_gate("prx")
 
-        # HACK reset gate shares cc_prx loci for now, until reset is also in the DQA/metrics
         if "cc_prx" in op_loci:
+            # IfElseOp is a global 'gate' so it's slightly different from the others.
+            self.add_instruction(
+                instruction=_QISKIT_IQM_GATE_MAP["if_else"],
+                name="if_else",
+            )
+            # HACK reset gate shares cc_prx loci for now, until reset is also in the DQA/metrics
             self.add_instruction(
                 _QISKIT_IQM_GATE_MAP["reset"],
                 {self.locus_to_idx(locus): None for locus in op_loci["cc_prx"]},

iqm/qiskit_iqm/iqm_transpilation.py

@@ -17,10 +17,14 @@ import math
 import warnings
 
 import numpy as np
+from packaging.version import Version
 from qiskit import QuantumCircuit
+from qiskit import __version__ as qiskit_version
+from qiskit.circuit.controlflow import IfElseOp
 from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary
-from qiskit.circuit.library import RGate, UnitaryGate
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.circuit.library import RGate, RZGate, UnitaryGate
+from qiskit.converters import circuit_to_dag, dag_to_circuit
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes import (
     BasisTranslator,
@@ -58,16 +62,33 @@ class IQMOptimizeSingleQubitGates(TransformationPass):
 
     def __init__(self, drop_final_rz: bool = True, ignore_barriers: bool = False):
         super().__init__()
-        self._basis = ["r", "cz", "move"]
-        self._intermediate_basis = ["u", "cz", "move"]
+        self._basis = ["r", "cz", "move", "if_else"]
+        self._intermediate_basis = ["u", "cz", "move", "if_else"]
         self._drop_final_rz = drop_final_rz
         self._ignore_barriers = ignore_barriers
 
-    def run(self, dag: DAGCircuit) -> DAGCircuit:
-        self._validate_ops(dag)
+    def run(self, dag: DAGCircuit, decompose_rz_to_r: bool = True) -> DAGCircuit:
+        """Runs the single-qubit gate optimization pass.
+
+        Args:
+            dag: The input DAG circuit to optimize.
+            decompose_rz_to_r: Whether to decompose RZ gates into R gates, or add the to the DAG as
+                RZ gates. This is used in recursive calls to communicate the accumulated RZ angles in ``rz_angles``.
+
+        Returns:
+            The optimized DAG circuit.
+
+        """
+        if decompose_rz_to_r:
+            self._validate_ops(dag)
         # accumulated RZ angles for each qubit, from the beginning of the circuit to the current gate
         rz_angles: list[float] = [0] * dag.num_qubits()
 
+        # Handle old conditional gates
+        if Version(qiskit_version) < Version("2.0"):
+            # This needs to be done before the BasisTranslation as that pass does not retain the condition.
+            dag = self._handle_c_if_blocks(dag)
+
         if self._ignore_barriers:
             dag = RemoveBarriers().run(dag)
         # convert all gates in the circuit to U and CZ gates
@@ -76,21 +97,7 @@ class IQMOptimizeSingleQubitGates(TransformationPass):
         dag = Optimize1qGatesDecomposition(self._intermediate_basis).run(dag)
         for node in dag.topological_op_nodes():
             if node.name == "u":
-                # convert into PRX + RZ
-                qubit_index = dag.find_bit(node.qargs[0]).index
-                if isinstance(node.op.params[0], float) and math.isclose(node.op.params[0], 0, abs_tol=TOLERANCE):
-                    dag.remove_op_node(node)
-                else:
-                    dag.substitute_node(
-                        node,
-                        RGate(
-                            node.op.params[0],
-                            np.pi / 2 - node.op.params[2] - rz_angles[qubit_index],
-                        ),
-                    )
-                phase = node.op.params[1] + node.op.params[2]
-                dag.global_phase += phase / 2
-                rz_angles[qubit_index] += phase
+                dag, rz_angles = self._handle_u_gates(dag, node, rz_angles)
             elif node.name in {"measure", "reset"}:
                 # measure and reset destroy phase information. The local phases before and after such
                 # an operation are in principle independent, and the local computational frame phases
@@ -115,21 +122,207 @@ class IQMOptimizeSingleQubitGates(TransformationPass):
                 rz_angles[res], rz_angles[qb] = rz_angles[qb], rz_angles[res]
             elif node.name in {"cz", "delay"}:
                 pass  # commutes with RZ gates
+            elif node.name == "if_else":
+                dag, rz_angles = self._handle_if_else_block(dag, node, rz_angles)
             else:
                 raise ValueError(
                     f"Unexpected operation '{node.name}' in circuit given to IQMOptimizeSingleQubitGates pass"
                 )
 
-        if not self._drop_final_rz:
+        if not decompose_rz_to_r:
             for qubit_index, rz_angle in enumerate(rz_angles):
-                if rz_angle != 0:
-                    qubit = dag.qubits[qubit_index]
-                    dag.apply_operation_back(RGate(-np.pi, 0), qargs=(qubit,))
-                    dag.apply_operation_back(RGate(np.pi, rz_angle / 2), qargs=(qubit,))
+                dag.apply_operation_back(RZGate(rz_angle), qargs=(dag.qubits[qubit_index],))
+        elif not self._drop_final_rz:
+            dag, rz_angles = self._apply_final_r_gates(dag, rz_angles)
 
         return dag
 
+    def _apply_final_r_gates(self, dag: DAGCircuit, rz_angles: list[float]) -> tuple[DAGCircuit, list[float]]:
+        """Helper function that adds the final PRX/R gates to the circuit according to the accumulated angles.
+
+        Returns the updated dag and a list of zero angles since the final RZ rotations are already applied.
+
+        Args:
+            dag: The input DAG circuit we are optimizing.
+            rz_angles: The accumulated RZ angles for each qubit.
+
+        Returns:
+            The updated DAG circuit and a list of zero angles.
+
+        """
+        for qubit_index, rz_angle in enumerate(rz_angles):
+            if not math.isclose(rz_angle, 0, abs_tol=TOLERANCE):
+                qubit = dag.qubits[qubit_index]
+                dag.apply_operation_back(RGate(-np.pi, 0), qargs=(qubit,))
+                dag.apply_operation_back(RGate(np.pi, rz_angle / 2), qargs=(qubit,))
+        # Return resetted angles
+        return dag, [0.0] * dag.num_qubits()
+
+    def _handle_u_gates(
+        self, dag: DAGCircuit, node: DAGOpNode, rz_angles: list[float]
+    ) -> tuple[DAGCircuit, list[float]]:
+        """Helper function that converts U gates to PRXs and RZ gates,
+        so that the RZ gates can be commuted to the end of the circuit.
+
+        Args:
+            dag: The input DAG circuit we are optimizing.
+            node: The DAG node containing the U gate to convert.
+            rz_angles: The accumulated RZ angles for each qubit.
+
+        Returns:
+            The updated DAG circuit and the updated list of accumulated RZ angles.
+
+        """
+        qubit_index = dag.find_bit(node.qargs[0]).index
+        if isinstance(node.op.params[0], float) and math.isclose(node.op.params[0], 0, abs_tol=TOLERANCE):
+            dag.remove_op_node(node)
+        else:
+            dag.substitute_node(
+                node,
+                RGate(
+                    node.op.params[0],
+                    np.pi / 2 - node.op.params[2] - rz_angles[qubit_index],
+                ),
+            )
+        phase = node.op.params[1] + node.op.params[2]
+        dag.global_phase += phase / 2
+        rz_angles[qubit_index] += phase
+        return dag, rz_angles
+
+    def _handle_if_else_block(
+        self, dag: DAGCircuit, node: DAGOpNode, rz_angles: list[float]
+    ) -> tuple[DAGCircuit, list[float]]:
+        """Call the optimization recursively on both branches of the if_else node.
+
+        The accumulated RZ angles are added to both branches before optimizing them.
+        The accumulated RZ angles after the optimization are taken from the else branch
+        and the adjoint is applied to the if branch to correct for the overrotation.
+
+        Args:
+            dag: The input DAG circuit we are optimizing.
+            node: The DAG node containing the if_else block to optimize.
+            rz_angles: The accumulated RZ angles for each qubit.
+
+        Returns:
+            The updated DAG circuit and the updated list of accumulated RZ angles.
+
+        """
+        # Add the Rz angles to each circuit block of the if_else node
+        # and run this pass recursively
+        sub_dags = []
+        for circuit_block in node.op.params:
+            new_circuit = QuantumCircuit(list(node.qargs + node.cargs))
+            # Prepend Rz angle to circuit block
+            for qubit in node.qargs:
+                new_circuit.append(RGate(-np.pi, 0), [qubit])
+                new_circuit.append(RGate(np.pi, rz_angles[dag.find_bit(qubit).index] / 2), [qubit])
+            if circuit_block is not None:
+                new_circuit.compose(circuit_block, node.qargs, node.cargs, inplace=True)
+            # Run optimization pass on the block
+            block_dag = circuit_to_dag(new_circuit)
+            block_dag = self.run(block_dag, decompose_rz_to_r=False)
+            sub_dags.append(block_dag)
+        # Pick up the final rotation
+        for qubit in node.qargs:
+            # Find the last node on the qubit
+            final_rzs = [list(block_dag.nodes_on_wire(qubit, only_ops=True))[-1] for block_dag in sub_dags]
+            # Assertions because this cannot go wrong by user error
+            assert len(final_rzs) == 2, "IfElseOp should have exactly two circuit blocks"
+            assert final_rzs[0].name == "rz" and final_rzs[1].name == "rz", (
+                "The last operation on each qubit in an IfElseOp should be an RZ gate, "
+                + f"found {final_rzs[0].name} and {final_rzs[1].name} instead"
+            )
+            # Extract the angles
+            rz1, rz2 = final_rzs[0].op.params[0], final_rzs[1].op.params[0]
+            # We take the else_block rotation as the one to continue pushing through the circuit
+            # because we don't support else_blocks in the circuit at the moment.
+            # Update the rz_angle on this qubit with the one found
+            rz_angles[dag.find_bit(qubit).index] = rz2
+            # Remove the final rz from the dag in both circuit blocks
+            for block_dag, final_node in zip(sub_dags, final_rzs):
+                block_dag.remove_op_node(final_node)
+            # Fix the overrotation of the if_block when the final Rz does not match
+            if not math.isclose(rz1, rz2):
+                rz_angle = rz1 - rz2
+                sub_dags[0].apply_operation_back(RGate(-np.pi, 0), qargs=(qubit,))
+                sub_dags[0].apply_operation_back(RGate(np.pi, rz_angle / 2), qargs=(qubit,))
+        # Replace the params in the if_else node with the optimized circuits
+        new_params = []
+        for idx, sub_dag in enumerate(sub_dags):
+            # Optimize the PRXs on the block_dag, but now keep the final Rzs
+            block_dag = IQMOptimizeSingleQubitGates(drop_final_rz=False, ignore_barriers=self._ignore_barriers).run(
+                sub_dag
+            )
+            # Ensure the qubits act on the same qubits as before
+            if node.op.params[idx] is not None and block_dag.qubits != node.op.params[idx].qubits:
+                # Sometimes the circuit_block.qubits != node.qargs,
+                # so we need to make sure that they act on the same qubits as before
+                new_circuit = QuantumCircuit(list(node.op.params[idx].qubits + node.op.params[idx].clbits))
+                new_circuit.compose(
+                    dag_to_circuit(block_dag),
+                    node.op.params[idx].qubits,
+                    node.op.params[idx].clbits,
+                    inplace=True,
+                )
+            else:
+                new_circuit = dag_to_circuit(block_dag)
+            new_params.append(new_circuit)
+        dag.substitute_node(
+            node,
+            IfElseOp(
+                node.op.condition,
+                new_params[0],
+                false_body=new_params[1] if new_params[1].size() > 0 else None,
+                label=node.op.label,
+            ),
+        )
+        return dag, rz_angles
+
+    def _handle_c_if_blocks(self, dag: DAGCircuit) -> DAGCircuit:
+        """Helper function that replaces all classically controlled RGates with an if_else operator.
+
+        This is needed because the BasisTranslator pass does not retain the condition on the nodes.
+        This is only needed for Qiskit versions < 2.0.0.
+
+        Args:
+            dag: The input DAG circuit we are optimizing.
+
+        Returns:
+            The updated DAG circuit with if_else blocks instead of R gates with a condition.
+
+        """
+        for node in dag.topological_op_nodes():
+            if hasattr(node, "condition") and node.condition and node.name != "if_else":
+                # Manually parse the node to a circuit because helper functions don't exist
+                # NOTE if_block needs to have the same size as node or else it cannot be replaced later.
+                if_block = QuantumCircuit(list(node.qargs))
+                # NOTE Need to reconstruct the node.op manually because rust panics when using node.op directly
+                if node.op.name != "r":
+                    raise ValueError(
+                        f"Unexpected operation '{node.name}' in circuit given to IQMOptimizeSingleQubitGates pass"
+                    )
+                if_block.append(RGate(node.op.params[0], node.op.params[1], label=node.op.label), node.qargs)
+                new_op = IfElseOp(
+                    node.condition,
+                    if_block,
+                )
+                dag.substitute_node(
+                    node,
+                    new_op,
+                )
+        return dag
+
     def _validate_ops(self, dag: DAGCircuit):  # noqa: ANN202
+        """Helper function that validates that the operations in the circuit are compatible
+        with the IQMOptimizeSingleQubitGates pass.
+
+        Args:
+            dag: The input DAG circuit to validate before optimization.
+
+        Raises:
+            ValueError: If an invalid operation is found in the circuit.
+
+        """
         valid_ops = self._basis + ["measure", "reset", "delay", "barrier"]
         for node in dag.op_nodes():
             if node.name not in valid_ops: