luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/parameters/algorithms/genetic_algorithms/saga.py

@@ -0,0 +1,139 @@
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends import DWave
+from luna_quantum.solve.parameters.constants import DEFAULT_ATOL, DEFAULT_RTOL
+
+
+class SAGA(LunaAlgorithm[DWave]):
+    """
+    Simulated Annealing Genetic Algorithm (SAGA).
+
+    SAGA combines genetic algorithms with simulated annealing to enhance optimization.
+    While QAGA uses quantum annealing, SAGA uses classical simulated annealing for the
+    mutation and recombination operations, making it more accessible while still
+    providing benefits over standard genetic algorithms.
+
+    The algorithm maintains a population of solutions that evolve through selection,
+    annealing-enhanced recombination, and mutation operations across generations.
+
+    Attributes
+    ----------
+    p_size : int
+        Initial population size (number of candidate solutions). Default is 20.
+    p_inc_num : int
+        Number of new individuals added to the population after each generation.
+        Default is 5.
+    p_max : int | None
+        Maximum population size. Once reached, no more growth occurs.
+        Default is 160.
+    pct_random_states : float
+        Percentage of random states added to the population after each iteration.
+        Default is 0.25 (25%).
+    mut_rate : float
+        Mutation rate - probability to mutate an individual after each iteration.
+        Default is 0.5. Must be between 0.0 and 1.0.
+    rec_rate : int
+        Recombination rate - number of mates each individual is recombined with
+        per generation. Default is 1.
+    rec_method : Literal["cluster_moves", "one_point_crossover", "random_crossover"]
+        Method used for recombining individuals. Default is "random_crossover".
+    select_method : Literal["simple", "shared_energy"]
+        Selection strategy for the next generation. Default is "simple".
+    target : Union[float, None]
+        Target energy level to stop the algorithm. Default is None.
+    atol : float
+        Absolute tolerance when comparing energies to target.
+        Default is DEFAULT_ATOL.
+    rtol : float
+        Relative tolerance when comparing energies to target.
+        Default is DEFAULT_RTOL.
+    timeout : float
+        Maximum runtime in seconds. Default is 60.0 seconds.
+    max_iter : int | None
+        Maximum number of generations before stopping. Default is 100.
+    num_sweeps: int
+        Initial number of sweeps for simulated annealing in the first iteration.
+        Default is 10.
+    num_sweeps_inc_factor: float
+        Factor by which to increase num_sweeps after each iteration.
+        Default is 1.2 (20% increase per iteration).
+    num_sweeps_inc_max: Optional[int]
+        Maximum number of sweeps that may be reached when increasing the num_sweeps.
+        Default is 7,000.
+    beta_range_type: Literal["default", "percent", "fixed", "inc"]
+        Method used to compute the temperature range (beta range) for annealing.
+        Default is "default".
+    beta_range: Optional[Tuple[float, float]]
+        Explicit beta range (inverse temperature) used with beta_range_type "fixed" or
+        "percent". Default is None.
+    """
+
+    p_size: int = 20
+    p_inc_num: int = 5
+    p_max: int | None = 160
+    pct_random_states: float = 0.25
+    mut_rate: float = Field(default=0.5, ge=0.0, le=1.0)
+    rec_rate: int = 1
+    rec_method: Literal["cluster_moves", "one_point_crossover", "random_crossover"] = (
+        "random_crossover"
+    )
+    select_method: Literal["simple", "shared_energy"] = "simple"
+    target: float | None = None
+    atol: float = DEFAULT_ATOL
+    rtol: float = DEFAULT_RTOL
+    timeout: float = 60.0
+    max_iter: int | None = 100
+
+    num_sweeps: int = 10
+    num_sweeps_inc_factor: float = 1.2
+    num_sweeps_inc_max: int | None = 7_000
+    beta_range_type: Literal["default", "percent", "fixed", "inc"] = "default"
+    beta_range: tuple[float, float] | None = None
+
+    @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 "SAGA+"
+
+    @classmethod
+    def get_default_backend(cls) -> DWave:
+        """
+        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 DWave()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[DWave], ...]:
+        """
+        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 (DWave,)

