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

iqm/qiskit_iqm/iqm_naive_move_pass.py

@@ -98,7 +98,7 @@ class IQMNaiveResonatorMoving(TransformationPass):
         # Convert the circuit to the IQMClientCircuit format and run the transpiler.
         iqm_circuit = IQMClientCircuit(
             name="Transpiling Circuit",
-            instructions=tuple(serialize_instructions(circuit, self.idx_to_component)),
+            instructions=tuple(serialize_instructions(circuit, self.idx_to_component, overwrite_layout=layout)),
             metadata=None,
         )
         try:

iqm/qiskit_iqm/iqm_target.py

@@ -26,7 +26,7 @@ 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
@@ -44,6 +44,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."""
 
@@ -126,8 +127,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:

iqm/qiskit_iqm/qiskit_to_iqm.py

@@ -15,14 +15,17 @@
 
 from __future__ import annotations
 
-from collections.abc import Collection
+from collections.abc import Collection, Iterable
 from dataclasses import dataclass
 from math import pi
 import re
+import warnings
 
 from iqm.qiskit_iqm.move_gate import MoveGate
+from packaging.version import Version
 from qiskit import QuantumCircuit as QiskitQuantumCircuit
-from qiskit.circuit import ClassicalRegister, Clbit, QuantumRegister
+from qiskit import __version__ as qiskit_version
+from qiskit.circuit import ClassicalRegister, Clbit, Operation, QuantumRegister
 from qiskit.transpiler.layout import Layout
 
 from iqm.pulse import CircuitOperation
@@ -93,8 +96,59 @@ class MeasurementKey:
         return cls(creg.name, len(creg), creg_idx, clbit_idx)
 
 
+def _apply_condition(
+    operation: Operation,
+    native_instructions: Iterable[CircuitOperation],
+    clbit_to_measure: dict[Clbit, CircuitOperation],
+) -> None:
+    """Apply a classical condition to circuit instructions.
+
+    Modifies the instructions in place.
+
+    Args:
+        operation: Operation containing the classical condition.
+        native_instructions: Instructions to apply the condition to.
+        clbit_to_measure: Maps bits in the classical register to the measurement operation that
+            last wrote something into them.
+
+    """
+    # check that the condition is supported
+    creg, value = operation.condition
+    if isinstance(creg, ClassicalRegister):
+        if len(creg) != 1:
+            raise ValueError(f"{operation.name} is conditioned on multiple bits, this is not supported.")
+        clbit = creg[0]
+    else:
+        clbit = creg  # it is a Clbit
+    if value != 1:
+        raise ValueError(f"{operation.name} is conditioned on integer value {value}, only value 1 is supported.")
+
+    # Set up feedback routing.
+    # The latest "measure" instruction to write to that classical bit is modified, it is
+    # given an explicit feedback_key equal to its measurement key.
+    # The same feedback_key is given to the controlled instruction, along with the feedback qubit.
+    if (measure_inst := clbit_to_measure.get(clbit)) is None:
+        raise ValueError(f"{operation.name} conditioned on {clbit}, which does not contain a measurement result yet.")
+    feedback_key = measure_inst.args["key"]
+    measure_inst.args["feedback_key"] = feedback_key  # this measure is used to provide feedback
+    physical_qubit_name = measure_inst.locus[0]  # single-qubit measurement
+
+    for inst in native_instructions:
+        # TODO we do not check anywhere if cc_prx is available for this locus!
+        if inst.name != "prx":
+            raise ValueError(f"This backend only supports conditionals on r, x, y, rx and ry gates, not on {inst.name}")
+        inst.name = "cc_prx"
+        inst.args["feedback_key"] = feedback_key
+        inst.args["feedback_qubit"] = physical_qubit_name
+
+
 def serialize_instructions(  # noqa: PLR0912, PLR0915
-    circuit: QiskitQuantumCircuit, qubit_index_to_name: dict[int, str], allowed_nonnative_gates: Collection[str] = ()
+    circuit: QiskitQuantumCircuit,
+    qubit_index_to_name: dict[int, str],
+    allowed_nonnative_gates: Collection[str] = (),
+    *,
+    clbit_to_measure: dict[Clbit, CircuitOperation] | None = None,
+    overwrite_layout: Layout | None = None,
 ) -> list[CircuitOperation]:
     """Serialize a quantum circuit into the IQM data transfer format.
 
