luna-quantum 1.0.8rc2__cp314-cp314-macosx_11_0_arm64.whl

luna_quantum/solve/parameters/algorithms/quantum_gate/flex_qaoa/config.py

@@ -0,0 +1,80 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+from luna_quantum.solve.errors.solve_base_error import SolveBaseError
+
+
+class MixerTypeError(SolveBaseError):
+    """Custom Mixer type exception."""
+
+    def __init__(self) -> None:
+        super().__init__("XY-mixer type can only occur once.")
+
+
+class XYMixer(BaseModel):
+    """XY-mixer configuration.
+
+    Attributes
+    ----------
+    types: list[Literal["even", "odd", "last"]]
+        XY-ring-mixer pipeline
+    """
+
+    types: list[Literal["even", "odd", "last"]] = Field(
+        default=["even", "odd", "last"],
+        description="XY-ring-mixer types and order.",
+    )
+
+    @field_validator("types")
+    @classmethod
+    def _validate_type_once(
+        cls, v: list[Literal["even", "odd", "last"]]
+    ) -> list[Literal["even", "odd", "last"]]:
+        if len(set(v)) < len(v):
+            raise MixerTypeError
+        return v
+
+
+class AdvancedConfig(BaseModel):
+    """Additional FlexQAOA algorithm configuration.
+
+    Attributes
+    ----------
+    mixer: XYMixer | Dict
+        Mixer types in XY-ring-mixer. Default: `["even", "odd", "last"]`
+    parallel_indicators: bool
+        Toggle to apply indicator functions in parallel. Does not affect sampling
+        performance of QAOA, but only circuit metrics, like number of qubits and
+        circuit depth.
+    discard_slack: bool
+        Discard slack qubits in evaluation, i.e. only measure on the binary variables of
+        the initial problem. This requires an auxilary cost function that penalizes
+        infeasible solutions.
+    infeas_penalty: float | None
+        Penalty for infeasible solutions if `discard_slack` is activated. By defalt,
+        10 times the max absolute intial bias is chosen.
+    """
+
+    mixer: XYMixer = Field(
+        default_factory=lambda: XYMixer(),
+        description='Mixer types in XY-ring-mixer. Default: `["even", "odd", "last"]`',
+    )
+    parallel_indicators: bool = Field(
+        default=True,
+        description="Toggle to apply indicator functions in parallel. Does not affect "
+        "sampling performance of QAOA, but only circuit metrics, "
+        "like number of qubits and circuit depth.",
+    )
+    discard_slack: bool = Field(
+        default=False,
+        description="Discard slack qubits in evaluation, i.e. only measure on the "
+        "binary variables of the initial problem. This requires an auxilary cost "
+        "function that penalizes infeasible solutions.",
+    )
+    infeas_penalty: float | None = Field(
+        default=None,
+        ge=0,
+        description="Penalty for infeasible solutions if `discard_slack` is activated."
+        "By defalt, 10 times the max absolute intial bias is chosen.",
+    )

