luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/parameters/backends/ibm.py

@@ -0,0 +1,138 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from luna_quantum.solve.interfaces.backend_i import IBackend
+
+
+class IBM(IBackend):
+    """IBM quantum backend configuration.
+
+    This class provides configuration options for IBM quantum backends, supporting
+    both local simulators and fake provider backends for quantum algorithm execution.
+    The configuration allows users to specify which type of backend to use without
+    requiring an IBM token for simulator-based execution.
+
+    The class supports two main backend types:
+
+    - Simulator backends: Execute quantum algorithms locally using simulators
+    - Fake provider backends: Use IBM's fake backends for testing and development
+
+    Attributes
+    ----------
+    backend : SimulatorBackend | FakeProviderBackend
+        The backend configuration, defaults to AER simulator.
+    """
+
+    class SimulatorBackend(BaseModel):
+        """Qiskit Statevector Simulator.
+
+        Use a simulator as backend. The QAOA is executed completely on our server, and
+        no IBM token is required.
+
+        Attributes
+        ----------
+        backend_name: Literal['aer', 'statevector']
+            Which simulator to use. Currently, `AerSimulator` from `qiskit_aer`
+            and the statevector simulator from `qiskit.primitives` are available.
+        """
+
+        backend_type: Literal["simulator"] = "simulator"
+        backend_name: Literal["aer", "statevector"] = "aer"
+
+    class FakeProviderBackend(BaseModel):
+        """Simulator with emulated QPU noise model.
+
+        The Qiskit fake provider runs a simulation with a noise model derived from
+        an actual QPU hardware implementation.
+        See [IBM documentation](
+        https://docs.quantum.ibm.com/api/qiskit-ibm-runtime/fake-provider) for
+        available “fake” devices.
+
+        Use a V2 fake backend from `qiskit_ibm_runtime.fake_provider`. The QAOA is
+        executed entirely on our server, and no IBM token is required.
+
+        Attributes
+        ----------
+        backend_name: str
+            Which backend to use
+        """
+
+        backend_type: Literal["fake_provider"] = "fake_provider"
+        backend_name: Literal[
+            "FakeAlgiers",
+            "FakeAlmadenV2",
+            "FakeArmonkV2",
+            "FakeAthensV2",
+            "FakeAuckland",
+            "FakeBelemV2",
+            "FakeBoeblingenV2",
+            "FakeBogotaV2",
+            "FakeBrisbane",
+            "FakeBrooklynV2",
+            "FakeBurlingtonV2",
+            "FakeCairoV2",
+            "FakeCambridgeV2",
+            "FakeCasablancaV2",
+            "FakeCusco",
+            "FakeEssexV2",
+            "FakeFez",
+            "FakeFractionalBackend",
+            "FakeGeneva",
+            "FakeGuadalupeV2",
+            "FakeHanoiV2",
+            "FakeJakartaV2",
+            "FakeJohannesburgV2",
+            "FakeKawasaki",
+            "FakeKolkataV2",
+            "FakeKyiv",
+            "FakeKyoto",
+            "FakeLagosV2",
+            "FakeLimaV2",
+            "FakeLondonV2",
+            "FakeManhattanV2",
+            "FakeManilaV2",
+            "FakeMarrakesh",
+            "FakeMelbourneV2",
+            "FakeMontrealV2",
+            "FakeMumbaiV2",
+            "FakeNairobiV2",
+            "FakeOsaka",
+            "FakeOslo",
+            "FakeOurenseV2",
+            "FakeParisV2",
+            "FakePeekskill",
+            "FakePerth",
+            "FakePrague",
+            "FakePoughkeepsieV2",
+            "FakeQuebec",
+            "FakeQuitoV2",
+            "FakeRochesterV2",
+            "FakeRomeV2",
+            "FakeSantiagoV2",
+            "FakeSherbrooke",
+            "FakeSingaporeV2",
+            "FakeSydneyV2",
+            "FakeTorino",
+            "FakeTorontoV2",
+            "FakeValenciaV2",
+            "FakeVigoV2",
+            "FakeWashingtonV2",
+            "FakeYorktownV2",
+        ]
+
+    backend: SimulatorBackend | FakeProviderBackend = Field(
+        default=SimulatorBackend(), discriminator="backend_type"
+    )
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "ibm"