luna_quantum/solve/parameters/algorithms/lq_fda/__init__.py

@@ -0,0 +1,3 @@
+from .fujitsu_da_v3c import FujitsuDA
+
+__all__ = ["FujitsuDA"]

luna_quantum/solve/parameters/algorithms/lq_fda/fujits_da_base.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends import Fujitsu
+
+
+class FujitsuDABase(LunaAlgorithm[Fujitsu]):
+    """Fujitsu Digital Annealer base parameters.
+
+    Parameters
+    ----------
+    scaling_action: Literal["NOTHING", "SCALING", "AUTO_SCALING"]
+        Method for scaling ``qubo`` and determining temperatures:
+        - "NOTHING": No action (use parameters exactly as specified)
+        - "SCALING": ``scaling_factor`` is multiplied to ``qubo``,
+          ``temperature_start``, ``temperature_end`` and ``offset_increase_rate``.
+        - "AUTO_SCALING": A maximum scaling factor w.r.t. ``scaling_bit_precision``
+          is multiplied to ``qubo``, ``temperature_start``, ``temperature_end`` and
+          ``offset_increase_rate``.
+    scaling_factor: int | float
+        Multiplicative factor applied to model coefficients, temperatures, and other
+        parameters: the ``scaling_factor`` for ``qubo``, ``temperature_start``,
+        ``temperature_end`` and ``offset_increase_rate``.
+        Higher values can improve numerical precision but may lead to overflow.
+        Default is 1.0 (no scaling).
+    scaling_bit_precision: int
+        Maximum bit precision to use when scaling. Determines the maximum allowable
+        coefficient magnitude. Default is 64, using full double precision.
+    random_seed: Union[int, None]
+        Seed for random number generation to ensure reproducible results.
+        Must be between 0 and 9_999. Default is None (random seed).
+    penalty_factor: float
+        Penalty factor used to scale the equality constraint penalty function,
+        default 1.0.
+    inequality_factor: int
+        Penalty factor used to scale the inequality constraints, default 1.
+    remove_ohg_from_penalty: bool
+        If equality constraints, identified to be One-Hot constraints are only
+        considered within one-hot groups (`remove_ohg_from_penalty=True`), i.e.,
+        identified one-hot constraints are not added to the penalty function,
+        default True.
+    """
+
+    scaling_action: Literal["NOTHING", "SCALING", "AUTO_SCALING"] = "NOTHING"
+    scaling_factor: int | float = 1.0
+    scaling_bit_precision: int = 64
+    random_seed: int | None = Field(default=None, ge=0, le=9_999)
+
+    penalty_factor: float = 1.0
+    inequality_factor: int = 1
+    remove_ohg_from_penalty: bool = True
+
+    @classmethod
+    def get_default_backend(cls) -> Fujitsu:
+        """
+        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 Fujitsu()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[Fujitsu], ...]:
+        """
+        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 (Fujitsu,)

luna_quantum/solve/parameters/algorithms/lq_fda/fujitsu_da_v3c.py