luna_quantum/solve/parameters/algorithms/quantum_gate/flex_qaoa/flex_qaoa.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, model_validator
+
+from luna_quantum.solve.domain.abstract.luna_algorithm import LunaAlgorithm
+from luna_quantum.solve.errors.solve_base_error import SolveBaseError
+from luna_quantum.solve.parameters.algorithms.base_params.qaoa_circuit_params import (
+    BasicQAOAParams,
+    LinearQAOAParams,
+    RandomQAOAParams,
+)
+from luna_quantum.solve.parameters.algorithms.base_params.scipy_optimizer import (
+    ScipyOptimizerParams,
+)
+from luna_quantum.solve.parameters.backends.aqarios import Aqarios
+
+from .config import AdvancedConfig
+from .optimizers import (
+    CombinedOptimizerParams,
+    InterpolateOptimizerParams,
+    LinearOptimizerParams,
+)
+from .pipeline import PipelineParams
+
+
+class QAOAParameterOptimizerError(SolveBaseError):
+    """QAOA cirucit parameters mismatch with optimizer exception."""
+
+    def __init__(
+        self,
+        optimizer: ScipyOptimizerParams
+        | LinearOptimizerParams
+        | CombinedOptimizerParams
+        | InterpolateOptimizerParams
+        | None,
+        params: BasicQAOAParams | LinearQAOAParams | RandomQAOAParams,
+        extra: str = "",
+    ) -> None:
+        super().__init__(
+            f"Parameter Mismatch of {optimizer.__class__} and {params.__class__}"
+            + ((". " + extra) if extra else "")
+        )
+
+
+class InterpolateOptimizerError(SolveBaseError):
+    """Interpolate optimizer error when final number of reps is too small."""
+
+    def __init__(self, reps_end: int, reps_start: int) -> None:
+        super().__init__(f"{reps_end=} needs to be larger than {reps_start=}.")
+
+
+class QAOAParameterDepthMismatchError(SolveBaseError):
+    """QAOA circuit params mismatch the specified reps."""
+
+    def __init__(self, params_reps: int, reps: int) -> None:
+        super().__init__(f"{params_reps=} needs to match {reps=}.")
+
+
+class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
+    """The FlexQAOA Algorithm for constrained quantum optimization.
+
+    The FlexQAOA is an extension to the default QAOA with the capabilities to encode
+    inequality constriants with indicator functions as well as one-hot constraints
+    through XY-mixers. This algorithm will dynamically extract all constraints from the
+    given constraint input optimization model, and construct an accoring QAOA circuit.
+    Currently only simulation of the circuit is supported. But due to the constrained
+    nature, the subspace of the Hilbertspace required for simulation is smaller,
+    depending on the problem instance. This allows for simulation of problems with
+    more qubits than ordinary state vector simulation allows. For now, the simulation
+    size is limited to Hilbertspaces with less <= 2**18 dimensions.
+
+    The FlexQAOA allows for a dynamic circuit construction depending on input paramters.
+    Central to this is the pipeline parameter which allows for different configurations.
+
+    For instance, if one likes to explore ordinary QUBO simulation with all constraints
+    represented as quadratic penalties, the `one_hot` and `indicator_function` options
+    need to be manually disabled
+    ```
+    pipeline = {"one_hot": None, "indicator_function": None}
+    ```
+
+    If no indicator function is employed, but the input problem contains inequality
+    constraints, slack variables are added to the optimization problem. FlexQAOA allows
+    for a configuration that discards slack variables as their assignment is not
+    necessarily of interest. This option can be enbled by setting
+    ```
+    qaoa_config = {"discard_slack": True}
+    ```
+
+    Following the standard protocol for QAOA, a classical optimizer is required that
+    tunes the variational parameters of the circuit. Besides the classical
+    `ScipyOptimizer` other optimizers are also featured, allowing for optimizing only a
+    linear schedule, starting with optimizing for a linear schedule followed by
+    individual parameter fine tuning, and interpolating between different QAOA circuit
+    depts.
+
+    Attributes
+    ----------
+    shots: int
+        Number of sampled shots.
+    reps: int
+        Number of QAOA layer repetitions
+    pipeline: PipelineParams | Dict
+        The pipeline defines the selected features for QAOA circuit generation. By
+        default, all supported features are enabled (one-hot constraints, inequality
+        constraints and quadratic penalties).
+    optimizer: ScipyOptimizerParams | LinearOptimizerParams | CombinedOptimizerParams |\
+        InterpolateOptimizerParams | None | Dict
+        The classical optimizer for parameter tuning. Default: ScipyOptimizer. Setting
+        to `None` disables the optimization, leading to an evaluation of the initial
+        parameters.
+    qaoa_config: AdvancedConfig | Dict
+        Additional options for the QAOA circuit and evalutation
+    initial_params: LinearQAOAParams | BasicQAOAParams | RandomQAOAParams | Dict
+        Custom QAOA variational circuit parameters. By default linear
+        increasing/decreasing parameters for the selected `reps` are generated.
+    """
+
+    shots: int = Field(default=1024, ge=1, description="Number of sampled shots.")
+    reps: int = Field(default=1, ge=1, description="Number of QAOA layer repetitions")
+    pipeline: PipelineParams = Field(
+        default_factory=lambda: PipelineParams(),
+        description="The pipeline defines the selected features for QAOA circuit "
+        "generation. By default, all supported features are enabled "
+        "(one-hot constraints, inequality constraints and quadratic penalties).",
+    )
+    optimizer: (
+        ScipyOptimizerParams
+        | LinearOptimizerParams
+        | CombinedOptimizerParams
+        | InterpolateOptimizerParams
+        | None
+    ) = Field(
+        default_factory=lambda: ScipyOptimizerParams(),
+        description="The classical optimizer. Default: ScipyOptimizer",
+    )
+    qaoa_config: AdvancedConfig = Field(
+        default_factory=lambda: AdvancedConfig(),
+        description="Additional options for the QAOA circuit and evalutation",
+    )
+    initial_params: LinearQAOAParams | BasicQAOAParams | RandomQAOAParams = Field(
+        default_factory=lambda: LinearQAOAParams(delta_beta=0.5, delta_gamma=0.5),
+        description="Custom QAOA circuit parameters. By default linear "
+        "increasing/decreasing parameters for the selected `reps` are generated.",
+    )
+
+    @model_validator(mode="after")
+    def _check_param_type(self) -> FlexQAOA:
+        if isinstance(self.optimizer, LinearOptimizerParams) and isinstance(
+            self.initial_params, BasicQAOAParams
+        ):
+            raise QAOAParameterOptimizerError(self.optimizer, self.initial_params)
+        if isinstance(self.optimizer, CombinedOptimizerParams) and isinstance(
+            self.initial_params, BasicQAOAParams
+        ):
+            raise QAOAParameterOptimizerError(self.optimizer, self.initial_params)
+        if (
+            isinstance(self.optimizer, InterpolateOptimizerParams)
+            and isinstance(self.optimizer.optimizer, LinearOptimizerParams)
+            and isinstance(self.initial_params, BasicQAOAParams)
+        ):
+            raise QAOAParameterOptimizerError(
+                self.optimizer,
+                self.initial_params,
+                extra="LinearOptimizer used in InterpolateOptimizer.",
+            )
+        if (
+            isinstance(self.optimizer, InterpolateOptimizerParams)
+            and self.optimizer.reps_end < self.reps
+        ):
+            raise InterpolateOptimizerError(self.optimizer.reps_end, self.reps)
+        return self
+
+    @model_validator(mode="after")
+    def _check_depth(self) -> FlexQAOA:
+        if (
+            isinstance(self.initial_params, BasicQAOAParams)
+            and self.initial_params.reps != self.reps
+        ):
+            raise QAOAParameterDepthMismatchError(self.initial_params.reps, self.reps)
+        return self
+
+    @property
+    def algorithm_name(self) -> str:
+        """
+        Returns the name of the algorithm.
+
+        This abstract property method is intended to be overridden by subclasses.
+        It should provide the name of the algorithm being implemented.
+
+        Returns
+        -------
+        str
+            The name of the algorithm.
+        """
+        return "FlexQAOA"
+
+    @classmethod
+    def get_default_backend(cls) -> Aqarios:
+        """
+        Return the default backend implementation.
+
+        This property must be implemented by subclasses to provide
+        the default backend instance to use when no specific backend
+        is specified.
+
+        Returns
+        -------
+            IBackend
+                An instance of a class implementing the IBackend interface that serves
+                as the default backend.
+        """
+        return Aqarios()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[Aqarios]]:
+        """
+        Check at runtime if the used backend is compatible with the solver.
+
+        Returns
+        -------
+        tuple[type[IBackend], ...]
+            True if the backend is compatible with the solver, False otherwise.
+
+        """
+        return (Aqarios,)

