qilisdk 0.1.8__cp312-cp312-macosx_10_9_x86_64.whl

qilisdk/functionals/sampling_result.py

@@ -0,0 +1,92 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+import heapq
+import operator
+from pprint import pformat
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class SamplingResult(FunctionalResult):
+    """Store shot counts and derived probabilities for a sampling experiment."""
+
+    def __init__(self, nshots: int, samples: dict[str, int]) -> None:
+        """
+        Args:
+            nshots (int): Total number of circuit evaluations.
+            samples (dict[str, int]): Mapping from bitstring to observed counts.
+
+        Raises:
+            ValueError: If ``samples`` is empty or contains bitstrings with different length.
+        """
+        self._nshots = nshots
+        self._samples = samples
+
+        # Ensure samples is not empty and is correct.
+        if not samples:
+            raise ValueError("The samples dictionary is empty.")
+        bitstrings = list(samples.keys())
+        nqubits = len(bitstrings[0])
+        if not all(len(bitstring) == nqubits for bitstring in bitstrings):
+            raise ValueError("Not all bitstring keys have the same length.")
+
+        # Assign nqubits to attribute
+        self._nqubits = nqubits
+
+        # Calculate probabilities
+        self._probabilities = {
+            bitstring: counts / self._nshots if self._nshots > 0 else 0.0 for bitstring, counts in self._samples.items()
+        }
+
+    @property
+    def nshots(self) -> int:
+        """Total number of repetitions used to gather samples."""
+        return self._nshots
+
+    @property
+    def nqubits(self) -> int:
+        """Number of qubits inferred from the sample bitstrings."""
+        return self._nqubits
+
+    @property
+    def samples(self) -> dict[str, int]:
+        """Return a copy of the raw sample counts."""
+        return dict(self._samples)
+
+    @property
+    def probabilities(self) -> dict[str, float]:
+        """Return a copy of the estimated probability distribution."""
+        return dict(self._probabilities)
+
+    def get_probability(self, bitstring: str) -> float:
+        """Return the probability associated with ``bitstring`` (0.0 if unseen)."""
+        return self._probabilities.get(bitstring, 0.0)
+
+    def get_probabilities(self, n: int | None = None) -> list[tuple[str, float]]:
+        """
+        Args:
+            n (int | None): Maximum number of items to return. Defaults to all outcomes.
+
+        Returns:
+            list[tuple[str, float]]: the ``n`` most probable bitstrings in descending probability order.
+        """
+        if n is None:
+            n = len(self._probabilities)
+        return heapq.nlargest(n, self._probabilities.items(), key=operator.itemgetter(1))
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(\n  nshots={self.nshots},\n  samples={pformat(self.samples)}\n)"

qilisdk/functionals/time_evolution.py

