iqm-pulse 9.20.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

iqm/pulse/gates/__init__.py

@@ -24,6 +24,7 @@ Likewise, a single GateImplementation subclass can be sometimes used to implemen
 through different calibration data.
 """
 
+import copy
 from dataclasses import replace
 
 from iqm.pulse.gate_implementation import GateImplementation
@@ -44,7 +45,7 @@ from iqm.pulse.gates.cz import (
     FluxPulseGate_CRF_CRF,
     FluxPulseGate_TGSS_CRF,
 )
-from iqm.pulse.gates.default_gates import _quantum_ops_library
+from iqm.pulse.gates.default_gates import _default_implementations, _quantum_ops_library
 from iqm.pulse.gates.delay import Delay
 from iqm.pulse.gates.flux_multiplexer import FluxMultiplexer_SampleLinear
 from iqm.pulse.gates.measure import Measure_Constant, Measure_Constant_Qnd, Shelved_Measure_Constant
@@ -75,7 +76,7 @@ from iqm.pulse.gates.u import UGate, get_unitary_u
 from iqm.pulse.quantum_ops import QuantumOp, QuantumOpTable
 
 _exposed_implementations: dict[str, type[GateImplementation]] = {
-    cls.__name__: cls  # type: ignore[misc]
+    cls.__name__: cls
     for cls in (
         Barrier,
         Constant_PRX_with_smooth_rise_fall,
@@ -120,7 +121,7 @@ _exposed_implementations: dict[str, type[GateImplementation]] = {
 
 def get_implementation_class(class_name: str) -> type[GateImplementation] | None:
     """Get gate implementation class by class name."""
-    return _exposed_implementations.get(class_name, None)
+    return _exposed_implementations.get(class_name)
 
 
 def expose_implementation(implementation: type[GateImplementation], overwrite: bool = False) -> None:
@@ -138,219 +139,102 @@ def expose_implementation(implementation: type[GateImplementation], overwrite: b
     _exposed_implementations[name] = implementation
 
 
-def _compare_operations(op1: QuantumOp, op2: QuantumOp) -> bool:
-    """Compares two QuantumOp instances. Operations are different only if certain parameters do not match.
-    (everything else except the implementations information which the user is allowed to modify and
-    :attr:`QuatumOp.unitary` the equality of which cannot be validated as it is a free-form function).
-
-    Args:
-        op1: First QuantumOp instance
-        op2: Second QuantumOp instance
-
-    Returns:
-        True if the operations have identical parameters, False otherwise
-
-    """
-    IGNORED_FIELDS = {"implementations", "defaults_for_locus", "unitary"}
-    op1_dict = vars(op1)
-    op2_dict = vars(op2)
-    return all(
-        (op1_dict[field] == op2_dict[field] or (field == "params" and tuple(op1_dict[field]) == tuple(op2_dict[field])))
-        for field in op1_dict
-        if field not in IGNORED_FIELDS
-    )
-
-
-def _validate_operation(
-    new_op: QuantumOp,
-    gate_name: str,
-    operations: QuantumOpTable,
-    overwrite: bool = False,
-) -> QuantumOp:
-    """Validate new operation against existing operations and set unitary if needed.
+def _validate_implementation(
+    op_name: str,
+    impl_name: str,
+    impl_class_name: str,
+) -> None:
+    """Check that canonical implementation names cannot be overridden.
 
     Args:
-        new_op: Operation to validate
-        gate_name: Name of the gate
-        operations: Dictionary containing existing operations
-        overwrite: Whether to allow overwriting existing operations
-
-    Returns:
-        Validated QuantumOp with unitary set if needed
+        op_name: Name of the operation.
+        impl_name: Name of the new implementation.
+        impl_class_name: Name of the GateImplementation class it maps to.
 
     Raises:
-        ValueError: If operation exists with different parameters and overwrite is False
-
-    """
-    if not overwrite and gate_name in operations:
-        old = operations.get(gate_name)
-        same = _compare_operations(new_op, old)  # type: ignore[arg-type]
-        if not same:
-            raise ValueError(f"{gate_name} already registered with different parameters")
-
-    if gate_name in _quantum_ops_library:
-        default = _quantum_ops_library.get(gate_name)
-        same = _compare_operations(new_op, default)  # type: ignore[arg-type]
-        if not same:
-            raise ValueError(f"{gate_name} conflicts with a canonical operation in iqm-pulse")
-
-    if new_op.unitary is None:
-        if gate_name in operations and operations[gate_name].unitary is not None:
-            unitary = operations[gate_name].unitary
-        elif gate_name in _quantum_ops_library and _quantum_ops_library[gate_name].unitary is not None:
-            unitary = default.unitary  # type: ignore[union-attr]
-        else:
-            unitary = None
-        new_op = replace(new_op, unitary=unitary)
-
-    return new_op
-
-
-def _register_gate(
-    operations: QuantumOpTable,
-    gate_name: str,
-    impl_class: type[GateImplementation],
-    quantum_op_specs: QuantumOp | dict | None = None,
-) -> QuantumOp:
-    """Create the quantum operation for the new gate.
-
-    Args:
-        operations: Known operations, mapping gate names to QuantumOps
-        gate_name: Name of the gate to register
-        impl_class: The implementation class
-        quantum_op_specs: The quantum operation specifications
-
-    Returns:
-        The instance of the new quantum operation
+        ValueError: A canonical implementation name is being redefined.
 
     """