luna_quantum/solve/parameters/algorithms/quantum_gate/flex_qaoa/optimizers.py

@@ -0,0 +1,99 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from luna_quantum.solve.parameters.algorithms.base_params.scipy_optimizer import (
+    ScipyOptimizerParams,
+)
+
+
+class LinearOptimizerParams(ScipyOptimizerParams):
+    """Optimizer for tuning a linear schedule of QAOA parameters.
+
+    Optimizes onyl two parameters: `delta_beta` and `delta_gamma` with the default
+    ScipyOptimizer.
+
+    Wrapper for scipy.optimize.minimize. See
+    [SciPy minimize documentation](
+    https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html)
+    for more information of the available methods and parameters.
+
+    Attributes
+    ----------
+    method: ScipyOptimizerMethod
+        Type of solver. See
+        [SciPy minimize documentation](
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html)
+        for supported methods.
+    tol: float | None
+        Tolerance for termination.
+    bounds: None | tuple[float, float] | list[tuple[float, float]]
+        Bounds on variables for Nelder-Mead, L-BFGS-B, TNC, SLSQP, Powell,
+        trust-constr, COBYLA, and COBYQA methods. None is used to specify no bounds,
+        `(min, max)` is used to specify bounds for all variables. A sequence of
+        `(min, max)` can be used to specify bounds for each parameter individually.
+    jac: None | Literal["2-point", "3-point", "cs"]
+        Method for computing the gradient vector. Only for CG, BFGS, Newton-CG,
+        L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg, trust-krylov, trust-exact and
+        trust-constr.
+    hess: None | Literal["2-point", "3-point", "cs"]
+        Method for computing the Hessian matrix. Only for Newton-CG, dogleg, trust-ncg,
+        trust-krylov, trust-exact and trust-constr.
+    maxiter: int
+        Maximum number of iterations to perform. Depending on the method
+        each iteration may use several function evaluations. Will be ignored for TNC
+        optimizer. Default: 100
+    options: dict[str, float]
+        A dictionary of solver options.
+    """
+
+    optimizer_type: Literal["linear"] = "linear"
+
+
+class CombinedOptimizerParams(BaseModel):
+    """Combination of LinearOptimizer and ScipyOptimizer.
+
+    Optimizer that first performs an optimization of the linear schedule and then
+    fine tunes individual parameters.
+
+
+    Attributes
+    ----------
+    linear: LinearOptimizerParams | Dict
+        Parameters of the linear optimizer.
+    fine_tune: ScipyOptimizerParams | Dict
+        Parameters of the fine tuning optimizer.
+    """
+
+    optimizer_type: Literal["combined"] = "combined"
+    linear: LinearOptimizerParams = Field(
+        default_factory=lambda: LinearOptimizerParams()
+    )
+    fine_tune: ScipyOptimizerParams = Field(
+        default_factory=lambda: ScipyOptimizerParams()
+    )
+
+
+class InterpolateOptimizerParams(BaseModel):
+    """Optimizer with sequentially increasing number of QAOA layers.
+
+    Optimizer that starts with `reps` iteration and interpolates sequentially in
+    `reps_step` steps to `reps_end`. In between it performs a full optimization routine
+    tunes individual parameters.
+
+    Attributes
+    ----------
+    optimiezr: LinearOptimizerParams | ScipyOptimizerParams | Dict
+        Parameters of the optimizer.
+    reps_step: int
+        Number of QAOA layers added for one interpolation.
+    reps_end: int
+        Final number of QAOA layers to be reached.
+    """
+
+    optimizer_type: Literal["interpolate"] = "interpolate"
+    optimizer: ScipyOptimizerParams | LinearOptimizerParams = Field(
+        default_factory=lambda: ScipyOptimizerParams()
+    )
+    reps_step: int = Field(default=1, ge=1)
+    reps_end: int = Field(default=10, ge=1)