@@ -0,0 +1,111 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+from typing import ClassVar
+
+from qilisdk.analog.hamiltonian import Hamiltonian, PauliOperator
+from qilisdk.analog.schedule import Schedule
+from qilisdk.core.qtensor import QTensor
+from qilisdk.core.types import RealNumber
+from qilisdk.core.variables import ComparisonTerm
+from qilisdk.functionals.functional import PrimitiveFunctional
+from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class TimeEvolution(PrimitiveFunctional[TimeEvolutionResult]):
+    """
+    Simulate the dynamics induced by a time-dependent Hamiltonian schedule.
+
+    Example:
+        .. code-block:: python
+
+            from qilisdk.analog import Schedule, Hamiltonian, Z
+            from qilisdk.core import ket
+            from qilisdk.functionals.time_evolution import TimeEvolution
+
+            h0 = Z(0)
+            schedule = Schedule(hamiltonians={"h0": h0}, total_time=10.0)
+            functional = TimeEvolution(schedule, observables=[Z(0), X(0)], initial_state=ket(0))
+    """
+
+    result_type: ClassVar[type[TimeEvolutionResult]] = TimeEvolutionResult
+
+    def __init__(
+        self,
+        schedule: Schedule,
+        observables: list[PauliOperator | Hamiltonian],
+        initial_state: QTensor,
+        nshots: int = 1000,
+        store_intermediate_results: bool = False,
+    ) -> None:
+        """
+        Args:
+            schedule (Schedule): Annealing or control schedule describing the Hamiltonian evolution.
+            observables (list[PauliOperator | Hamiltonian]): Observables measured at the end of the evolution.
+            initial_state (QTensor): Quantum state used as the simulation starting point.
+            nshots (int, optional): Number of executions for statistical estimation. Defaults to 1000.
+            store_intermediate_results (bool, optional): Keep intermediate states if produced by the backend. Defaults to False.
+
+        Raises:
+            ValueError: if the number of qubits of the initial state doesn't match the number of qubits in the schedule.
+        """
+        super().__init__()
+        self.initial_state = initial_state
+        self.schedule = schedule
+        self.observables = observables
+        self.nshots = nshots
+        self.store_intermediate_results = store_intermediate_results
+
+        if initial_state.nqubits != schedule.nqubits:
+            raise ValueError(
+                f"The initial state provided acts on {initial_state.nqubits} qubits while the schedule acts on {schedule.nqubits} qubits"
+            )
+
+    @property
+    def nparameters(self) -> int:
+        """Return the number of schedule parameters."""
+        return self.schedule.nparameters
+
+    def get_parameters(self) -> dict[str, RealNumber]:
+        """Return the schedule parameters and their current value."""
+        return self.schedule.get_parameters()
+
+    def set_parameters(self, parameters: dict[str, RealNumber]) -> None:
+        """Update a subset of schedule parameters."""
+        self.schedule.set_parameters(parameters)
+
+    def get_parameter_names(self) -> list[str]:
+        """Return order-stable parameter labels from the schedule."""
+        return self.schedule.get_parameter_names()
+
+    def get_parameter_values(self) -> list[RealNumber]:
+        """Return parameter values in the order provided by ``get_parameter_names``."""
+        return self.schedule.get_parameter_values()
+
+    def set_parameter_values(self, values: list[float]) -> None:
+        """Assign all schedule parameters according to ``get_parameter_names`` order."""
+        self.schedule.set_parameter_values(values)
+
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
+        """Return current bounds for schedule parameters."""
+        return self.schedule.get_parameter_bounds()
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        """Update bounds for selected schedule parameters."""
+        self.schedule.set_parameter_bounds(ranges)
+
+    def get_constraints(self) -> list[ComparisonTerm]:
+        """Return the parameter constraints defined within the underlying schedule."""
+        return self.schedule.get_constraints()

qilisdk/functionals/time_evolution_result.py

@@ -0,0 +1,91 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+from pprint import pformat
+
+import numpy as np
+
+from qilisdk.core.model import Model
+from qilisdk.core.qtensor import QTensor
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.settings import get_settings
+from qilisdk.yaml import yaml
+
+
+def _complex_dtype() -> np.dtype:
+    return get_settings().complex_precision.dtype
+
+
+@yaml.register_class
+class TimeEvolutionResult(FunctionalResult):
+    """Container for expectation values and states produced by a time-evolution simulation."""
+
+    def __init__(
+        self,
+        final_expected_values: np.ndarray | None = None,
+        expected_values: np.ndarray | None = None,
+        final_state: QTensor | None = None,
+        intermediate_states: list[QTensor] | None = None,
+    ) -> None:
+        """
+        Args:
+            final_expected_values (np.ndarray | None, optional): Expectation values evaluated at the end of the evolution.
+            expected_values (np.ndarray | None, optional): Time series of expectation values, if recorded.
+            final_state (QTensor | None, optional): Final quantum state associated with the evolution.
+            intermediate_states (list[QTensor] | None, optional): Intermediate states captured during the evolution.
+        """
+        super().__init__()
+        self._final_expected_values = (
+            final_expected_values if final_expected_values is not None else np.array([], dtype=_complex_dtype())
+        )
+        self._expected_values = expected_values if expected_values is not None else np.array([], dtype=_complex_dtype())
+        self._final_state = final_state
+        self._intermediate_states = intermediate_states or []
+
+    @property
+    def final_expected_values(self) -> np.ndarray:
+        """Final expectation values measured at the end of the evolution."""
+        return self._final_expected_values
+
+    @property
+    def expected_values(self) -> np.ndarray:
+        """Expectation values tracked over the course of the evolution."""
+        return self._expected_values
+
+    @property
+    def final_state(self) -> QTensor | None:
+        """Final quantum state if provided by the backend."""
+        return self._final_state
+
+    @property
+    def intermediate_states(self) -> list[QTensor]:
+        """List of intermediate quantum states captured during the simulation."""
+        return self._intermediate_states
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(\n"
+            + f"  final_expected_values={pformat(self.final_expected_values)},\n"
+            + (f"  expected_values={pformat(self.expected_values)}\n" if len(self.expected_values) > 0 else "")
+            + (f"  final_state={pformat(self.final_state)}\n" if self.final_state is not None else "")
+            + (
+                f"  intermediate_states={pformat(self.intermediate_states)}\n"
+                if len(self.intermediate_states) > 0
+                else ""
+            )
+            + ")"
+        )
+
+    def compute_cost(self, cost_model: Model) -> float:
+        raise NotImplementedError