luna_quantum/solve/parameters/backends/qctrl.py

@@ -0,0 +1,103 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from luna_quantum.client.schemas import QpuToken, QpuTokenSource, TokenProvider
+from luna_quantum.solve.domain.abstract import QpuTokenBackend
+
+
+class Qctrl(QpuTokenBackend):
+    """
+    Configuration parameters for Q-CTRL`s Fire Opal Backend.
+
+    QAOA (Quantum Approximate Optimization Algorithm) is a quantum algorithm designed
+    for combinatorial optimization problems. This implementation leverages Q-CTRL's
+    Fire Opal framework, which optimizes QAOA execution on quantum hardware to reduce
+    errors and improve solution quality.
+
+    Fire Opal's hardware-tailored optimizations enable solving larger problems with
+    better convergence in fewer iterations, reducing overall execution time on real
+    quantum devices.
+
+    Attributes
+    ----------
+    organization_slug: str | None, default=None
+        Organization identifier from your Q-CTRL account. Required only if you belong
+        to multiple organizations. This can be retrieved from your Q-CTRL account
+        settings or dashboard.
+
+    backend_name: str | None, default=None
+        The IBM Quantum backend to use for computations:
+        - Specific backend: e.g., 'ibm_fez', 'ibm_marrakesh'
+        - 'least_busy': Automatically selects the least busy available backend
+        - 'basic_simulator': Uses the basic simulator (default if None)
+        Check your IBM Quantum account for available backends.
+
+    ibm_credentials: IBMQ | IBMCloud
+        The IBM backend credentials, i.e. how to access the IBM service. Q-Ctrl
+        currently supports two mehtods, via the old IBMQ pattern or the new IBMCloud
+        pattern. Default is Qctrl.IBMQ()
+
+    token: QpuToken | str | None, default=None
+        The Q-Ctrl API token.
+
+
+    Notes
+    -----
+    For detailed information about Fire Opal's QAOA solver and its capabilities,
+    see [Q-CTRL's documentation](
+    https://docs.q-ctrl.com/fire-opal/topics/fire-opals-qaoa-solver)
+    """
+
+    class IBMCloud(BaseModel):
+        """
+        Configuration parameters for the IBM Cloud backend.
+
+        Attributes
+        ----------
+        instance: str
+            The Qiskit runtime instance CRN (Cloud Resource Name).
+
+        token: Union[str, None, QpuToken], default=None
+            The IBM API token.
+        """
+
+        instance: str = ""
+
+        token: str | QpuToken | None = Field(repr=False, exclude=True, default=None)
+
+    organization_slug: Any = None
+    backend_name: str | None = None
+
+    ibm_credentials: IBMCloud = Field(default=IBMCloud())
+
+    token: str | QpuToken | None = Field(repr=False, exclude=True, default=None)
+
+    def _get_token(self) -> TokenProvider | None:
+        if self.token is None or self.ibm_credentials.token is None:
+            return None
+        qctrl_token = (
+            self.token
+            if isinstance(self.token, QpuToken)
+            else QpuToken(source=QpuTokenSource.INLINE, token=self.token)
+        )
+        ibm_token = (
+            self.ibm_credentials.token
+            if isinstance(self.ibm_credentials.token, QpuToken)
+            else QpuToken(
+                source=QpuTokenSource.INLINE, token=self.ibm_credentials.token
+            )
+        )
+        return TokenProvider(qctrl=qctrl_token, ibm=ibm_token)
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "qctrl"

luna_quantum/solve/parameters/backends/zib.py

@@ -0,0 +1,17 @@
+from luna_quantum.solve.interfaces.backend_i import IBackend
+
+
+class ZIB(IBackend):
+    """Configuration class for the ZIB backend."""
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "zib"

luna_quantum/solve/parameters/constants.py