luna_quantum/solve/parameters/algorithms/quantum_gate/flex_qaoa/pipeline.py

@@ -0,0 +1,87 @@
+from pydantic import BaseModel, Field
+
+
+class OneHotParams(BaseModel):
+    """Implements one-hot constraints through XY-mixers."""
+
+
+class IndicatorFunctionParams(BaseModel):
+    """Implements inequality constraints via indicator functions.
+
+    Attributes
+    ----------
+    penalty: float | None
+        Custom penalty factor for indicator functions. If none set, automatically
+        determined through upper and lower bounds.
+    penalty_scaling: float
+        Scaling of automatically determined penalty factor. Default: 2
+    """
+
+    penalty: float | None = Field(
+        default=None,
+        ge=0,
+        description="Custom penalty factor for indicator functions. If none set, "
+        "automatically determined through upper and lower bounds.",
+    )
+    penalty_scaling: float = Field(
+        default=2,
+        ge=0,
+        description="Scaling of automatically determined penalty factor. Default: 2",
+    )
+
+
+class QuadraticPenaltyParams(BaseModel):
+    """Implements all constraints through quadratic penalties.
+
+    Adds penalty terms to the objective. Adds slack variables for inequality constraints
+    if neccessaray.
+
+    Attributes
+    ----------
+    penalty: float | None
+        Custom penalty factor for quadratic penalty terms. If none is set, it is
+        automatically determined by taking 10 times the maximum absolute initial bias.
+    """
+
+    penalty: float | None = Field(
+        default=None,
+        ge=0,
+        description="Custom penalty factor for quadratic penalty terms. If none set, "
+        "automatically determined by taking 10 times the maximum absolute initial "
+        "bias.",
+    )
+
+
+class PipelineParams(BaseModel):
+    """Defines the modular Constrained QAOA Pipeline.
+
+    By default all features are enabled.
+
+    Attributes
+    ----------
+    indicator_function: IndicatorFunctionParams | Dict | None
+        Whether to implement inequality constraints with indicator functions. Disable
+        with setting to `None`.
+    one_hot: OneHotParams | Dict | None
+        Whether to implement inequality constraints with indicator functions. Disable
+        with setting to `None`.
+    quadratic_penalty: QuadraticPenaltyParams | Dict | None
+        Whether to implement inequality constraints with indicator functions. Disable
+        with setting to `None`.
+    """
+
+    indicator_function: IndicatorFunctionParams | None = Field(
+        default_factory=lambda: IndicatorFunctionParams(),
+        description="Whether to implement inequality constraints with indicator "
+        "functions. Disable with setting to `None`.",
+    )
+    one_hot: OneHotParams | None = Field(
+        default_factory=lambda: OneHotParams(),
+        description="Whether to implement inequality constraints with indicator "
+        "functions. Disable with setting to `None`.",
+    )
+    quadratic_penalty: QuadraticPenaltyParams | None = Field(
+        default_factory=lambda: QuadraticPenaltyParams(),
+        description="Whether to implement inequality constraints with indicator "
+        "functions. Disable with setting to `None`.",
+    )