-    if isinstance(quantum_op_specs, QuantumOp):
-        new_op = quantum_op_specs
-    elif quantum_op_specs is None and gate_name in operations:
-        new_op = operations[gate_name]
-    else:
-        new_kwargs = {
-            "name": gate_name,
-            "arity": 1,
-            "params": tuple(),
-            "implementations": {},
-            "symmetric": impl_class.symmetric,
-            "factorizable": False,
-        }
-        if quantum_op_specs:
-            new_kwargs |= quantum_op_specs
-            new_kwargs["params"] = tuple(new_kwargs.get("params", ()))  # type: ignore[arg-type]
+    default_implementations = _default_implementations.get(op_name, {})
 
-        new_op = QuantumOp(**new_kwargs)  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]  # type: ignore[arg-type]
+    # check if the implementation name is canonical for this op
+    if (impl_class := default_implementations.get(impl_name)) is not None:
+        if impl_class_name != impl_class.__name__:
+            raise ValueError(
+                f"'{op_name}': '{impl_name}' is a reserved implementation name that refers to "
+                f"'{impl_class.__name__}', and cannot be overridden. "
+                "Consider renaming your implementation."
+            )
 
-    return new_op
 
-
-def _add_implementation(
+def register_operation(
     operations: dict[str, QuantumOp],
-    new_op: QuantumOp,
-    impl_name: str,
-    impl_class: type[GateImplementation],
-    set_as_default: bool = False,
+    op: QuantumOp,
     overwrite: bool = False,
 ) -> None:
-    """Register a new implementation for an existing quantum operation.
-
-    Args:
-        operations: Table of existing quantum operations
-        new_op: The new quantum operation
-        impl_name: The name for the implementation that is added
-        impl_class: The GateImplementation class corresponding to the new implementation
-        set_as_default: Whether to set as default implementation
-        overwrite: If True, allows replacing existing implementation
-
-    Returns:
-        new_op: QuantumOp with the new implementation
-
-    """
-    new_op.implementations[impl_name] = impl_class
-    _validate_implementation(operations, new_op, impl_name, impl_class)
-    if set_as_default and len(new_op.implementations) >= 1:
-        new_op.set_default_implementation(impl_name)
-    if not get_implementation_class(impl_class.__name__):
-        expose_implementation(impl_class, overwrite)
-
-    return new_op  # type: ignore[return-value]
-
-
-def _validate_implementation(
-    operations: QuantumOpTable,
-    new_op: QuantumOp,
-    impl_name: str,
-    impl_class: type[GateImplementation],
-) -> None:
-    """Validate new implementation against existing implementations.
+    """Register a new QuantumOp to the given operations table.
 
     Args:
-        operations: Table of quantum operations
-        new_op: Operation whose implementation we want to validate
-        impl_name: Name of the new implementation
-        impl_class: The GateImplementation class corresponding to the new
-        implementation
+        operations: Known operations, to which the new operation is added.
+        op: Definition for the new operation.
+        overwrite: If True, allows replacing an existing operation in ``operations``.
 
     Raises:
-        ValueError: If there is already an implementation with the same name, but
-        corresponds to a different implementation class.
+        ValueError: ``op.name`` exists in ``operations`` and ``overwrite==False``.
+        ValueError: ``op.name`` is the name of a canonical operation in iqm-pulse.
 
     """
-    if new_op.name in _quantum_ops_library:
-        default_op = _quantum_ops_library[new_op.name]
-        for default_impl_name, default_impl_cls in default_op.implementations.items():
-            if impl_name == default_impl_name:
-                default_impl_cls_name = (
-                    default_impl_cls if isinstance(default_impl_cls, str) else default_impl_cls.__name__
-                )
-                if impl_class.__name__ != default_impl_cls_name:
-                    raise ValueError(
-                        f"The implementation '{default_impl_name}' already exists in default implementations with '{default_impl_cls.__name__}' as corresponding GateImplementation class."  # noqa: E501
-                    )
-
-    if new_op.name in operations:
-        existing_op = operations[new_op.name]
-        for existing_impl_name, existing_impl_cls in existing_op.implementations.items():
-            if impl_name == existing_impl_name:
-                existing_impl_cls_name = (
-                    existing_impl_cls if isinstance(existing_impl_cls, str) else existing_impl_cls.__name__
-                )  # noqa: E501
-                if impl_class.__name__ != existing_impl_cls_name:
-                    raise ValueError(
-                        f"The implementation '{existing_impl_name}' already exists with '{existing_impl_cls.__name__}' as corresponding GateImplementation class."  # noqa: E501
-                    )
+    if op.name in operations and not overwrite:
+        raise ValueError(f"'{op.name}' already registered.")
+    if op.name in _quantum_ops_library:
+        raise ValueError(f"'{op.name}' conflicts with a canonical operation in iqm-pulse. Use a different name.")
+
+    # make a deep copy since the dicts inside QuantumOp are mutable
+    operations[op.name] = copy.deepcopy(op)
 
 
 def register_implementation(
     operations: dict[str, QuantumOp],
-    gate_name: str,
+    op_name: str,
     impl_name: str,
     impl_class: type[GateImplementation],
+    *,
     set_as_default: bool = False,
     overwrite: bool = False,
-    quantum_op_specs: QuantumOp | dict | None = None,
 ) -> None:
-    """Register a new gate implementation, and a new gate (operation) if needed.
+    """Register a new GateImplementation.
 
     Args:
-        operations: Known operations, mapping gate names to QuantumOps
-        gate_name: The gate name to register
-        impl_name: The name for this implementation
-        impl_class: The implementation class
-        set_as_default: Whether to set as default implementation
-        overwrite: If True, allows replacing existing operation/implementation
-        quantum_op_specs: Specs for creating new quantum op if needed
+        operations: Known operations, to which the new implementation is added.
+        op_name: Name of the operation under which the implementation is registered.
+        impl_name: Name of the implementation to register.
+        impl_class: Implementation class to register.
+        set_as_default: Whether to set as the default implementation for ``op_name``.
+        overwrite: If True, allows replacing an existing implementation.
 
     Raises:
-        ValueError: If operation/implementation exists and overwrite=False
+        ValueError: ``op_name`` does not exist in ``operations``.
+        ValueError: The implementation exists and ``overwrite==False``.
+
 
     """
-    new_op = _register_gate(operations, gate_name, impl_class, quantum_op_specs)
+    if (op := operations.get(op_name)) is None:
+        raise ValueError(f"Operation '{op_name}' is not known, register it first.")
 
-    new_op = _validate_operation(new_op, gate_name, operations, overwrite)
+    # canonical implementation names must not be overridden
+    _validate_implementation(op_name, impl_name, impl_class.__name__)
+
+    # only overwrite existing implementations with permission
+    if (old_class := op.implementations.get(impl_name)) is not None and not overwrite:
+        if old_class is not impl_class:
+            # cannot change an existing implementation name
+            raise ValueError(f"'{op_name}' already has an implementation named '{impl_name}'.")
+    else:
+        # add the new implementation
+        op.implementations[impl_name] = impl_class
 
-    _add_implementation(operations, new_op, impl_name, impl_class, set_as_default, overwrite)
+    if set_as_default:
+        op.set_default_implementation(impl_name)
 
-    operations[gate_name] = new_op
+    if get_implementation_class(impl_class.__name__) is None:
+        expose_implementation(impl_class, overwrite=overwrite)

iqm/pulse/gates/conditional.py

@@ -32,6 +32,8 @@ class CCPRX_Composite(CompositeGate):
     Uses the default implementation of PRX underneath, so no extra calibration is needed.
     """
 
+    registered_gates = ("prx",)
+
     parameters = {"control_delays": Parameter("", "Control delays", "s", collection_type=CollectionType.NDARRAY)}
     """``control_delays`` contains the times it takes for the classical control signal from each
     probe line (readout instrument) to become usable for the drive AWG implementing the PRX gate.
@@ -81,7 +83,7 @@ class CCPRX_Composite(CompositeGate):
         pulse_instruction = ConditionalInstruction(
             duration=pulse.duration, condition=default_label, outcomes=(wait, pulse)
         )
-        delays = self.builder.get_calibration(self.parent.name, self.name, self.locus)["control_delays"]
+        delays = self.calibration_data["control_delays"]
         if len(delays) == 0:
             raise ValueError(f"'control_delays' for '{self.name}' on {qubit} is empty (not calibrated).")
 

iqm/pulse/gates/cz.py

@@ -100,7 +100,7 @@ class FluxPulseGate(GateImplementation):
         builder: ScheduleBuilder,
     ):
         super().__init__(parent, name, locus, calibration_data, builder)