@@ -0,0 +1,155 @@
+from pydantic import Field
+
+from .fujits_da_base import FujitsuDABase
+
+
+class FujitsuDA(FujitsuDABase):
+    """
+    Parameters for the Fujitsu Digital Annealer (v3c).
+
+    Attributes
+    ----------
+    time_limit_sec: int | None
+        Maximum running time of DA in seconds. Specifies the upper limit of running
+        time of DA. Time_limit_sec should be selected according to problem hardness
+        and size (number of bits). Min: 1, Max: 3600
+    target_energy: int | None
+        Threshold energy for fast exit. This may not work correctly if the specified
+        value is larger than its max value or lower than its min value.
+        Min: -99_999_999_999, Max: 99_999_999_999
+    num_group: int
+        Number of independent optimization processes. Increasing the number of
+        independent optimization processes leads to better coverage of the search
+        space. Note: Increasing this number requires to also increase time_limit_sec
+        such that the search time for each process is sufficient.
+        Default: 1, Min: 1, Max: 16
+    num_solution: int
+        Number of solutions maintained and updated by each optimization process.
+        Default: 16, Min: 1, Max: 1024
+    num_output_solution: int
+        Maximal number of the best solutions returned by each optimization.
+        Total number of results is ``num_solution`` * ``num_group``.
+        Default: 5, Min: 1, Max: 1024
+    gs_num_iteration_factor: int
+        Maximal number of iterations in one epoch of the global search in each
+        optimization is ``gs_num_iteration_factor`` * *number of bits*.
+        Default: 5, Min: 0, Max: 100
+    gs_num_iteration_cl: int
+        Maximal number of iterations without improvement in one epoch of the global
+        search in each optimization before terminating and continuing with the next
+        epoch. For problems with very deep local minima having a very low value is
+        helpful. Default: 800, Min: 0, Max: 1000000
+    gs_ohs_xw1h_num_iteration_factor: int
+        Maximal number of iterations in one epoch of the global search in each
+        optimization is ``gs_ohs_xw1h_num_iteration_factor`` * *number of bits*.
+        Only used when 1Hot search is defined. Default: 3, Min: 0, Max: 100
+    gs_ohs_xw1h_num_iteration_cl: int
+        Maximal number of iterations without improvement in one epoch of the global
+        search in each optimization before terminating and continuing with the next
+        epoch. For problems with very deep local minima having a very low value is
+        helpful. Only used when 1Hot search is defined.
+        Default: 100, Min: 0, Max: 1000000
+    ohs_xw1h_internal_penalty: int | str
+        Mode of 1hot penalty constraint generation.
+        - 0: internal penalty generation off: 1hot constraint as part of penalty
+             polynomial required
+        - 1: internal penalty generation on: 1hot constraint not as part of penalty
+             polynomial required
+        If 1way 1hot constraint or a 2way 1hot constraint is specified,
+        ``ohs_xw1h_internal_penalty`` = 1 is recommended.
+        Default: 0, Min: 0, Max: 1
+    gs_penalty_auto_mode: int
+        Parameter to choose whether to automatically incrementally adapt
+        ``gs_penalty_coef`` to the optimal value.
+        - 0: Use ``gs_penalty_coef`` as the fixed factor to weight the penalty
+             polynomial during optimization.
+        - 1: Start with ``gs_penalty_coef`` as weight factor for penalty polynomial
+             and automatically and incrementally increase this factor during
+             optimization by multiplying ``gs_penalty_inc_rate`` / 100 repeatedly
+             until ``gs_max_penalty_coef`` is reached or the penalty energy iszero.
+        Default: 1, Min: 0, Max: 1
+    gs_penalty_coef: int
+        Factor to weight the penalty polynomial. If ``gs_penalty_auto_mode`` is 0,
+        this value does not change. If ``gs_penalty_auto_mode`` is 1, this initial
+        weight factor is repeatedly increased by ``gs_penalty_inc_rate`` until
+        ``gs_max_penalty_coef`` is reached or the penalty energy is zero.
+        Default: 1, Min: 1, Max: 9_223_372_036_854_775_807
+    gs_penalty_inc_rate: int
+        Only used if ``gs_penalty_auto_mode`` is 1. In this case, the initial weight
+        factor ``gs_penalty_coef`` for the penalty polynomial is repeatedly
+        increased by multiplying ``gs_penalty_inc_rate`` / 100 until
+        ``gs_max_penalty_coef`` is reached or the penalty energy is zero.
+        Default: 150, Min: 100, Max: 200
+    gs_max_penalty_coef: int
+        Maximal value for the penalty coefficient. If ``gs_penalty_auto_mode`` is 0,
+        this is the maximal value for ``gs_penalty_coef``.
+        If ``gs_penalty_auto_mode`` is 1, this is the maximal value to which
+        ``gs_penalty_coef`` can be increased during the automatic adjustment.
+        If ``gs_max_penalty_coef`` is set to 0, then the maximal penalty coefficient
+        is 2^63 - 1.
+        Default: 0, Min: 0, Max: 9_223_372_036_854_775_807
+
+
+    scaling_action: Literal["NOTHING", "SCALING", "AUTO_SCALING"]
+        Method for scaling ``qubo`` and determining temperatures:
+        - "NOTHING": No action (use parameters exactly as specified)
+        - "SCALING": ``scaling_factor`` is multiplied to ``qubo``,
+          ``temperature_start``, ``temperature_end`` and ``offset_increase_rate``.
+        - "AUTO_SCALING": A maximum scaling factor w.r.t. ``scaling_bit_precision``
+          is multiplied to ``qubo``, ``temperature_start``, ``temperature_end`` and
+          ``offset_increase_rate``.
+    scaling_factor: int | float
+        Multiplicative factor applied to model coefficients, temperatures, and other
+        parameters: the ``scaling_factor`` for ``qubo``, ``temperature_start``,
+        ``temperature_end`` and ``offset_increase_rate``.
+        Higher values can improve numerical precision but may lead to overflow.
+        Default is 1.0 (no scaling).
+    scaling_bit_precision: int
+        Maximum bit precision to use when scaling. Determines the maximum allowable
+        coefficient magnitude. Default is 64, using full double precision.
+    random_seed: Union[int, None]
+        Seed for random number generation to ensure reproducible results.
+        Must be between 0 and 9_999. Default is None (random seed).
+    penalty_factor: float
+        Penalty factor used to scale the equality constraint penalty function,
+        default 1.0.
+    inequality_factor: int
+        Penalty factor used to scale the inequality constraints, default 1.
+    remove_ohg_from_penalty: bool
+        If equality constraints, identified to be One-Hot constraints are only
+        considered within one-hot groups (`remove_ohg_from_penalty=True`),
+        i.e., identified one-hot constraints are not added to the penalty function,
+        default True.
+    """
+
+    time_limit_sec: int | None = Field(default=None, ge=1, le=3600)
+    target_energy: int | None = Field(
+        default=None, ge=-99_999_999_999, le=99_999_999_999
+    )
+    num_group: int = Field(default=1, ge=1, le=16)
+    num_solution: int = Field(default=16, ge=1, le=1024)
+    num_output_solution: int = Field(default=5, ge=1, le=1024)
+    gs_num_iteration_factor: int = Field(default=5, ge=0, le=100)
+    gs_num_iteration_cl: int = Field(default=800, ge=0, le=1_000_000)
+    gs_ohs_xw1h_num_iteration_factor: int = Field(default=3, ge=0, le=100)
+    gs_ohs_xw1h_num_iteration_cl: int = Field(default=100, ge=0, le=1_000_000)
+    ohs_xw1h_internal_penalty: int = Field(default=0, ge=0, le=1)
+    gs_penalty_auto_mode: int = Field(default=1, ge=0, le=1)
+    gs_penalty_coef: int = Field(default=1, ge=1, le=2**63 - 1)
+    gs_penalty_inc_rate: int = Field(default=150, ge=100, le=200)
+    gs_max_penalty_coef: int = Field(default=0, ge=0, le=2**63 - 1)
+
+    @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 "FDAV3C"