luna_quantum/solve/parameters/algorithms/quantum_gate/qaoa.py

@@ -0,0 +1,102 @@
+from pydantic import Field
+
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.algorithms.base_params.qaoa_circuit_params import (
+    BasicQAOAParams,
+    LinearQAOAParams,
+    RandomQAOAParams,
+)
+from luna_quantum.solve.parameters.algorithms.base_params.scipy_optimizer import (
+    ScipyOptimizerParams,
+)
+from luna_quantum.solve.parameters.backends import AWS, IBM, IQM, IonQ, Rigetti
+
+
+class QAOA(LunaAlgorithm[AWS | IonQ | IQM | Rigetti | IBM]):
+    """
+    Quantum Approximate Optimization Algorithm (QAOA).
+
+    QAOA is a hybrid quantum-classical algorithm for solving combinatorial optimization
+    problems. It works by preparing a quantum state through alternating applications of
+    problem-specific (cost) and mixing Hamiltonians, controlled by variational
+    parameters that are optimized classically to maximize the probability of measuring
+    the optimal solution.
+
+    QAOA is particularly suited for problems that can be encoded as quadratic
+    unconstrained binary optimization (QUBO) or Ising models, such as MaxCut, TSP, and
+    portfolio optimization.
+
+    Attributes
+    ----------
+    reps : int
+        Number of QAOA layers (p). Each layer consists of applying both the cost and
+        mixing Hamiltonians with different variational parameters. Higher values
+        generally lead to better solutions but increase circuit depth and quantum
+        resources required. Default is 1.
+    shots : int
+        Number of measurement samples to collect per circuit execution. Higher values
+        reduce statistical noise but increase runtime. Default is 1024.
+    optimizer : ScipyOptimizerParams | Dict
+        Configuration for the classical optimization routine that updates the
+        variational parameters. Default is a ScipyOptimizer instance with default
+        settings. See ScipyOptimizerParams class for details of contained parameters.
+    initial_params: LinearQAOAParams | BasicQAOAParams | RandomQAOAParams | Dict
+        Custom QAOA variational circuit parameters. By default linear
+        increasing/decreasing parameters for the selected `reps` are generated.
+    """
+
+    reps: int = Field(default=1, ge=1)
+    shots: int = Field(default=1024, ge=1)
+    optimizer: ScipyOptimizerParams = Field(
+        default_factory=lambda: ScipyOptimizerParams()
+    )
+    initial_params: RandomQAOAParams | BasicQAOAParams | LinearQAOAParams = Field(
+        default_factory=lambda: LinearQAOAParams(delta_beta=0.5, delta_gamma=0.5)
+    )
+
+    @property
+    def algorithm_name(self) -> str:
+        """
+        Returns the name of the algorithm.
+
+        This abstract property method is intended to be overridden by subclasses.
+        It should provide the name of the algorithm being implemented.
+
+        Returns
+        -------
+        str
+            The name of the algorithm.
+        """
+        return "QAOA"
+
+    @classmethod
+    def get_default_backend(cls) -> AWS | IonQ | IQM | Rigetti | IBM:
+        """
+        Return the default backend implementation.
+
+        This property must be implemented by subclasses to provide
+        the default backend instance to use when no specific backend
+        is specified.
+
+        Returns
+        -------
+            IBackend
+                An instance of a class implementing the IBackend interface that serves
+                as the default backend.
+        """
+        return IBM()
+
+    @classmethod
+    def get_compatible_backends(
+        cls,
+    ) -> tuple[type[AWS | IonQ | IQM | Rigetti | IBM], ...]:
+        """
+        Check at runtime if the used backend is compatible with the solver.
+
+        Returns
+        -------
+        tuple[type[IBackend], ...]
+            True if the backend is compatible with the solver, False otherwise.
+
+        """
+        return AWS, IonQ, IQM, Rigetti, IBM