qilisdk/functionals/variational_program.py

@@ -0,0 +1,138 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+from __future__ import annotations
+
+import functools
+import operator
+from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
+
+from qilisdk.core.variables import BaseVariable, Parameter
+from qilisdk.functionals.functional import Functional, PrimitiveFunctional
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.functionals.variational_program_result import VariationalProgramResult
+from qilisdk.yaml import yaml
+
+if TYPE_CHECKING:
+    from qilisdk.core.variables import ComparisonTerm
+    from qilisdk.cost_functions.cost_function import CostFunction
+    from qilisdk.optimizers.optimizer import Optimizer
+
+TFunctional = TypeVar("TFunctional", bound=PrimitiveFunctional[FunctionalResult])
+
+
+@yaml.register_class
+class VariationalProgram(Functional, Generic[TFunctional]):
+    """
+    Bundle a parameterized functional, optimizer, and cost function into a variational loop.
+
+    Example:
+        .. code-block:: python
+
+            program = VariationalProgram(functional, optimizer, cost_function)
+    """
+
+    result_type: ClassVar[type[FunctionalResult]] = VariationalProgramResult
+
+    def __init__(
+        self,
+        functional: TFunctional,
+        optimizer: Optimizer,
+        cost_function: CostFunction,
+        store_intermediate_results: bool = False,
+        parameter_constraints: list[ComparisonTerm] | None = None,
+    ) -> None:
+        """
+        Args:
+            functional (PrimitiveFunctional): Parameterized functional to optimize.
+            optimizer (Optimizer): Optimization routine controlling parameter updates.
+            cost_function (CostFunction): Metric used to evaluate functional executions.
+            store_intermediate_results (bool, optional): Persist intermediate executions if requested by the optimizer.
+            parameter_constraints (list[ComparisonTerm] | None): Optional constraints on parameter values that are
+                enforced before optimizer updates are applied.
+
+        Raises:
+            ValueError: if the user applies constraints on parameters that are not present in the variational program.
+                        Or the constraints contain Objects that are not parameters.
+        """
+        self._functional = functional
+        self._optimizer = optimizer
+        self._cost_function = cost_function
+        self._store_intermediate_results = store_intermediate_results
+        parameter_constraints = parameter_constraints or []
+        functional_params = self._functional.get_parameters()
+        for p in parameter_constraints:
+            if not p.lhs.is_parameterized_term() or not p.rhs.is_parameterized_term():
+                raise ValueError("Only parameters are allowed to be constrained.")
+            variables = p.variables()
+            for v in variables:
+                if v.label not in functional_params:
+                    raise ValueError(
+                        f"Writing a constraint on the parameter ({v}) that is not present in the variational program "
+                    )
+        self._parameter_constraints = parameter_constraints
+
+    @property
+    def functional(self) -> TFunctional:
+        """Return the wrapped functional that will be optimised."""
+        return self._functional
+
+    @property
+    def optimizer(self) -> Optimizer:
+        """Return the optimizer responsible for parameter updates."""
+        return self._optimizer
+
+    @property
+    def cost_function(self) -> CostFunction:
+        """Return the cost function applied to functional results."""
+        return self._cost_function
+
+    @property
+    def store_intermediate_results(self) -> bool:
+        """Indicate whether intermediate execution data should be stored."""
+        return self._store_intermediate_results
+
+    def get_constraints(self) -> list[ComparisonTerm]:
+        """Return variational-program-level constraints plus those from the underlying functional."""
+        return self._parameter_constraints + self._functional.get_constraints()
+
+    def _check_constraints(self, parameters: dict[str, float]) -> list[bool]:
+        """Evaluate each constraint with a proposed parameter set.
+
+        Returns:
+            list[bool]: list of booleans that correspond to whether each constraint is satisfied or not.
+
+        Raises:
+            ValueError: if the parameter is not defined in the underlying functional.
+        """
+        params: list[BaseVariable] = functools.reduce(
+            operator.iadd, (con.variables() for con in self.get_constraints()), []
+        )
+        params = list(set(params))
+        if any(not isinstance(p, Parameter) for p in params):
+            raise ValueError("Only Parameters are allowed.")
+        params_dict = {p.label: p for p in params}
+        evaluate_dict: dict[BaseVariable, float] = {}
+        functional_params = self._functional.get_parameters()
+        for label, value in parameters.items():
+            if label not in functional_params:
+                raise ValueError(f"Parameter {label} is not defined in the functional.")
+            if label in params_dict:
+                evaluate_dict[params_dict[label]] = value
+        constraints = self.get_constraints()
+        return [con.evaluate(evaluate_dict) for con in constraints]
+
+    def check_parameter_constraints(self, parameters: dict[str, float]) -> int:
+        """Return a penalty-like score (0 if valid) indicating how many constraints are violated."""
+        const_list = self._check_constraints(parameters)
+        return sum((100 if not con else 0) for con in const_list)