luna_quantum/solve/parameters/algorithms/optimization_solvers/__init__.py

@@ -0,0 +1,3 @@
+from .scip import SCIP
+
+__all__ = ["SCIP"]

luna_quantum/solve/parameters/algorithms/optimization_solvers/scip.py

@@ -0,0 +1,51 @@
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends.zib import ZIB
+
+
+class SCIP(LunaAlgorithm[ZIB]):
+    """Parameters for the "Solve Constraint Integer Programming" (SCIP) solver."""
+
+    @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 "SCIP"
+
+    @classmethod
+    def get_default_backend(cls) -> ZIB:
+        """
+        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
+        -------
+            BACKEND_TYPE
+                An instance of a class implementing the IBackend interface that serves
+                as the default backend.
+        """
+        return ZIB()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[ZIB], ...]:
+        """
+        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 (ZIB,)

luna_quantum/solve/parameters/algorithms/quantum_annealing/__init__.py

@@ -0,0 +1,19 @@
+from .kerberos import Kerberos
+from .leap_hybrid_bqm import LeapHybridBqm
+from .leap_hybrid_cqm import LeapHybridCqm
+from .parallel_tempering_qpu import ParallelTemperingQpu
+from .population_annealing_qpu import PopulationAnnealingQpu
+from .qbsolv_like_qpu import QBSolvLikeQpu
+from .quantum_annealing import QuantumAnnealing
+from .repeated_reverse_quantum_annealing import RepeatedReverseQuantumAnnealing
+
+__all__ = [
+    "Kerberos",
+    "LeapHybridBqm",
+    "LeapHybridCqm",
+    "ParallelTemperingQpu",
+    "PopulationAnnealingQpu",
+    "QBSolvLikeQpu",
+    "QuantumAnnealing",
+    "RepeatedReverseQuantumAnnealing",
+]

luna_quantum/solve/parameters/algorithms/quantum_annealing/kerberos.py

@@ -0,0 +1,149 @@
+from pydantic import Field
+
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.algorithms.base_params import (
+    Decomposer,
+    QuantumAnnealingParams,
+    SimulatedAnnealingBaseParams,
+    TabuKerberosParams,
+)
+from luna_quantum.solve.parameters.backends import DWaveQpu
+from luna_quantum.solve.parameters.constants import (
+    DEFAULT_ATOL,
+    DEFAULT_RTOL,
+)
+
+
+class Kerberos(
+    LunaAlgorithm[DWaveQpu],
+):
+    """
+    Kerberos hybrid quantum-classical optimization solver.
+
+    Kerberos is a sophisticated hybrid solver that decomposes an optimization problem
+    into subproblems and solves them using multiple techniques in parallel: Tabu Search,
+    Simulated Annealing, and QPU (Quantum Processing Unit) sampling. It then combines
+    the results and iteratively refines the solution.
+
+    This approach leverages both classical and quantum resources efficiently, making it
+    effective for large and complex optimization problems beyond the capacity of pure
+    quantum approaches.
+
+    Attributes
+    ----------
+    num_reads: int
+        Number of output solutions to generate. Higher values provide better statistical
+        coverage of the solution space but increase computational resources required.
+        This parameter determines how many distinct solutions the algorithm will return
+        after completion. Default is 100.
+    num_retries: int
+        Number of attempts to retry embedding the problem onto the quantum hardware
+        if initial attempts fail. Useful for complex problems that may be challenging
+        to map to the quantum processor's topology. Each retry attempts a different
+        embedding strategy. Default is 0 (no retries).
+    max_iter: int | None
+        Maximum number of iterations for the solver. Each iteration involves running
+        the three solvers (Tabu, SA, QPU) in parallel, combining their results, and
+        refining the solution for the next iteration. Higher values allow more thorough
+        exploration and refinement but increase runtime. Default is 100.
+    max_time: int
+        Maximum time in seconds for the solver to run. Provides a hard time limit
+        regardless of convergence or iteration status. Once this time is reached,
+        the solver returns the best solution found so far. Default is 5, which may
+        need to be increased for large problems.
+    convergence: int
+        Number of consecutive iterations without improvement before declaring
+        convergence. Higher values ensure more stable solutions by requiring consistent
+        results across multiple iterations. Default is 3, which balances thoroughness
+        with efficiency.
+    target: float | None
+        Target objective value that triggers termination if reached. Allows early
+        stopping when a solution of sufficient quality is found. Default is None,
+        which means the algorithm will run until other stopping criteria are met.
+    rtol: float
+        Relative tolerance for convergence detection. Used when comparing objective
+        values between iterations to determine if significant improvement has occurred.
+        Smaller values require more substantial improvements to continue. Default is
+        DEFAULT_RTOL.
+    atol: float
+        Absolute tolerance for convergence detection. Used alongside rtol when
+        comparing objective values to determine if the algorithm has converged.
+        Smaller values enforce stricter convergence criteria. Default is DEFAULT_ATOL.
+    quantum_annealing_params: QuantumAnnealingParams
+        Nested configuration for quantum annealing parameters used by the QPU component
+        of the hybrid solver. Controls aspects like annealing schedule, chain strength,
+        and programming thermalization time. These parameters can significantly impact
+        the quality of solutions found by the quantum component. Default is a
+        QuantumAnnealingParams instance with default settings.
+    tabu_kerberos_params: TabuKerberosParams
+        Nested configuration for tabu search parameters used by the Tabu component of
+        the hybrid solver. Controls aspects like tabu tenure, number of iterations,
+        and neighborhood exploration strategy. The Tabu component helps the algorithm
+        systematically explore promising regions while avoiding cycles. Default is a
+        TabuKerberosParams instance with default settings.
+    decomposer: Decomposer
+        Decomposer: Breaks down problems into subproblems of manageable size
+        Default is a Decomposer instance with default settings.
+    """
+
+    num_reads: int = 100
+    num_retries: int = 0
+    max_iter: int | None = 100
+    max_time: int = 5
+    convergence: int = 3
+    target: float | None = None
+    rtol: float = DEFAULT_RTOL
+    atol: float = DEFAULT_ATOL
+    simulated_annealing_params: SimulatedAnnealingBaseParams = Field(
+        default_factory=SimulatedAnnealingBaseParams
+    )
+    quantum_annealing_params: QuantumAnnealingParams = Field(
+        default_factory=QuantumAnnealingParams
+    )
+    tabu_kerberos_params: TabuKerberosParams = Field(default_factory=TabuKerberosParams)
+    decomposer: Decomposer = Field(default_factory=Decomposer)
+
+    @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 "K"
+
+    @classmethod
+    def get_default_backend(cls) -> DWaveQpu:
+        """
+        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 DWaveQpu()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[DWaveQpu], ...]:
+        """
+        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 (DWaveQpu,)

luna_quantum/solve/parameters/algorithms/quantum_annealing/leap_hybrid_bqm.py

@@ -0,0 +1,75 @@
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends import DWaveQpu
+
+
+class LeapHybridBqm(LunaAlgorithm[DWaveQpu]):
+    """
+    D-Wave's Leap Hybrid Binary Quadratic Model (BQM) solver.
+
+    Leap's hybrid BQM solver is a cloud-based service that combines quantum and
+    classical resources to solve unconstrained binary optimization problems that are
+    larger than what can fit directly on a quantum processor. It automatically handles
+    decomposition, quantum processing, and solution reconstruction.
+
+    The hybrid solver is particularly useful for problems with thousands of variables,
+    offering better scaling than classical solvers for many problem types.
+
+    Attributes
+    ----------
+    time_limit: float | int | None
+        Maximum running time in seconds. Longer time limits generally produce better
+        solutions but increase resource usage and cost. Default is None, which uses
+        the service's default time limit (typically problem-size dependent).
+
+    Note
+    ------
+    For a D-Wave backend, this will ignore the decompose parameters as the hybrid
+    solver handles decomposition internally.
+    """
+
+    time_limit: float | int | None = None
+
+    @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 "LBQM"
+
+    @classmethod
+    def get_default_backend(cls) -> DWaveQpu:
+        """
+        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 DWaveQpu()
+
+    @classmethod
+    def get_compatible_backends(cls) -> tuple[type[DWaveQpu], ...]:
+        """
+        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 (DWaveQpu,)