luna_quantum/solve/parameters/algorithms/quantum_gate/qaoa_fo.py

@@ -0,0 +1,69 @@
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends import Qctrl
+
+
+class QAOA_FO(LunaAlgorithm[Qctrl]):  # noqa: N801
+    """
+    Quantum Approximate Optimization Algorithm via Fire Opal (QAOA_FO).
+
+    QAOA_FO is Q-CTRL's implementation of the Quantum Approximate Optimization Algorithm
+    (QAOA) through their Fire Opal framework. It is a hybrid quantum-classical algorithm
+    for solving combinatorial optimization problems with enhanced performance through
+    Q-CTRL's error mitigation and control techniques. For more details, please refer
+    to the `Fire Opal QAOA documentation <https://docs.q-ctrl.com/fire-opal/execute/run-algorithms/solve-optimization-problems/fire-opals-qaoa-solver>`_.
+
+    The algorithm works by preparing a quantum state through alternating applications of
+    problem-specific (cost) and mixing Hamiltonians, controlled by variational
+    parameters that are optimized classically to maximize the probability of measuring
+    the optimal solution.
+
+    QAOA_FO leverages Q-CTRL's expertise in quantum control to improve circuit fidelity
+    and optimization performance. It is particularly suited for problems that can be
+    encoded as quadratic unconstrained binary optimization (QUBO) or Ising models,
+    such as MaxCut, TSP, and portfolio optimization.
+    """
+
+    @property
+    def algorithm_name(self) -> str:
+        """
+        Returns the name of the algorithm.
+
+        This abstract property method is intended to be overridden by subclasses.
+        It should provide the name of the algorithm being implemented.
+
+        Returns
+        -------
+        str
+            The name of the algorithm.
+        """
+        return "QAOA_FO"
+
+    @classmethod
+    def get_default_backend(cls) -> Qctrl:
+        """
+        Return the default backend implementation.
+
+        This property must be implemented by subclasses to provide
+        the default backend instance to use when no specific backend
+        is specified.
+
+        Returns
+        -------
+            IBackend
+                An instance of a class implementing the IBackend interface that serves
+                as the default backend.
+        """
+        return Qctrl()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[Qctrl]]:
+        """
+        Check at runtime if the used backend is compatible with the solver.
+
+        Returns
+        -------
+        tuple[type[IBackend], ...]
+            True if the backend is compatible with the solver, False otherwise.
+
+        """
+        return (Qctrl,)