qilisdk/functionals/variational_program_result.py

@@ -0,0 +1,69 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+
+from pprint import pformat
+from typing import Generic, TypeVar
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.optimizers.optimizer_result import OptimizerIntermediateResult, OptimizerResult
+from qilisdk.yaml import yaml
+
+TResult_co = TypeVar("TResult_co", bound=FunctionalResult, covariant=True)
+
+
+@yaml.register_class
+class VariationalProgramResult(FunctionalResult, Generic[TResult_co]):
+    """Aggregate the optimizer summary and best functional result from a variational run."""
+
+    def __init__(self, optimizer_result: OptimizerResult, result: TResult_co) -> None:
+        """
+        Args:
+            optimizer_result (OptimizerResult): Summary produced by the optimiser.
+            result (TResult_co): Functional result evaluated at the final parameters.
+        """
+        super().__init__()
+        self._optimizer_result = optimizer_result
+        self._result = result
+
+    @property
+    def optimal_cost(self) -> float:
+        """Best cost reported by the optimiser."""
+        return self._optimizer_result.optimal_cost
+
+    @property
+    def optimal_execution_results(self) -> TResult_co:
+        """Return the functional result evaluated at the optimal parameters."""
+        return self._result
+
+    @property
+    def optimal_parameters(self) -> list[float]:
+        """Optimised parameter values."""
+        return self._optimizer_result.optimal_parameters
+
+    @property
+    def intermediate_results(self) -> list[OptimizerIntermediateResult]:
+        """Sequence of intermediate optimiser snapshots, if recorded."""
+        return self._optimizer_result.intermediate_results
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(\n"
+            f"  Optimal Cost={self.optimal_cost},\n"
+            f"  Optimal Parameters={pformat(self.optimal_parameters)},\n"
+            f"  Intermediate Results={pformat(self.intermediate_results)},\n"
+            f"  Optimal Results={pformat(self.optimal_execution_results)}\n"
+            ")"
+        )

qilisdk/logging_config.yaml

@@ -0,0 +1,16 @@
+sinks:
+  - sink: stderr
+    level: WARNING
+    format: "<fg #7f1cdb>QiliSDK</> | <green>{time:YYYY-MM-DD at HH:mm:ss}</green> | <lvl>{level}</> | <lvl>{level.icon} {message}</>"
+    filter: qilisdk
+    colorize: true
+
+intercept_libraries:
+  - name: httpx
+    level: ERROR
+  - name: httpcore
+    level: ERROR
+  - name: keyring
+    level: ERROR
+  - name: matplotlib
+    level: ERROR

