iqm-client 30.1.0__py3-none-any.whl → 31.0.0__py3-none-any.whl

iqm/iqm_client/transpile.py

@@ -61,15 +61,15 @@ from collections.abc import Collection, Iterable, Sequence
 from enum import Enum
 
 from iqm.iqm_client import (
-    Circuit,
     CircuitTranspilationError,
     CircuitValidationError,
     DynamicQuantumArchitecture,
-    Instruction,
 )
 from iqm.iqm_client.models import GateImplementationInfo, GateInfo, Locus, _op_is_symmetric
 from iqm.iqm_client.validation import validate_circuit_moves, validate_instruction
 
+from iqm.pulse import Circuit, CircuitOperation
+
 Resolution = tuple[str, str, str]
 """A (gate qubit, move qubit, resonator) triple that represents a resolution of a fictional
  qubit-qubit gate."""
@@ -93,10 +93,10 @@ class ExistingMoveHandlingOptions(str, Enum):
 
 
 def _map_loci(
-    instructions: Iterable[Instruction],
+    instructions: Iterable[CircuitOperation],
     qubit_mapping: dict[str, str],
     inverse: bool = False,
-) -> tuple[Instruction, ...]:
+) -> tuple[CircuitOperation, ...]:
     """Map the loci of the given instructions using the given qubit mapping, or its inverse.
 
     Args:
@@ -111,7 +111,13 @@ def _map_loci(
     if inverse:
         qubit_mapping = {phys: log for log, phys in qubit_mapping.items()}
     return tuple(
-        inst.model_copy(update={"qubits": tuple(qubit_mapping[q] for q in inst.qubits)}) for inst in instructions
+        CircuitOperation(
+            name=inst.name,
+            locus=tuple(qubit_mapping[q] for q in inst.locus),
+            args=inst.args,
+            implementation=inst.implementation,
+        )
+        for inst in instructions
     )
 
 
@@ -212,7 +218,7 @@ class _ResonatorStateTracker:
         return cls.from_instructions(circuit.instructions)
 
     @classmethod
-    def from_instructions(cls, instructions: Iterable[Instruction]) -> _ResonatorStateTracker:
+    def from_instructions(cls, instructions: Iterable[CircuitOperation]) -> _ResonatorStateTracker:
         """Constructor to make the _ResonatorStateTracker from a sequence of instructions.
 
         Infers the resonator connectivity from the MOVE gates.
@@ -227,7 +233,7 @@ class _ResonatorStateTracker:
         qr_gates: dict[str, dict[str, set[str]]] = {}
         for i in instructions:
             if i.name in cls.qr_gate_names:
-                q, r = i.qubits
+                q, r = i.locus
                 qr_gates.setdefault(i.name, {}).setdefault(q, set()).add(r)
         return cls(qr_gates)
 
@@ -270,7 +276,7 @@ class _ResonatorStateTracker:
         self,
         qubit: str,
         resonator: str,
-    ) -> Iterable[Instruction]:
+    ) -> Iterable[CircuitOperation]:
         """MOVE instruction(s) to move the state of the given qubit into the given resonator,
         or back to the qubit.
 
@@ -292,7 +298,7 @@ class _ResonatorStateTracker:
         if owner not in [qubit, resonator]:
             locus = (owner, resonator)
             self.apply_move(*locus)
-            yield Instruction(name=self.move_gate, qubits=locus, args={})
+            yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
         # if the qubit does not hold its own state, restore it, unless it's in the resonator
         # find where the qubit state is (it can be in at most one resonator)
@@ -300,17 +306,17 @@ class _ResonatorStateTracker:
         if res and (holder := res[0]) != resonator:
             locus = (qubit, holder)
             self.apply_move(*locus)
-            yield Instruction(name=self.move_gate, qubits=locus, args={})
+            yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
         # move qubit state to resonator, or back to the qubit
         locus = (qubit, resonator)
         self.apply_move(*locus)
-        yield Instruction(name=self.move_gate, qubits=locus, args={})
+        yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
     def restore_as_move_instructions(
         self,
         resonators: Iterable[str] | None = None,
-    ) -> list[Instruction]:
+    ) -> list[CircuitOperation]:
         """MOVE instructions that move the states held in the given resonators back to their qubits.
 
         Applies the returned MOVE instructions on the tracker state.