-        duration = calibration_data["duration"]
+        duration = calibration_data["duration"]  # shared between all pulses
         flux_pulses = {}
 
         def build_flux_pulse(waveform_class: type[Waveform], component_name: str, cal_node_name: str) -> None:
@@ -110,14 +110,11 @@ class FluxPulseGate(GateImplementation):
                 calibration_data[cal_node_name],
                 self.parameters[cal_node_name],  # type: ignore[arg-type]
                 builder.channels[flux_channel],
-                duration,
+                duration=duration,
             )
-            # TODO convert_calibration_data should be able to do this too
-            n_samples = builder.channels[flux_channel].duration_to_int_samples(duration) if duration > 0 else 0
-            params["n_samples"] = n_samples
             amplitude = params.pop("amplitude")
             flux_pulses[flux_channel] = FluxPulse(
-                duration=n_samples,
+                duration=params["n_samples"],
                 wave=waveform_class(**params),
                 scale=amplitude,
             )
@@ -283,8 +280,7 @@ class CouplerFluxPulseQubitACStarkPulseGate(GateImplementation):
         builder: ScheduleBuilder,
     ):
         super().__init__(parent, name, locus, calibration_data, builder)
-
-        duration = calibration_data["duration"]
+        duration = calibration_data["duration"]  # shared between all pulses
         flux_pulses = {}
         qubit_drive_pulses = {}
         rz = calibration_data["rz"]