qilisdk/noise/__init__.py

@@ -0,0 +1,56 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+from .amplitude_damping import AmplitudeDamping
+from .bit_flip import BitFlip
+from .dephasing import Dephasing
+from .depolarizing import Depolarizing
+from .gaussian_perturbation import GaussianPerturbation
+from .noise import Noise
+from .noise_config import NoiseConfig
+from .noise_model import NoiseModel
+from .offset_perturbation import OffsetPerturbation
+from .parameter_perturbation import ParameterPerturbation
+from .pauli_channel import PauliChannel
+from .phase_flip import PhaseFlip
+from .protocols import (
+    SupportsStaticKraus,
+    SupportsStaticLindblad,
+    SupportsTimeDerivedKraus,
+    SupportsTimeDerivedLindblad,
+)
+from .readout_assignment import ReadoutAssignment
+from .representations import KrausChannel, LindbladGenerator
+
+__all__ = [
+    "AmplitudeDamping",
+    "BitFlip",
+    "Dephasing",
+    "Depolarizing",
+    "GaussianPerturbation",
+    "KrausChannel",
+    "LindbladGenerator",
+    "Noise",
+    "NoiseConfig",
+    "NoiseModel",
+    "OffsetPerturbation",
+    "ParameterPerturbation",
+    "PauliChannel",
+    "PhaseFlip",
+    "ReadoutAssignment",
+    "SupportsStaticKraus",
+    "SupportsStaticLindblad",
+    "SupportsTimeDerivedKraus",
+    "SupportsTimeDerivedLindblad",
+]

qilisdk/noise/amplitude_damping.py

@@ -0,0 +1,71 @@
+# Copyright 2026 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+from __future__ import annotations
+
+import numpy as np
+
+from qilisdk.core import QTensor
+
+from .noise import Noise
+from .protocols import AttachmentScope, SupportsStaticLindblad, SupportsTimeDerivedKraus
+from .representations import KrausChannel, LindbladGenerator
+from .utils import _sigma_minus
+
+
+class AmplitudeDamping(Noise, SupportsTimeDerivedKraus, SupportsStaticLindblad):
+    """Amplitude damping noise model for energy relaxation."""
+
+    def __init__(self, *, t1: float) -> None:
+        """Args:
+            t1 (float): Relaxation time constant (must be > 0).
+
+        Raises:
+            ValueError: If t1 is not positive.
+        """
+        if t1 <= 0:
+            raise ValueError("t1 must be > 0.")
+        self._t1 = float(t1)
+
+    @property
+    def t1(self) -> float:
+        """Return the relaxation time constant.
+
+        Returns:
+            float: The t1 value.
+        """
+        return self._t1
+
+    def as_lindblad(self) -> LindbladGenerator:
+        gamma = 1.0 / self._t1
+        L = np.sqrt(gamma) * _sigma_minus()
+        return LindbladGenerator([QTensor(L)])
+
+    def as_kraus_from_duration(self, *, duration: float) -> KrausChannel:
+        if duration < 0:
+            raise ValueError("duration must be >= 0.")
+        gamma = 1.0 - float(np.exp(-duration / self._t1))
+        K0 = np.array([[1.0, 0.0], [0.0, np.sqrt(1.0 - gamma)]], dtype=complex)
+        K1 = np.array([[0.0, np.sqrt(gamma)], [0.0, 0.0]], dtype=complex)
+        return KrausChannel(operators=[QTensor(K0), QTensor(K1)])
+
+    @classmethod
+    def allowed_scopes(cls) -> frozenset[AttachmentScope]:
+        return frozenset(
+            {
+                AttachmentScope.GLOBAL,
+                AttachmentScope.PER_QUBIT,
+                AttachmentScope.PER_GATE_TYPE,
+                AttachmentScope.PER_GATE_TYPE_PER_QUBIT,
+            }
+        )