@@ -327,13 +333,13 @@ class _ResonatorStateTracker:
         if resonators is None:
             resonators = self.resonators
 
-        instructions: list[Instruction] = []
+        instructions: list[CircuitOperation] = []
         for r in resonators:
             q = self.res_state_owner[r]
             # if the state in r does not belong to r, restore it to its owner
             if q != r:
                 locus = (q, r)
-                instructions.append(Instruction(name=self.move_gate, qubits=locus, args={}))
+                instructions.append(CircuitOperation(name=self.move_gate, locus=locus, args={}))
                 self.apply_move(*locus)
         return instructions
 
@@ -367,7 +373,7 @@ class _ResonatorStateTracker:
         """
         return tuple(self.res_state_owner.get(q, q) for q in locus)
 
-    def find_resolutions(self, inst: Instruction) -> list[Resolution]:
+    def find_resolutions(self, inst: CircuitOperation) -> list[Resolution]:
         """Find all the possible resolutions for the given fictional qubit-qubit gate.
 
         Given a fictional gate G acting on qubits (a, b), finds all resonators r for which the current DQA
@@ -390,10 +396,10 @@ class _ResonatorStateTracker:
             return gate_q2r.get(g, set()) & self.move_q2r.get(m, set())
 
         # G is assumed symmetric, hence we may reverse the locus order for more resolutions
-        a, b = inst.qubits
+        a, b = inst.locus
         return [(a, b, r) for r in get_resonators(a, b)] + [(b, a, r) for r in get_resonators(b, a)]
 
-    def find_best_resolution(self, inst: Instruction, lookahead: Iterable[Instruction]) -> Resolution | None:
+    def find_best_resolution(self, inst: CircuitOperation, lookahead: Iterable[CircuitOperation]) -> Resolution | None:
         """Find the best resolution for the fictional qubit-qubit gate instruction ``inst``
         using the available native qubit-resonator gates.
 
@@ -419,12 +425,12 @@ class _ResonatorStateTracker:
         # but that would scale exponentially in n. Instead we do some heuristics:
         # Look ahead until we find the instructions that target the locus qubits next, and include
         # their costs in the badness calculation.
-        followers: dict[str, Instruction] = {}
+        followers: dict[str, CircuitOperation] = {}
         for follower in lookahead:
             if len(followers) == 2:
                 break  # found a follower for both locus qubits
-            for q in follower.qubits:
-                if q in inst.qubits:
+            for q in follower.locus:
+                if q in inst.locus:
                     followers.setdefault(q, follower)
 
         def get_badness(res: Resolution, g_holder: str, m_holder: str, r_owner: str) -> int:
@@ -499,7 +505,7 @@ class _ResonatorStateTracker:
                     else:
                         # follower needs to use same resonator but different move qubit
                         badness += 2
-                elif len(m_follower.qubits) == 1:
+                elif len(m_follower.locus) == 1:
                     # Not a resolvable QR gate. For 1q gates on m, state must be restored.
                     badness += 1
 
@@ -529,7 +535,7 @@ class _ResonatorStateTracker:
         # return the best option
         return min(options, key=lambda x: x[1])[0]
 
-    def get_sequence(self, resolution: Resolution, inst: Instruction) -> list[Instruction]:
+    def get_sequence(self, resolution: Resolution, inst: CircuitOperation) -> list[CircuitOperation]:
         """Apply a fictional two-qubit gate using a sequence of native qubit-resonator gates.
 
         See :mod:`~iqm.iqm_client.transpile`.
@@ -547,7 +553,7 @@ class _ResonatorStateTracker:
 
         """
         g, m, r = resolution
-        seq: list[Instruction] = []
+        seq: list[CircuitOperation] = []
         # does m state need to be moved to the resonator?
         m_holder = self.qubit_state_holder.get(m, m)
         if m_holder != r:
@@ -557,14 +563,14 @@ class _ResonatorStateTracker:
         if g_holder != g:
             seq += self.restore_as_move_instructions([g_holder])
         # apply G(g, r)
-        seq.append(inst.model_copy(update={"qubits": (g, r)}))
+        seq.append(CircuitOperation(name=inst.name, locus=(g, r), args=inst.args, implementation=inst.implementation))
         return seq
 
     def insert_moves(
         self,
-        instructions: Sequence[Instruction],
+        instructions: Sequence[CircuitOperation],
         arch: DynamicQuantumArchitecture,
-    ) -> list[Instruction]:
+    ) -> list[CircuitOperation]:
         """Convert a simplified architecture circuit into a equivalent Star architecture circuit with
         resonators and MOVE gates.
 