@@ -109,9 +163,13 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
             If such gates are present in the circuit, the caller must edit the result to be valid and executable.
             Notably, since IQM transfer format requires named parameters and qiskit parameters don't have names, the
             `i` th parameter of an unrecognized instruction is given the name ``"p<i>"``.
+        clbit_to_measure: Maps clbits to the latest "measure" instruction to store its result there, or
+            None if nothing has been measured yet.
+        overwrite_layout: A layout indicating the physical qubit mapping to use for the serialized instructions, this
+            overwrites the circuit's layout.
 
     Returns:
-        list of instructions representing the circuit
+        list of IQM instructions representing the circuit
 
     Raises:
         ValueError: circuit contains an unsupported instruction or is not transpiled in general
@@ -119,7 +177,8 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
     """
     instructions: list[CircuitOperation] = []
     # maps clbits to the latest "measure" instruction to store its result there
-    clbit_to_measure: dict[Clbit, CircuitOperation] = {}
+    if clbit_to_measure is None:
+        clbit_to_measure = {}
     for circuit_instruction in circuit.data:
         instruction = circuit_instruction.operation
         qubit_names = tuple(qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits)
@@ -178,44 +237,56 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
         elif instruction.name in allowed_nonnative_gates:
             args = {f"p{i}": param for i, param in enumerate(instruction.params)}
             native_inst = CircuitOperation(name=instruction.name, locus=qubit_names, args=args)
+        elif instruction.name == "if_else":
+            if_block, else_block = instruction.params
+            if else_block is not None and len(else_block) > 0:  # Non-empty circuit in else-block
+                raise ValueError("The use of an else-block with if_test is not supported.")
+            # Serialize the if-block.
+            # NOTE The if-block circuit has no qregs of its own, just references to the parent circuit qregs,
+            # and it does not always have every parent circuit qubit.
+            # Hence we need to make a new qubit index to name mapping for it.
+
+            # NOTE Sometimes the qubits in the if-block are in the circuit and
+            # sometimes they are in the layout depending on how the circuit was transpiled.
+            # So let's find out where to get the physical qubits from.
+            use_overwrite_layout = overwrite_layout is not None and all(
+                qb in overwrite_layout.get_physical_bits().values() for qb in if_block.qubits
+            )
+            if use_overwrite_layout:
+                physical_qubits = {q: i for i, q in overwrite_layout.get_physical_bits().items()}  # type: ignore[union-attr]
+                q_index_to_name = {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block.qubits)}
+            elif circuit.layout is None or all(qb in circuit.qubits for qb in if_block.qubits):
+                q_index_to_name = {
+                    k: qubit_index_to_name[circuit.find_bit(q).index] for k, q in enumerate(if_block.qubits)
+                }
+            else:
+                physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
+                q_index_to_name = {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block.qubits)}
+
+            if_instructions = serialize_instructions(
+                if_block, q_index_to_name, allowed_nonnative_gates, clbit_to_measure=clbit_to_measure
+            )
+            _apply_condition(instruction, if_instructions, clbit_to_measure)
+            instructions.extend(if_instructions)
+            continue  # Skip the rest of the loop, as we already handled the instructions
         else:
             raise ValueError(
                 f"Instruction '{instruction.name}' in the circuit '{circuit.name}' is not natively supported. "
                 f"You need to transpile the circuit before execution."
             )
-
-        # classically controlled gates (using the c_if method)
-        # TODO we do not check anywhere if cc_prx is available for this locus!
-        condition = instruction.condition
-        if condition is not None:
-            if native_inst.name != "prx":
-                raise ValueError(
-                    f"This backend only supports conditionals on r, x, y, rx and ry gates, not on {instruction.name}"
-                )
-            native_inst.name = "cc_prx"
-            creg, value = condition
-            if isinstance(creg, ClassicalRegister):
-                if len(creg) != 1:
-                    raise ValueError(f"{instruction} is conditioned on multiple bits, this is not supported.")
-                if value != 1:
-                    raise ValueError(
-                        f"{instruction} is conditioned on integer value {value}, only value 1 is supported."
+        # classically controlled gates (using the c_if method) need to be updated
+        if (
+            Version(qiskit_version) < Version("2.0.0") and instruction.condition is not None
+        ):  # None means no classical condition
+            if Version(qiskit_version) < Version("1.3.0"):
+                # Avoid double deprecation warnings.
+                warnings.warn(
+                    DeprecationWarning(
+                        "The use of Qiskit's `c_if` method is deprecated and will be removed in a future release"
+                        "of IQM Client. Please use the `with circuit.if_test(...)` construction instead."
                     )
-                clbit = creg[0]
-            else:
-                clbit = creg  # it is a Clbit
-
-            # Set up feedback routing.
-            # The latest "measure" instruction to write to that classical bit is modified, it is
-            # given an explicit feedback_key equal to its measurement key.
-            # The same feedback_key is given to the controlled instruction, along with the feedback qubit.
-            measure_inst = clbit_to_measure[clbit]
-            feedback_key = measure_inst.args["key"]
-            measure_inst.args["feedback_key"] = feedback_key  # this measure is used to provide feedback
-            physical_qubit_name = measure_inst.locus[0]  # single-qubit measurement
-            native_inst.args["feedback_key"] = feedback_key
-            native_inst.args["feedback_qubit"] = physical_qubit_name
-
+                )
+            _apply_condition(instruction, [native_inst], clbit_to_measure)
         instructions.append(native_inst)
     return instructions
 
@@ -299,7 +370,8 @@ def deserialize_instructions(
             phase = instr.args["phase"]
             feedback_key = instr.args["feedback_key"]
             # NOTE: 'feedback_qubit' is not needed, because in Qiskit you only have single-qubit measurements.
-            circuit.r(angle, phase, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
+            with circuit.if_test((fk_to_clbit[feedback_key], 1)):
+                circuit.r(angle, phase, locus[0])
         elif instr.name == "reset":
             for qubit in locus:
                 circuit.reset(qubit)

iqm/qiskit_iqm/transpiler_plugins.py

@@ -63,15 +63,18 @@ class IQMSchedulingPlugin(PassManagerStagePlugin):
             scheduling.append(
                 IQMOptimizeSingleQubitGates(drop_final_rz=self.drop_final_rz, ignore_barriers=self.ignore_barriers)
             )
-        if pass_manager_config.target is None:
-            raise ValueError("PassManagerConfig must have a target backend set, unable to schedule MoveGate routing.")
-        if self.move_gate_routing and isinstance(pass_manager_config.target, IQMTarget):
-            scheduling.append(
-                IQMNaiveResonatorMoving(
-                    target=pass_manager_config.target,
-                    existing_moves_handling=self.existing_move_handling,
+        if self.move_gate_routing:
+            if pass_manager_config.target is None:
+                raise ValueError(
+                    "PassManagerConfig must have a target backend set, unable to schedule MoveGate routing."
+                )
+            if isinstance(pass_manager_config.target, IQMTarget):
+                scheduling.append(
+                    IQMNaiveResonatorMoving(
+                        target=pass_manager_config.target,
+                        existing_moves_handling=self.existing_move_handling,
+                    )
                 )
-            )
         return scheduling
 
 

{iqm_client-32.0.0.dist-info → iqm_client-32.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-client
-Version: 32.0.0
+Version: 32.1.1
 Summary: Client library for accessing an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License: Apache License

{iqm_client-32.0.0.dist-info → iqm_client-32.1.1.dist-info}/RECORD

@@ -33,14 +33,14 @@ iqm/qiskit_iqm/iqm_circuit.py,sha256=jaPo3zc5FC0vAIumh5d56fr44fDaJXXwcquBzQEy1Yg
 iqm/qiskit_iqm/iqm_circuit_validation.py,sha256=9pneZKs-KjBDGeDI6RHj6lB-ACqugbnYr1BqkJwLcXg,1737
 iqm/qiskit_iqm/iqm_job.py,sha256=YLkAF4oqQ44dOLWbsqMiYCyj7pd3Rk6NIZ_TI1XtcQ8,11700
 iqm/qiskit_iqm/iqm_move_layout.py,sha256=ECf1BcRmXKeClc7AL0lHedvJbqtwV5rEHcOOFR8shKU,10534
-iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=jhTfvhrNDKt6NhhJg_3Y-5x6E1HRNzC_n4A27ZQTuvQ,12962
+iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=3wuZMGIFJ1UZnfvsmrBAhA_W3cYWdQ8xKZiaJZbk4x0,12987
 iqm/qiskit_iqm/iqm_provider.py,sha256=KHF27Qk12-_OA7_UZ8Rd25qDfFq4np2jv11_9f4tchQ,18599
-iqm/qiskit_iqm/iqm_target.py,sha256=UyULiGMn6UJsyILBQiriso9KbhlmzP9TZItS2URaXWg,15832
-iqm/qiskit_iqm/iqm_transpilation.py,sha256=6_6Mri01_HQBV_GTX94WSvIbu-pDMLMzEU6zVMEt6Gc,9153
+iqm/qiskit_iqm/iqm_target.py,sha256=NHpfCmkE090eblH3asNKUtD361kGfX6ZeXzUb8iMku4,16098
+iqm/qiskit_iqm/iqm_transpilation.py,sha256=RccAHY7lNXvg7TWKG7fBNBCgFu5Xd9B_J9V9uKLlmuY,18336
 iqm/qiskit_iqm/move_gate.py,sha256=UbrQSfrpVV3QKGJ93TelxEfZkl1wY4uWL8IH_QDpGUw,2840
 iqm/qiskit_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=3Sm1gLELFLCLf6QiATZSiPzLzkjvzUakhU2N6KoBXC8,14948
-iqm/qiskit_iqm/transpiler_plugins.py,sha256=iuReGL42fCe5aOoH-KMUsb6t7Ok9qmIIj2S4yotJJ-U,8749
+iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=-CWYTxNTeBNXlgllStwyjNkCor5FjkM_qfjP37L6z8Y,18872
+iqm/qiskit_iqm/transpiler_plugins.py,sha256=BrCkUFQUdi0m8K8V0ERYgtPAkvoX4VlYIJwnFKyCN9Q,8831
 iqm/qiskit_iqm/examples/__init__.py,sha256=M4ElQHCo-WxtVXK39bF3QiFT3IGXPtZ1khqexHiTBEc,20
 iqm/qiskit_iqm/examples/bell_measure.py,sha256=vlayliApHU70a2zTnN_gs6iKSSdaB4Jip-iQHJNYN5M,3064
 iqm/qiskit_iqm/examples/transpile_example.py,sha256=cQmXXx3lqvmhgWYFK_U5HmHzMOKQqXUXPYfQhkyHH14,2135
@@ -51,10 +51,10 @@ iqm/qiskit_iqm/fake_backends/fake_apollo.py,sha256=6YSaKtUc6zZ4m3iAREbmxL4tRs_DW
 iqm/qiskit_iqm/fake_backends/fake_deneb.py,sha256=_xpo_NJdu9t4ER8p5be-xTRmApkFY6kQw1UEGUPizk0,3193
 iqm/qiskit_iqm/fake_backends/fake_garnet.py,sha256=GI0xafTCj1Um09qVuccO6GPOGBm6ygul_O40Wu220Ys,5555
 iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py,sha256=wJtfsxjPYbDKmzaz5R4AuaXvvPHa21WyPtRgNctL9eY,16785
-iqm_client-32.0.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
-iqm_client-32.0.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
-iqm_client-32.0.0.dist-info/METADATA,sha256=TNcHTh2I8F7zKgtU-Lh1QfNWpmUH1WwhO1SY0pJCyDo,17887
-iqm_client-32.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_client-32.0.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
-iqm_client-32.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_client-32.0.0.dist-info/RECORD,,
+iqm_client-32.1.1.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
+iqm_client-32.1.1.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
+iqm_client-32.1.1.dist-info/METADATA,sha256=KUS_M5HU81o7THuT1V1TG2-vtRiXCn2_S8umUJaXA04,17887
+iqm_client-32.1.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_client-32.1.1.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
+iqm_client-32.1.1.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_client-32.1.1.dist-info/RECORD,,