@@ -296,13 +292,11 @@ class CouplerFluxPulseQubitACStarkPulseGate(GateImplementation):
                 calibration_data[cal_node_name],
                 self.parameters[cal_node_name],  # type: ignore[arg-type]
                 builder.channels[flux_channel],
-                duration,
+                duration=duration,
             )
-            n_samples = builder.channels[flux_channel].duration_to_int_samples(duration) if duration > 0 else 0
-            params["n_samples"] = n_samples
             amplitude = params.pop("amplitude")
             flux_pulses[flux_channel] = FluxPulse(
-                duration=n_samples,
+                duration=params["n_samples"],
                 wave=waveform_class(**params),
                 scale=amplitude,
             )
@@ -314,10 +308,8 @@ class CouplerFluxPulseQubitACStarkPulseGate(GateImplementation):
                 calibration_data[cal_node_name],
                 self.parameters[cal_node_name],  # type: ignore[arg-type]
                 builder.channels[drive_channel],
-                duration,
+                duration=duration,
             )
-            n_samples = builder.channels[drive_channel].duration_to_int_samples(duration) if duration > 0 else 0
-            params["n_samples"] = n_samples
             params["phase_increment"] = rz[component_name]
             qubit_drive_pulses[drive_channel] = self._ac_stark_pulse(**params)
 

iqm/pulse/gates/default_gates.py