@@ -0,0 +1,11 @@
+# The default absolute tolerance that should be used for `numpy.isclose(...)`
+# calls. Equal to the default used in `numpy.isclose(..)`.
+DEFAULT_ATOL: float = 1.0e-8
+
+# The default relative tolerance that should be used for ``numpy.isclose(...)``
+# calls. Equal to the default used in ``numpy.isclose(..)``.
+DEFAULT_RTOL: float = 1.0e-5
+
+# The default timeout used for solver run with a specified target.
+# Number of seconds before routine halts. Default is 2592000 for dimod.qbsolv.
+DEFAULT_TIMEOUT: int = 10

luna_quantum/solve/parameters/errors.py

@@ -0,0 +1,30 @@
+from luna_quantum.solve.errors.solve_base_error import SolveBaseError
+
+
+class QAOAParameterOptimizerError(SolveBaseError):
+    """QAOA cirucit parameters mismatch with optimizer exception."""
+
+    def __init__(
+        self,
+        optimizer: str,
+        params: str,
+        extra: str = "",
+    ) -> None:
+        super().__init__(
+            f"Parameter Mismatch of '{optimizer}' and '{params}'"
+            + ((": " + 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 QAOAParameterRepsMismatchError(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=}.")

luna_quantum/solve/parameters/mixins/fujitsu_common_params_mixin.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class FujitsuCommonParamsMixin(BaseModel):
+    """
+    Common parameters used across various quantum and classical optimization solvers.
+
+    This class encapsulates parameters for auto-tuning, scaling, and general
+    configuration options that are applicable to multiple solver types. It provides a
+    consistent interface for these common settings to simplify configuration and
+    enhance reusability.
+
+    Attributes
+    ----------
+    auto_tuning: Literal["NOTHING", "SCALING", "AUTO_SCALING", "SAMPLING",
+                        "AUTO_SCALING_AND_SAMPLING", "SCALING_AND_SAMPLING"]
+        Controls automatic parameter adjustment strategies:
+        - "NOTHING": No auto-tuning (use parameters exactly as specified)
+        - "SCALING": Apply scaling_factor to model coefficients and parameters
+        - "AUTO_SCALING": Automatically determine optimal scaling factor based on bit
+        precision
+        - "SAMPLING": Automatically determine temperature parameters through sampling
+        - "AUTO_SCALING_AND_SAMPLING": Combine auto-scaling and sampling
+        - "SCALING_AND_SAMPLING": Apply explicit scaling and determine temperatures
+        Default is "NOTHING", giving full control to the user.
+    scaling_factor: Union[int, float]
+        Multiplicative factor applied to model coefficients, temperatures, and other
+        parameters.
+        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.
+    guidance_config: Union[PartialConfig, None]
+        Optional configuration for guiding the optimization process with prior
+        knowledge. Can specify initial values or constraints for variables. Default is
+        None.
+    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).
+    timeseries_max_bits: Union[int, None]
+        Maximum number of bits to use for timeseries representation.
+        Limits memory usage for large problems. Default is None (no limit).
+    solver_max_bits: int
+        Maximum problem size (in bits/variables) that the solver can handle.
+        Default is 2¹³ (8,192), suitable for most solvers.
+    var_shape_set: Optional[VarShapeSet]
+        This parameter should be an object of :class:`VarShapeSet` or ``None``
+    auto_fill_cold_bits: Optional[bool]
+        In case ``var_shape_set`` is defined and contains a 1-hot group,
+        and a hot bit is set to ``True`` and this parameter is also set to ``True``,
+        then all related cold bits are set to ``False``. Default is ``True``
+    """
+
+    class BitArrayShape(BaseModel):
+        """BitArrayShape.
+
+        An object of the class :class:`BitArrayShape` represents an array structure as
+        part of a bit vector. It allows multidimensional indexed access to the bit
+        variables of a :class:`BinPol` polynomial. :class:`BitArrayShape` objects are
+        used inside :class:`VarShapeSet` objects, which organize index data of a
+        complete bit vector for a polynomial. Bit variables of such polynomials can
+        then be accessed by name and indices according to the shape specified in the
+        :class:`BitArrayShape` object.
+
+        Parameters
+        ----------
+        shape: List[int]
+            shape of the index; specify the length of each dimension
+        constant_bits: Optional[NDArray]
+            numpy array of type int8 with same shape as the previous parameter
+            containing 0 and 1 for constant bits and -1 variable bits
+        one_hot: OneHot
+            define variable as one_hot section
+        axis_names: Optional[List[str]]
+            Names for the axis.
+        index_offsets: Optional[List[int]]
+            index_offsets of the index, specify the index_offsets of each dimension
+        """
+
+        type: Literal["BitArrayShape"] = "BitArrayShape"
+        axis_names: list[str] | None = None
+        index_offsets: list[int] | None = None
+        name: str
+        one_hot: Literal["no_way", "one_way", "two_way"] = "no_way"
+
+    class Category(BaseModel):
+        """Category.
+
+        An object of the class :class:`Category` represents an array structure as part
+        of a bit vector. It allows indexed access to the bit variables of a
+        :class:`BinPol` polynomial. :class:`Category`
+        objects are used inside :class:`VarShapeSet` objects, which organize index data
+        of a complete bit vector for a polynomial. Bit variables of such polynomials
+        can then be accessed by ``name`` and categorical indices according to the
+        ``values`` specified in the :class:`BitArrayShape` object. A categorical index
+        can be any sequence of unique values.
+
+        Parameters
+        ----------
+        name: str
+            name of the new index
+        values: List[Any]
+            list of unique values for this category
+        one_hot: OneHot
+            define variable as one_hot section
+        axis_names: List[str]
+            Names for the axis.
+        """
+
+        type: Literal["Category"] = "Category"
+        values: list[Any] = Field(default_factory=list)
+        axis_names: list[str] | None = None
+        name: str
+        one_hot: Literal["no_way", "one_way", "two_way"] = "no_way"
+
+    class Variable(BaseModel):
+        """Variable.
+
+        A ``Variable`` is a binary polynomial, that represents a numerical value
+        according to values of the underlying bits. The variable is defined by a value
+        range and a specific representation scheme that is realized in respective
+        inherited classes.
+
+        Parameters
+        ----------
+        name: str
+            name of the variable
+        start: float
+            first number in the list of values to be represented by the variable
+        stop: float
+            stop value for the list of numbers to be represented by the variable; stop
+            is omitted
+        step: float
+            increment for the list of numbers to be represented by the variable
+        shape: List[int]
+            shape of the index; specify the length of each dimension
+        constant_bits: Optional[NDArray]
+            numpy array of type int8 with same shape as the previous parameter
+            containing 0 and 1 for constant bits and -1 variable bits
+        one_hot: OneHot
+            define variable as one_hot section
+        """
+
+        type: Literal["Variable"] = "Variable"
+        start: float
+        stop: float
+        step: float
+
+        shape: list[int] | None = None
+        constant_bits: list[int] | None = None
+
+        name: str
+        one_hot: Literal["no_way", "one_way", "two_way"] = "no_way"
+
+    class VarShapeSet(BaseModel):
+        """VarShapeSet.
+
+        :class:`dadk.BinPol.VarShapeSet` defines an indexing structure for the bits of
+        a BinPol polynomial. Plain BinPol polynomials are defined on a set of bits
+        indexed by a ``range(N)`` for some integer ``N``. The ``VarShapeSet`` lays
+        a sequence of disjoint named sections over this linear structure. Bits within a
+        section can be addressed by the defined name. With a ``BitArrayShape`` a
+        section can be defined as multidimensional array and single bits in the section
+        can be addressed by an appropriate tuple of indices. With a ``Variable``
+        definition the section represents a number encoded in certain bit schemes; in
+        this case it is possible to retrieve the represented value instead of reading
+        single bits.
+
+        Parameters
+        ----------
+        var_defs: Union[BitArrayShape, Variable, Category]
+            one or more section definitions of type :class:`BitArrayShape`,
+            :class:`Variable` or :class:`Category`
+        one_hot_groups: Optional[List[OneHotGroup]]
+            optional list of special one_hot group definitions
+        """
+
+        var_defs: list[
+            Annotated[
+                FujitsuCommonParamsMixin.BitArrayShape
+                | FujitsuCommonParamsMixin.Variable
+                | FujitsuCommonParamsMixin.Category,
+                Field(discriminator="type"),
+            ]
+        ] = Field(default_factory=list)
+        one_hot_groups: list[Literal["no_way", "one_way", "two_way"]] | None = None
+
+    class PartialConfig:
+        """Produces a dict that can be used for the annealing algorithm.
+
+        The start state for an annealing or parallel tempering model can be specified.
+        The used dictionary addresses bits with their flattened index. With the class
+        :class:`PartialConfig` those bits can be specified on the symbolic level of
+        :class:`BitArrayShape` or :class:`Variable` and the offsets in a
+        :class:`VarShapeSet` are calculated automatically. Flat indices can be used
+        directly, if they are known. For variables, indices are used directly and do
+        not need to be adjusted by a global index consideration from the
+        :class:`VarShapeSet`. After setting the start state accordingly, a string can
+        be created with the method ``as_json``. If one_hot or two_hot specifications
+        are given in :class:`VarShapeSet`, the dictionary generated in the methods
+        ``get_dict`` or ``as_json`` is build up with respect to the set bit variables
+        and one-way or two-way rules.
+
+        The object is initialized by a :class:`VarShapeSet` object or None.
+        An initialization with None can be used for :class:`BinPol`.
+
+        Parameters
+        ----------
+        var_shape_set: Optional[VarShapeSet]
+            This parameter should be an object of :class:`VarShapeSet` or ``None``
+        auto_fill_cold_bits: bool
+            In case ``var_shape_set`` is defined and contains a 1-hot group,
+            and a hot bit is set to ``True`` and this parameter is also set to ``True``,
+            then all related cold bits are set to ``False``. Default is ``True``
+        """
+
+        var_shape_set: FujitsuCommonParamsMixin.VarShapeSet | None = None
+        auto_fill_cold_bits: bool = True
+
+    auto_tuning: Literal[
+        "NOTHING",
+        "SCALING",
+        "AUTO_SCALING",
+        "SAMPLING",
+        "AUTO_SCALING_AND_SAMPLING",
+        "SCALING_AND_SAMPLING",
+    ] = "NOTHING"
+    scaling_factor: int | float = 1.0
+    scaling_bit_precision: int = 64
+    random_seed: int | None = Field(default=None, ge=0, le=9_999)
+    timeseries_max_bits: int | None = None
+    solver_max_bits: int = 2**13
+    var_shape_set: VarShapeSet | None = None
+    auto_fill_cold_bits: bool | None = True

luna_quantum/solve/parameters/mixins/fujitsu_v2_mixin.py

@@ -0,0 +1,70 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class FujitsuV2Mixin(BaseModel):
+    """
+    FujitsuV2Mixin.
+
+    Parameters for V2 optimization algorithms, particularly relevant for
+    Digital Annealer implementations.
+
+    This class defines parameters controlling the annealing process, temperature
+    scheduling, and solution mode for V2 solvers. These parameters impact how
+    the algorithm traverses the energy landscape and converges to solutions.
+
+    Attributes
+    ----------
+    optimization_method: Literal["annealing", "parallel_tempering"]
+        Algorithm to use for optimization:
+        - "annealing": Standard simulated annealing with gradual cooling
+        - "parallel_tempering": Simultaneous runs at different temperatures with
+          periodic state exchanges, effective for complex energy landscapes
+        Default is "annealing".
+    temperature_start: float
+        Initial temperature for the annealing process. Higher values enable more
+        exploration initially. Default is 1000.0. Range: [0.0, 1e20].
+    temperature_end: float
+        Final temperature for the annealing process. Lower values enforce more
+        exploitation in final phases. Default is 1.0. Range: [0.0, 1e20].
+    temperature_mode: int
+        Cooling curve mode for temperature decay:
+        - 0: Exponential cooling - reduce by factor at fixed intervals
+        - 1: Inverse cooling - faster initial cooling, slower later
+        - 2: Inverse root cooling - another non-linear cooling schedule
+        Default is 0 (exponential).
+    temperature_interval: int
+        Number of iterations between temperature adjustments. Larger values
+        allow more exploration at each temperature. Default is 100. Range: [1, 1e20].
+    offset_increase_rate: float
+        Rate at which dynamic offset increases when no bit is selected.
+        Helps escape plateaus in the energy landscape. Default is 5.0.
+        Range: [0.0, 1e20].
+    solution_mode: Literal["QUICK", "COMPLETE"]
+        Determines solution reporting strategy:
+        - "QUICK": Return only the overall best solution (faster)
+        - "COMPLETE": Return best solutions from all runs (more diverse)
+        Default is "COMPLETE", providing more solution options.
+    flip_probabilities: Tuple[float, float]
+        Probabilities used for determining temperature parameters.
+        First value is probability of accepting worse solutions at start temperature,
+        second value is probability at end temperature. Default is (0.99, 0.01).
+    annealing_steps: Tuple[float, float]
+        Portion of annealing trajectory where end_progress_probability is reached.
+        Controls the annealing schedule shape. Default is (0.0, 0.5).
+    sampling_runs: int
+        Number of random walkers used for energy delta determination during
+        parameter estimation sampling. Default is 100.
+    """
+
+    optimization_method: Literal["annealing", "parallel_tempering"] = "annealing"
+    temperature_start: float = Field(default=1_000.0, ge=0.0, le=1e20)
+    temperature_end: float = Field(default=1.0, ge=0.0, le=1e20)
+    temperature_mode: int = 0
+    temperature_interval: int = Field(default=100, ge=1, le=int(1e20))
+    offset_increase_rate: float = Field(default=5.0, ge=0.0, le=1e20)
+    solution_mode: Literal["QUICK", "COMPLETE"] = "COMPLETE"
+    flip_probabilities: tuple[float, float] = 0.99, 0.01
+    annealing_steps: tuple[float, float] = 0.0, 0.5
+    sampling_runs: int = 100

luna_quantum/solve/parameters/mixins/qbsolv_like_mixin.py

@@ -0,0 +1,60 @@
+from pydantic import BaseModel
+
+from luna_quantum.solve.parameters.constants import DEFAULT_ATOL, DEFAULT_RTOL
+
+
+class QBSolvLikeMixin(BaseModel):
+    """
+    QBSolvLikeMixin.
+
+    Attributes
+    ----------
+    decomposer_size: int
+        Size for the decomposer, which determines the maximum subproblem size to be
+        handled in each iteration. Larger values may produce better solutions but
+        increase computational complexity exponentially. Default is 50, which balances
+        solution quality with reasonable runtime.
+    rolling: bool
+        Whether to use rolling window decomposition for the solver. When enabled,
+        this allows for overlapping subproblems with shared variables, which can
+        improve solution quality by better handling interactions across subproblem
+        boundaries. Default is True.
+    rolling_history: float
+        Rolling history factor controlling how much of previous subproblem solutions
+        are considered when solving subsequent subproblems. Higher values incorporate
+        more historical information but may slow convergence to new solutions.
+        Default is 0.15 (15% retention).
+    max_iter: int | None
+        Maximum number of iterations (decomposition and solving cycles) to perform.
+        Higher values allow for more thorough optimization but increase runtime.
+        Default is 100.
+    max_time: int
+        Time in seconds after which the algorithm will stop, regardless of convergence
+        status. Provides a hard time limit for time-constrained applications.
+        Default is 5.
+    convergence: int
+        Number of iterations with unchanged output to terminate algorithm. Higher values
+        ensure more stable solutions but may increase computation time unnecessarily
+        if the algorithm has already found the best solution. Default is 3.
+    target: float | None
+        Energy level that the algorithm tries to reach. If this target energy is
+        achieved, the algorithm will terminate early. Default is None, meaning the
+        algorithm will run until other stopping criteria are met.
+    rtol: float
+        Relative tolerance for convergence. Used when comparing energy values between
+        iterations to determine if significant improvement has occurred. Default uses
+        DEFAULT_RTOL.
+    atol: float
+        Absolute tolerance for convergence. Used alongside rtol when comparing energy
+        values to determine if the algorithm has converged. Default uses DEFAULT_ATOL.
+    """
+
+    decomposer_size: int = 50
+    rolling: bool = True
+    rolling_history: float = 0.15
+    max_iter: int | None = 100
+    max_time: int = 5
+    convergence: int = 3
+    target: float | None = None
+    rtol: float = DEFAULT_RTOL
+    atol: float = DEFAULT_ATOL