@@ -587,10 +593,10 @@ class _ResonatorStateTracker:
         """
         # This method can handle real single- and two-qubit gates, real q-r gates including MOVE,
         # and fictional two-qubit gates which it decomposes into real q-r gates.
-        new_instructions: list[Instruction] = []
+        new_instructions: list[CircuitOperation] = []
 
         for idx, inst in enumerate(instructions):
-            locus = inst.qubits
+            locus = inst.locus
             try:
                 validate_instruction(architecture=arch, instruction=inst)
                 # inst can be applied as is on locus, but we may first need to use MOVEs to make
@@ -828,11 +834,11 @@ def transpile_remove_moves(circuit: Circuit) -> Circuit:
     for inst in circuit.instructions:
         if inst.name == tracker.move_gate:
             # update the state tracking, drop the MOVE
-            tracker.apply_move(*inst.qubits)
+            tracker.apply_move(*inst.locus)
         else:
             # map the instruction locus
-            new_qubits = tracker.map_resonators_in_locus(inst.qubits)
+            new_locus = tracker.map_resonators_in_locus(inst.locus)
             new_instructions.append(
-                Instruction(name=inst.name, implementation=inst.implementation, qubits=new_qubits, args=inst.args)
+                CircuitOperation(name=inst.name, implementation=inst.implementation, locus=new_locus, args=inst.args)
             )
     return Circuit(name=circuit.name, instructions=tuple(new_instructions), metadata=circuit.metadata)

iqm/iqm_client/util.py

@@ -22,7 +22,7 @@ import numpy as np
 class IQMJSONEncoder(JSONEncoder):
     """JSONEncoder that that adds support for some non-JSON datatypes"""
 
-    def default(self, o: Any):
+    def default(self, o: Any):  # noqa: ANN201
         if isinstance(o, np.ndarray):
             return o.tolist()
         return JSONEncoder.default(self, o)

iqm/iqm_client/validation.py

@@ -13,14 +13,14 @@ import itertools
 from iqm.iqm_client.errors import CircuitValidationError
 from iqm.iqm_client.models import (
     _SUPPORTED_OPERATIONS,
-    Circuit,
     CircuitBatch,
     DynamicQuantumArchitecture,
-    Instruction,
     MoveGateValidationMode,
     QIRCode,
 )
 
+from iqm.pulse import Circuit, CircuitOperation
+
 
 def validate_qubit_mapping(
     architecture: DynamicQuantumArchitecture,
@@ -52,7 +52,7 @@ def validate_qubit_mapping(
     for i, circuit in enumerate(circuits):
         if isinstance(circuit, (QIRCode)):
             continue
-        diff = circuit.all_qubits() - set(qubit_mapping)
+        diff = circuit.all_locus_components() - set(qubit_mapping)
         if diff:
             raise CircuitValidationError(
                 f"The qubits {diff} in circuit '{circuit.name}' at index {i} "
@@ -112,7 +112,7 @@ def validate_circuit_instructions(
 
 def validate_instruction(
     architecture: DynamicQuantumArchitecture,
-    instruction: Instruction,
+    instruction: CircuitOperation,
     qubit_mapping: dict[str, str] | None = None,
 ) -> None:
     """Validate an instruction against the dynamic quantum architecture.