@@ -11,7 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""This file defines the default quantum gates and operations for IQM's pulse control system"""
+"""Canonical quantum operations and implementations provided by iqm-pulse."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -53,11 +57,13 @@ from iqm.pulse.gates.rz import (
 )
 from iqm.pulse.gates.sx import SXGate
 from iqm.pulse.gates.u import UGate, get_unitary_u
-from iqm.pulse.quantum_ops import QuantumOp, QuantumOpTable
+from iqm.pulse.quantum_ops import QuantumOp
 
-"""A collection of mappings between default implementation names and their GateImplementation classes,
-for different gates."""
-_default_implementations = {
+if TYPE_CHECKING:
+    from iqm.pulse.gate_implementation import GateImplementation
+
+
+_default_implementations: dict[str, dict[str, type[GateImplementation]]] = {
     "barrier": {"": Barrier},
     "delay": {"wait": Delay},
     "measure": {
@@ -99,119 +105,10 @@ _default_implementations = {
     "reset_wait": {"reset_wait": Reset_Wait},
     "flux_multiplexer": {"sample_linear": FluxMultiplexer_SampleLinear},
 }
+"""Canonical implementation names for the canonical quantum operations.
+A collection of mappings between default implementation names and their GateImplementation classes,
+for different gates."""
 
-"""A table of quantum operations (`_default_operations`) defining characteristics:
-    - Number of qubits involved (arity)
-    - Required parameters
-    - GateImplementation classes
-    - Unitary matrices where applicable
-    - Properties like symmetry and factorizability
-This table is here so that we retain information about operations, even though they might 
-be deleted in the future.
-"""
-_default_operations: QuantumOpTable = {
-    op.name: op
-    for op in [
-        QuantumOp(
-            "barrier",
-            0,
-            implementations=_default_implementations["barrier"],  # type: ignore[arg-type]
-            symmetric=True,
-        ),
-        QuantumOp(
-            "delay",
-            0,
-            ("duration",),
-            implementations=_default_implementations["delay"],  # type: ignore[arg-type]
-            symmetric=True,
-        ),
-        QuantumOp(
-            "measure",
-            0,
-            ("key",),
-            implementations=_default_implementations["measure"],  # type: ignore[arg-type]
-            factorizable=True,
-        ),
-        QuantumOp(
-            "prx",
-            1,
-            ("angle", "phase"),
-            implementations=_default_implementations["prx"],  # type: ignore[arg-type]
-            unitary=get_unitary_prx,
-        ),
-        QuantumOp(
-            "prx_12",
-            1,
-            ("angle", "phase"),
-            implementations=_default_implementations["prx_12"],  # type: ignore[arg-type]
-        ),
-        QuantumOp(
-            "u",
-            1,
-            ("theta", "phi", "lam"),
-            implementations=_default_implementations["u"],  # type: ignore[arg-type]
-            unitary=get_unitary_u,
-        ),
-        QuantumOp(
-            "sx",
-            1,
-            implementations=_default_implementations["sx"],  # type: ignore[arg-type]
-            unitary=lambda: get_unitary_prx(np.pi / 2, 0),
-        ),
-        QuantumOp(
-            "rz",
-            1,
-            ("angle",),
-            implementations=_default_implementations["rz"],  # type: ignore[arg-type]
-            unitary=get_unitary_rz,
-        ),
-        QuantumOp(
-            "rz_physical",
-            1,
-            implementations=_default_implementations["rz_physical"],  # type: ignore[arg-type]
-        ),
-        QuantumOp(
-            "cz",
-            2,
-            (),
-            implementations=_default_implementations["cz"],  # type: ignore[arg-type]
-            symmetric=True,
-            unitary=lambda: np.diag([1.0, 1.0, 1.0, -1.0]),
-        ),
-        QuantumOp(
-            "move",
-            2,
-            implementations=_default_implementations["move"],  # type: ignore[arg-type]
-        ),
-        QuantumOp(
-            "cc_prx",
-            1,
-            ("angle", "phase", "feedback_qubit", "feedback_key"),
-            implementations=_default_implementations["cc_prx"],  # type: ignore[arg-type]
-        ),
-        QuantumOp(
-            "reset",
-            0,
-            implementations=_default_implementations["reset"],  # type: ignore[arg-type]
-            symmetric=True,
-            factorizable=True,
-        ),
-        QuantumOp(
-            "reset_wait",
-            0,
-            implementations=_default_implementations["reset_wait"],  # type: ignore[arg-type]
-            symmetric=True,
-            factorizable=True,
-        ),
-        QuantumOp(
-            "flux_multiplexer",
-            0,
-            implementations=_default_implementations["flux_multiplexer"],  # type: ignore[arg-type]
-        ),
-    ]
-}
-
-"""A library for all canonical Quantum Operations (gates)"""
 _quantum_ops_library = {
     op.name: op
     for op in [
@@ -313,3 +210,6 @@ _quantum_ops_library = {
         ),
     ]
 }
+"""Library of the current canonical quantum operations provided by iqm-pulse."""
+# NOTE If a canonical operation is removed in the future, consider adding a second dict for former
+# canonical operations so that we retain information about them.

iqm/pulse/gates/flux_multiplexer.py

@@ -9,7 +9,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from copy import deepcopy
 
 from iqm.models.playlist.waveforms import Samples
@@ -170,7 +170,7 @@ class FluxMultiplexer_SampleLinear(GateImplementation):
 
     @classmethod
     def get_custom_locus_mapping(
-        cls, chip_topology: ChipTopology, component_to_channels: dict[str, Iterable[str]]
+        cls, chip_topology: ChipTopology, component_to_channels: Mapping[str, Iterable[str]]
     ) -> dict[tuple[str, ...] | frozenset[str], tuple[str, ...]] | None:
         """Locus is "global" (the whole QPU) represented by an empty tuple for now."""
         # pylint: disable=unused-argument