@@ -134,11 +134,11 @@ def validate_instruction(
         raise CircuitValidationError(f"Unknown quantum operation '{instruction.name}'.")
 
     # apply the qubit mapping if any
-    mapped_qubits = tuple(qubit_mapping[q] for q in instruction.qubits) if qubit_mapping else instruction.qubits
+    mapped_qubits = tuple(qubit_mapping[q] for q in instruction.locus) if qubit_mapping else instruction.locus
 
     def check_locus_components(allowed_components: Iterable[str], msg: str) -> None:
         """Checks that the instruction locus consists of the allowed components only."""
-        for q, mapped_q in zip(instruction.qubits, mapped_qubits):
+        for q, mapped_q in zip(instruction.locus, mapped_qubits):
             if mapped_q not in allowed_components:
                 raise CircuitValidationError(
                     f"{instruction!r}: Component {q} = {mapped_q} {msg}."
@@ -146,10 +146,14 @@ def validate_instruction(
                     else f"{instruction!r}: Component {q} {msg}."
                 )
 
-    if op_info.no_calibration_needed:
-        # all QPU loci are allowed
-        check_locus_components(architecture.components, msg="does not exist on the QPU")
-        return
+    impl_name = instruction.implementation or _SUPPORTED_OPERATIONS[
+        instruction.name
+    ].get_default_implementation_for_locus(instruction.locus)
+    if (impl := op_info.implementations.get(impl_name)) is not None:
+        if not impl.needs_calibration():
+            # all QPU loci are allowed
+            check_locus_components(architecture.components, msg="does not exist on the QPU")
+            return
 
     gate_info = architecture.gates.get(instruction.name)
     if gate_info is None:
@@ -187,13 +191,13 @@ def validate_instruction(
     )
     if mapped_qubits not in all_loci:
         raise CircuitValidationError(
-            f"{instruction.qubits} = {tuple(mapped_qubits)} is not allowed as locus for '{instruction_name}'"
+            f"{instruction.locus} = {tuple(mapped_qubits)} is not allowed as locus for '{instruction_name}'"
             if qubit_mapping
-            else f"{instruction.qubits} is not allowed as locus for '{instruction_name}'"
+            else f"{instruction.locus} is not allowed as locus for '{instruction_name}'"
         )
 
 
-def validate_circuit_moves(
+def validate_circuit_moves(  # noqa: PLR0912
     architecture: DynamicQuantumArchitecture,
     circuit: Circuit,
     qubit_mapping: dict[str, str] | None = None,
@@ -243,17 +247,17 @@ def validate_circuit_moves(
 
     for inst in circuit.instructions:
         if inst.name == "move":
-            qubit, resonator = inst.qubits
+            qubit, resonator = inst.locus
             if not (qubit in all_qubits and resonator in all_resonators):
                 raise CircuitValidationError(
-                    f"MOVE instructions are only allowed between qubit and resonator, not {inst.qubits}."
+                    f"MOVE instructions are only allowed between qubit and resonator, not {inst.locus}."
                 )
 
             if (resonator_qubit := resonator_occupations.get(resonator)) is None:
                 # Beginning MOVE: check that the qubit hasn't been moved to another resonator
                 if qubit in moved_qubits:
                     raise CircuitValidationError(
-                        f"MOVE instruction {inst.qubits}: state of {qubit} is "
+                        f"MOVE instruction {inst.locus}: state of {qubit} is "
                         f"in another resonator: {resonator_occupations}."
                     )
                 resonator_occupations[resonator] = qubit
@@ -262,16 +266,16 @@ def validate_circuit_moves(
                 # Ending MOVE: check that the qubit matches to the qubit that was moved to the resonator
                 if resonator_qubit != qubit:
                     raise CircuitValidationError(
-                        f"MOVE instruction {inst.qubits} to an already occupied resonator: {resonator_occupations}."
+                        f"MOVE instruction {inst.locus} to an already occupied resonator: {resonator_occupations}."
                     )
                 del resonator_occupations[resonator]
                 moved_qubits.remove(qubit)
         elif moved_qubits:
             # Validate that moved qubits are not used during MOVE operations
             if inst.name not in allowed_gates:
-                if overlap := set(inst.qubits) & moved_qubits:
+                if overlap := set(inst.locus) & moved_qubits:
                     raise CircuitValidationError(
-                        f"Instruction {inst.name} acts on {inst.qubits} while the state(s) of {overlap} "
+                        f"Instruction {inst.name} acts on {inst.locus} while the state(s) of {overlap} "
                         f"are in a resonator. Current resonator occupation: {resonator_occupations}."
                     )
 

iqm/qiskit_iqm/iqm_circuit.py

@@ -22,7 +22,7 @@ from qiskit import QuantumCircuit
 class IQMCircuit(QuantumCircuit):
     """Extends the QuantumCircuit class, adding a shortcut for applying the MOVE gate."""
 
-    def move(self, qubit: int, resonator: int):
+    def move(self, qubit: int, resonator: int):  # noqa: ANN201
         """Applies the MOVE gate to the circuit.
 
         Note: at this point the circuit layout is only guaranteed to work if the order

iqm/qiskit_iqm/iqm_circuit_validation.py

@@ -21,7 +21,7 @@ from iqm.qiskit_iqm.qiskit_to_iqm import serialize_instructions
 from qiskit import QuantumCircuit
 
 
-def validate_circuit(
+def validate_circuit(  # noqa: ANN201
     circuit: QuantumCircuit,
     backend: IQMBackendBase,
     validate_moves: MoveGateValidationMode | None = None,

iqm/qiskit_iqm/iqm_job.py

@@ -24,7 +24,6 @@ import warnings
 from iqm.iqm_client import (
     DEFAULT_TIMEOUT_SECONDS,
     APITimeoutError,
-    Circuit,
     CircuitMeasurementResults,
     HeraldingMode,
     IQMClient,
@@ -38,6 +37,8 @@ import numpy as np
 from qiskit.providers import JobStatus, JobV1
 from qiskit.result import Counts, Result
 
+from iqm.pulse import Circuit
+
 if TYPE_CHECKING:
     from iqm.qiskit_iqm.iqm_provider import IQMBackend
 
@@ -140,7 +141,7 @@ class IQMJob(JobV1):
             for s in range(shots)
         ]
 
-    def submit(self):
+    def submit(self):  # noqa: ANN201
         raise NotImplementedError(
             "You should never have to submit jobs by calling this method. When running circuits through "
             "RemoteIQMBackend, the submission will happen under the hood. The job instance that you get is only for "

iqm/qiskit_iqm/iqm_move_layout.py

@@ -101,7 +101,7 @@ class IQMMoveLayout(TrivialLayout):
                 return False
         return True
 
-    def run(self, dag: DAGCircuit):
+    def run(self, dag: DAGCircuit):  # noqa: ANN201
         """Creates a valid layout for the given quantum circuit.
 
         Args:
@@ -194,7 +194,7 @@ class IQMMoveLayout(TrivialLayout):
         resonators: set[int] = set()
         qubit_to_idx: dict[Qubit, int] = {qubit: log_idx for log_idx, qubit in enumerate(dag.qubits)}
 
-        def _require_qubit_type(qubit: Qubit, required_type: str):
+        def _require_qubit_type(qubit: Qubit, required_type: str):  # noqa: ANN202
             """Add a requirement for the given qubit."""
             log_idx = qubit_to_idx[qubit]
             if log_idx in resonators:
@@ -204,7 +204,7 @@ class IQMMoveLayout(TrivialLayout):
                 )
             reqs.setdefault(log_idx, set()).add(required_type)
 
-        def _require_resonator(qubit: Qubit):
+        def _require_resonator(qubit: Qubit):  # noqa: ANN202
             """Add a requirement for the given resonator."""
             log_idx = qubit_to_idx[qubit]
             if log_idx in reqs:

iqm/qiskit_iqm/iqm_provider.py

@@ -22,7 +22,6 @@ from uuid import UUID
 import warnings
 
 from iqm.iqm_client import (
-    Circuit,
     CircuitBatch,
     CircuitCompilationOptions,
     CircuitValidationError,
@@ -39,6 +38,8 @@ from iqm.qiskit_iqm.qiskit_to_iqm import serialize_instructions
 from qiskit import QuantumCircuit
 from qiskit.providers import JobStatus, JobV1, Options
 
+from iqm.pulse import Circuit
+
 try:
     __version__ = version("qiskit-iqm")
 except PackageNotFoundError:  # pragma: no cover

iqm/qiskit_iqm/iqm_target.py

@@ -93,7 +93,7 @@ class IQMTarget(Target):
         self.iqm_metrics = metrics
         self._add_instructions_from_DQA()
 
-    def _add_instructions_from_DQA(self):
+    def _add_instructions_from_DQA(self):  # noqa: ANN202
         """Initializes the Target with instructions and properties that represent the
         dynamic quantum architecture :attr:`iqm_dqa`.
 

iqm/qiskit_iqm/iqm_transpilation.py

@@ -129,7 +129,7 @@ class IQMOptimizeSingleQubitGates(TransformationPass):
 
         return dag
 
-    def _validate_ops(self, dag: DAGCircuit):
+    def _validate_ops(self, dag: DAGCircuit):  # noqa: ANN202
         valid_ops = self._basis + ["measure", "reset", "delay", "barrier"]
         for node in dag.op_nodes():
             if node.name not in valid_ops:
@@ -184,7 +184,7 @@ class IQMReplaceGateWithUnitaryPass(TransformationPass):
         self.gate = gate
         self.unitary = unitary
 
-    def run(self, dag):
+    def run(self, dag):  # noqa: ANN001, ANN201
         for node in dag.op_nodes():
             if node.name == self.gate:
                 dag.substitute_node(node, UnitaryGate(self.unitary))

iqm/qiskit_iqm/move_gate.py

@@ -53,12 +53,12 @@ class MoveGate(Gate):
        order ``[qubit, resonator]``, regardless of which component is currently holding the state.
     """
 
-    def __init__(self, label=None):
+    def __init__(self, label=None):  # noqa: ANN001
         """Initializes the move gate"""
         super().__init__("move", 2, [], label=label)
         self.unitary = qi.Operator(MOVE_GATE_UNITARY)
 
-    def _define(self):
+    def _define(self):  # noqa: ANN202
         """This function is purposefully not defined so that that the Qiskit transpiler cannot accidentally
         decompose the MOVE gate into a sequence of other gates, instead it will throw an error.
         """

iqm/qiskit_iqm/qiskit_to_iqm.py

@@ -17,15 +17,16 @@ from __future__ import annotations
 
 from collections.abc import Collection
 from dataclasses import dataclass
+from math import pi
 import re
 
-from iqm.iqm_client import Instruction
 from iqm.qiskit_iqm.move_gate import MoveGate
-import numpy as np
 from qiskit import QuantumCircuit as QiskitQuantumCircuit
 from qiskit.circuit import ClassicalRegister, Clbit, QuantumRegister
 from qiskit.transpiler.layout import Layout
 
+from iqm.pulse import CircuitOperation
+
 
 class InstructionNotSupportedError(RuntimeError):
     """Raised when a given instruction is not supported by the IQM server."""
@@ -94,7 +95,7 @@ class MeasurementKey:
 
 def serialize_instructions(  # noqa: PLR0912, PLR0915
     circuit: QiskitQuantumCircuit, qubit_index_to_name: dict[int, str], allowed_nonnative_gates: Collection[str] = ()
-) -> list[Instruction]:
+) -> list[CircuitOperation]:
     """Serialize a quantum circuit into the IQM data transfer format.
 
     This is IQM's internal helper for :meth:`.IQMBackend.serialize_circuit` that gives slightly more control.
@@ -116,32 +117,32 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
         ValueError: circuit contains an unsupported instruction or is not transpiled in general
 
     """
-    instructions: list[Instruction] = []
+    instructions: list[CircuitOperation] = []
     # maps clbits to the latest "measure" instruction to store its result there
-    clbit_to_measure: dict[Clbit, Instruction] = {}
+    clbit_to_measure: dict[Clbit, CircuitOperation] = {}
     for circuit_instruction in circuit.data:
         instruction = circuit_instruction.operation
-        qubit_names = [qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits]
+        qubit_names = tuple(qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits)
         if instruction.name == "r":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            phase_t = float(instruction.params[1] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": phase_t})
+            angle = float(instruction.params[0])
+            phase = float(instruction.params[1])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": phase})
         elif instruction.name == "x":
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": 0.5, "phase_t": 0.0})
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": pi, "phase": 0.0})
         elif instruction.name == "rx":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": 0.0})
+            angle = float(instruction.params[0])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": 0.0})
         elif instruction.name == "y":
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": 0.5, "phase_t": 0.25})
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": pi, "phase": 0.5 * pi})
         elif instruction.name == "ry":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": 0.25})
+            angle = float(instruction.params[0])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": 0.5 * pi})
         elif instruction.name == "cz":
-            native_inst = Instruction(name="cz", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="cz", locus=qubit_names, args={})
         elif instruction.name == "move":
-            native_inst = Instruction(name="move", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="move", locus=qubit_names, args={})
         elif instruction.name == "barrier":
-            native_inst = Instruction(name="barrier", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="barrier", locus=qubit_names, args={})
         elif instruction.name == "delay":
             duration = float(instruction.params[0])
             # convert duration to seconds
@@ -160,7 +161,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
                 duration *= 1e-12
             else:
                 raise ValueError(f"Delay: Unsupported unit '{unit}'")
-            native_inst = Instruction(name="delay", qubits=qubit_names, args={"duration": duration})
+            native_inst = CircuitOperation(name="delay", locus=qubit_names, args={"duration": duration})
         elif instruction.name == "measure":
             if len(circuit_instruction.clbits) != 1:
                 raise ValueError(
@@ -168,15 +169,15 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
                 )
             clbit = circuit_instruction.clbits[0]  # always a single-qubit measurement
             mk = str(MeasurementKey.from_clbit(clbit, circuit))
-            native_inst = Instruction(name="measure", qubits=qubit_names, args={"key": mk})
+            native_inst = CircuitOperation(name="measure", locus=qubit_names, args={"key": mk})
             clbit_to_measure[clbit] = native_inst
         elif instruction.name == "reset":
-            native_inst = Instruction(name="reset", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="reset", locus=qubit_names, args={})
         elif instruction.name == "id":
             continue
         elif instruction.name in allowed_nonnative_gates:
             args = {f"p{i}": param for i, param in enumerate(instruction.params)}
-            native_inst = Instruction.model_construct(name=instruction.name, qubits=tuple(qubit_names), args=args)
+            native_inst = CircuitOperation(name=instruction.name, locus=qubit_names, args=args)
         else:
             raise ValueError(
                 f"Instruction '{instruction.name}' in the circuit '{circuit.name}' is not natively supported. "
@@ -211,7 +212,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
             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.qubits[0]  # single-qubit measurement
+            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
 
@@ -220,7 +221,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
 
 
 def deserialize_instructions(
-    instructions: list[Instruction], qubit_name_to_index: dict[str, int], layout: Layout
+    instructions: list[CircuitOperation], qubit_name_to_index: dict[str, int], layout: Layout
 ) -> QiskitQuantumCircuit:
     """Helper function to turn a list of IQM Instructions into a Qiskit QuantumCircuit.
 
@@ -276,11 +277,11 @@ def deserialize_instructions(
         *(cl_regs.get(i, ClassicalRegister(0)) for i in range(max(cl_regs) + 1 if cl_regs else 0)),
     )
     for instr in instructions:
-        locus = [index_to_qiskit_qubit[qubit_name_to_index[q]] for q in instr.qubits]
+        locus = [index_to_qiskit_qubit[qubit_name_to_index[q]] for q in instr.locus]
         if instr.name == "prx":
-            angle_t = instr.args["angle_t"] * 2 * np.pi
-            phase_t = instr.args["phase_t"] * 2 * np.pi
-            circuit.r(angle_t, phase_t, locus[0])
+            angle = instr.args["angle"]
+            phase = instr.args["phase"]
+            circuit.r(angle, phase, locus[0])
         elif instr.name == "cz":
             circuit.cz(*locus)
         elif instr.name == "move":
@@ -294,11 +295,11 @@ def deserialize_instructions(
             duration = instr.args["duration"]
             circuit.delay(duration, locus, unit="s")  # native delay instructions always use seconds
         elif instr.name == "cc_prx":
-            angle_t = instr.args["angle_t"] * 2 * np.pi
-            phase_t = instr.args["phase_t"] * 2 * np.pi
+            angle = instr.args["angle"]
+            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_t, phase_t, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
+            circuit.r(angle, phase, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
         elif instr.name == "reset":
             for qubit in locus:
                 circuit.reset(qubit)