luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,174 @@
+from typing import Any
+
+from pydantic import Field
+
+from luna_quantum.solve.domain.abstract import LunaAlgorithm
+from luna_quantum.solve.parameters.backends import DWaveQpu
+
+
+class RepeatedReverseQuantumAnnealing(LunaAlgorithm[DWaveQpu]):
+    """
+    Parameters for the Repeated Reverse Quantum Annealing algorithm.
+
+    This approach combines reverse annealing (starting from a classical state) with
+    repetition to refine solutions iteratively. It's particularly useful for:
+    1. Local refinement of solutions found by classical methods
+    2. Escaping local minima by temporarily increasing quantum fluctuations
+    3. Improving solutions through multiple rounds of quantum optimization
+
+    The process involves:
+    - Starting with classical initial states
+    - Partially "unsolving" them by increasing quantum fluctuations
+    - Re-annealing to find potentially better nearby solutions
+    - Repeating with the best solutions found
+
+    Attributes
+    ----------
+    anneal_offsets: Any | None
+        Per-qubit time offsets for the annealing path, allowing qubits to anneal at
+        different rates. Useful for problems with varying energy scales or when certain
+        qubits need different annealing trajectories. Default is None, which uses
+        standard annealing for all qubits.
+    annealing_time: Any | None
+        Duration of the annealing process in microseconds. Longer times can improve
+        solution quality for problems with small energy gaps but increase runtime.
+        Default is None, which uses the QPU's default annealing time.
+    auto_scale: Any | None
+        Whether to automatically normalize the problem energy range to match hardware
+        capabilities, preventing precision issues in the physical implementation.
+        Default is None, which uses the D-Wave system's default setting.
+    flux_biases: Any | None
+        Custom flux bias offsets for each qubit to compensate for manufacturing
+        variations in the QPU hardware or to intentionally bias certain qubits.
+        Default is None, using standard calibration values.
+    flux_drift_compensation: bool
+        Whether to compensate for drift in qubit flux over time, improving the
+        reliability and consistency of results across multiple runs.
+        Default is True, which is recommended for most applications.
+    h_gain_schedule: Any | None
+        Schedule for h-gain (linear coefficient strength) during annealing,
+        allowing dynamic adjustment of problem coefficients throughout the process.
+        Default is None, using standard gain settings.
+    max_answers: int | None
+        Maximum number of unique answer states to return from the quantum hardware.
+        Useful for collecting diverse solutions while filtering out duplicates.
+        Must be greater than or equal to 1 if specified. Default is None, which returns
+        all unique solutions found.
+    programming_thermalization: float | None
+        Wait time (in microseconds) after programming the QPU, allowing it to
+        reach thermal equilibrium before starting the annealing process.
+        Must be positive if specified. Default is None, using system default.
+    readout_thermalization: float | None
+        Wait time (in microseconds) after each anneal before reading results.
+        Helps ensure the qubits have settled into their final states before measurement.
+        Must be positive if specified. Default is None, using system default.
+    reduce_intersample_correlation: bool
+        Whether to add delay between samples to reduce temporal correlations
+        that might bias results across multiple runs. Default is False to minimize
+        runtime, but can be set to True when sample independence is critical.
+    initial_states: list[dict[str, int]] | None
+        Initial classical states to start the reverse annealing from, specified as
+        dictionaries mapping variable names to binary values (0 or 1). For each state,
+        one call to the sampler with parameter `initial_state=state` will be made
+        in the first iteration. Default is None, in which case random or specified
+        states are generated according to n_initial_states.
+    n_initial_states: int
+        Number of initial states to create when `initial_states` is None.
+        Controls the diversity of starting points for the algorithm.
+        Ignored if `initial_states` is provided. Default is 1. Must be ≥1.
+    samples_per_state: int
+        How many samples to create per state in each iteration after the first.
+        More samples increase the chance of finding improvements but use more QPU time.
+        Controls the breadth of exploration around each promising solution.
+        Default is 1. Must be ≥1.
+    beta_schedule: list[float]
+        Beta schedule controlling the quantum fluctuation strength during reverse
+        annealing. Beta is the inverse temperature (1/T), with lower values allowing
+        more thermal excitation to explore the energy landscape more widely.
+        Default [0.5, 3] provides moderate initial fluctuation followed by cooling,
+        balancing exploration and exploitation.
+    timeout: float
+        Maximum runtime in seconds before the solver stops, regardless of convergence.
+        Provides a hard time limit to ensure the algorithm completes within a reasonable
+        timeframe. Default is 300 seconds (5 minutes), balancing solution quality with
+        timeliness.
+    max_iter: int
+        Maximum number of iterations (reverse annealing cycles) to perform.
+        Each iteration refines the solutions from the previous round, potentially
+        discovering better solutions in the neighborhood of good candidates.
+        Default is 10, providing good refinement without excessive QPU usage.
+    target: Any | None
+        Target energy value that, if reached, causes the algorithm to terminate early.
+        Allows for early stopping when a sufficiently good solution is found.
+        Default is None (run until other stopping criteria are met).
+    check_trivial: bool
+        Whether to check for and handle trivial variables (those without interactions)
+        before sending the problem to the QPU. Adds some computational overhead but
+        prevents potential runtime errors and improves embedding efficiency.
+        Default is True, which is recommended for robust operation.
+    """
+
+    anneal_offsets: Any | None = None
+    annealing_time: Any | None = None
+    auto_scale: Any | None = None
+    flux_biases: Any | None = None
+    flux_drift_compensation: bool = True
+    h_gain_schedule: Any | None = None
+    max_answers: int | None = Field(default=None, ge=1)
+    programming_thermalization: float | None = Field(default=None, gt=0)
+    readout_thermalization: float | None = Field(default=None, gt=0)
+    reduce_intersample_correlation: bool = False
+
+    initial_states: list[dict[str, int]] | None = None
+    n_initial_states: int = Field(default=1, ge=1)
+    samples_per_state: int = Field(default=1, ge=1)
+    beta_schedule: list[float] = Field(default_factory=lambda: [0.5, 3])
+    timeout: float = 300
+    max_iter: int = 10
+    target: Any | None = None
+    check_trivial: bool = True
+
+    @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 "RRQA"
+
+    @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_gate/__init__.py

@@ -0,0 +1,6 @@
+from .flexqaoa import FlexQAOA
+from .qaoa import QAOA
+from .qaoa_fo import QAOA_FO
+from .vqe import VQE
+
+__all__ = ["QAOA", "QAOA_FO", "VQE", "FlexQAOA"]

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

@@ -0,0 +1,10 @@
+import warnings
+
+from luna_quantum.solve.parameters.algorithms.quantum_gate.flexqaoa import *  # noqa: F403
+
+warnings.warn(
+    "The module `flex_qaoa` is deprecated and will be removed in the future. "
+    "Use 'flexqaoa' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

luna_quantum/solve/parameters/algorithms/quantum_gate/flexqaoa/__init__.py

@@ -0,0 +1,29 @@
+from .config import CustomConfig
+from .flexqaoa import FlexQAOA
+from .optimizers import (
+    CombinedOptimizerParams,
+    InterpolateOptimizerParams,
+)
+from .pipeline import (
+    IndicatorFunctionConfig,
+    InequalityToEqualityConfig,
+    PenaltySetting,
+    PipelineParams,
+    QuadraticPenaltyConfig,
+    SetpackingAsOnehotConfig,
+    XYMixerConfig,
+)
+
+__all__ = [
+    "CombinedOptimizerParams",
+    "CustomConfig",
+    "FlexQAOA",
+    "IndicatorFunctionConfig",
+    "InequalityToEqualityConfig",
+    "InterpolateOptimizerParams",
+    "PenaltySetting",
+    "PipelineParams",
+    "QuadraticPenaltyConfig",
+    "SetpackingAsOnehotConfig",
+    "XYMixerConfig",
+]

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

@@ -0,0 +1,58 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field, PositiveInt
+
+
+class CustomConfig(BaseModel):
+    """Additional FlexQAOA circuit configuration.
+
+    Attributes
+    ----------
+    max_qubits : PositiveInt | None
+        Maximum number of qubits allowed for the circuit. If `None`, no limit is
+        applied. Default: `None`.
+    minimize_qubits : bool
+        Minimize the number of used qubits in the circuit if set to `True`. Otherwise,
+        minimize circuit depth. Default: `False`.
+    wstate : Literal["log", "bilinear", "linear"]
+        WState generation cricuit. Choice between:
+
+        - `"log"`: Logarithmic-depth binary tree circuit.
+        - `"linear"`: Linear circuit construction.
+        - `"bilinear"`: Bi-linear circuit construction, starts in the middle and
+                        linearly constructs the circuit outwards.
+
+        Default: `"log"`
+    qft_synth : Literal["line", "full"]
+        QFT synthesis method. Choice between:
+
+        - `"full"`: Shorter circuit depth implementation that requires all-to-all
+                    connectivity.
+        - `"line"`: Longer circuit depth implementation that requires linear
+                    connectivity.
+
+        Default: `"full"`
+    """
+
+    max_qubits: PositiveInt | None = Field(
+        default=None,
+        description="Maximum number of qubits allowed for the circuit. If `None`, no "
+        "limit is applied.",
+    )
+    minimize_qubits: bool = Field(
+        default=False,
+        description="Minimize the number of used qubits in the circuit "
+        "if set to `True`. Otherwise, minimize circuit depth.",
+    )
+    wstate: Literal["log", "bilinear", "linear"] = Field(
+        default="log",
+        description="WState generation cricuit. Choice between: Logarithmic-depth (log)"
+        " binary tree circuit and linear or bilinear construction. bilinear places the "
+        "start in the middle and linearly constructs the circuit outwards.",
+    )
+    qft_synth: Literal["line", "full"] = Field(
+        default="full",
+        description="QFT synthesis method. Shorter depth (full) implementation requires"
+        " all-to-all connectivity. Longer (line) implementation requires only linear "
+        "connectivity.",
+    )

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

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field, model_validator
+
+from luna_quantum.solve.domain.abstract.luna_algorithm 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.aqarios import Aqarios
+from luna_quantum.solve.parameters.backends.aqarios_gpu import AqariosGpu
+from luna_quantum.solve.parameters.errors import (
+    InterpolateOptimizerError,
+    QAOAParameterOptimizerError,
+    QAOAParameterRepsMismatchError,
+)
+
+from .config import CustomConfig
+from .optimizers import CombinedOptimizerParams, InterpolateOptimizerParams
+from .pipeline import PipelineParams
+
+
+class FlexQAOA(LunaAlgorithm[Aqarios | AqariosGpu], 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 `xy_mixers` and `indicator_function` options
+    need to be manually disabled
+    ```
+    pipeline.xy_mixer.enable = False
+    pipeline.indicator_function.enable = False
+    ```
+
+    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
+        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 | CombinedOptimizerParams |\
+        InterpolateOptimizerParams | None
+        The classical optimizer for parameter tuning. Setting
+        to `None` disables the optimization, leading to an evaluation of the initial
+        parameters.
+    initial_params: LinearQAOAParams | BasicQAOAParams | RandomQAOAParams | Dict
+        Custom QAOA variational circuit parameters. By default linear
+        increasing/decreasing parameters for the selected `reps` are generated.
+    param_conversion: None | Literal["basic"] = "basic"
+        Parameter conversion after initialization. This option set to `None` means the
+        parameters, as specified are used. This parameter set to `"basic"` means the
+        parameters are converted to basic parameters before optimization. This is useful
+        if one only wants to optimize the linear schedule of parameters: Then the option
+        `None` needs to be selected alongside LinearQAOAParams. This
+        option is ignored when CombinedOptimizer is also selected.
+    custom_config: CustomConfig
+        Additional options for the FlexQAOA circuit.
+    """
+
+    shots: int = Field(
+        default=1024, ge=1, lt=1 << 16, description="Number of sampled shots."
+    )
+    reps: int = Field(
+        default=1, ge=1, lt=1000, 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
+        | CombinedOptimizerParams
+        | InterpolateOptimizerParams
+        | None
+    ) = Field(
+        default_factory=lambda: ScipyOptimizerParams(),
+        description="The classical optimizer. Default: ScipyOptimizer",
+    )
+    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.",
+    )
+    param_conversion: None | Literal["basic"] = "basic"
+    custom_config: CustomConfig = Field(
+        default_factory=lambda: CustomConfig(),
+        description="Additional configuration options for the FlexQAOA circuit.",
+    )
+
+    @model_validator(mode="after")
+    def _check_param_type(self) -> FlexQAOA:
+        if isinstance(self.optimizer, CombinedOptimizerParams):
+            if isinstance(self.initial_params, (BasicQAOAParams, RandomQAOAParams)):
+                optim = self.optimizer.__class__.__name__
+                params = self.initial_params.__class__.__name__
+                raise QAOAParameterOptimizerError(optim, params)
+            self.param_conversion = None
+        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 QAOAParameterRepsMismatchError(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], type[AqariosGpu]]:
+        """
+        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, AqariosGpu)

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

@@ -0,0 +1,53 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from luna_quantum.solve.parameters.algorithms.base_params.scipy_optimizer import (
+    ScipyOptimizerParams,
+)
+
+
+class CombinedOptimizerParams(BaseModel):
+    """Combination of LinearOptimizer and ScipyOptimizer.
+
+    Optimizer that first performs an optimization of the linear schedule and then
+    fine tunes individual parameters. Only works in conjunction with `LinearQAOAParams`.
+
+
+    Attributes
+    ----------
+    linear: ScipyOptimizerParams
+        Parameters of the linear optimizer.
+    fine_tune: ScipyOptimizerParams | None
+        Parameters of the fine tuning optimizer. If `None`, the same optimizer is used.
+        Default: `None`.
+    """
+
+    optimizer_type: Literal["combined"] = "combined"
+    linear: ScipyOptimizerParams = Field(default_factory=lambda: ScipyOptimizerParams())
+    fine_tune: ScipyOptimizerParams | None = None
+
+
+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
+    ----------
+    optimizer: ScipyOptimizerParams
+        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 = Field(
+        default_factory=lambda: ScipyOptimizerParams()
+    )
+    reps_step: int = Field(default=1, ge=1)
+    reps_end: int = Field(default=10, ge=1, lt=1000)

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

@@ -0,0 +1,164 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field, PositiveFloat
+
+
+class _EnableMixin:
+    enable: bool = True
+
+
+class PenaltySetting(BaseModel):
+    """Penalty factor settings.
+
+    Attributes
+    ----------
+    override: PositiveFloat | None
+        Overrides the automatically evaluated penalty factor.
+    scaling: PositiveFloat
+        Scales the automatically evaluated penalty factor.
+    """
+
+    override: PositiveFloat | None = None
+    scaling: PositiveFloat = 1.0
+
+
+class IndicatorFunctionConfig(BaseModel, _EnableMixin):
+    """Configuration for indicator functions to implement inequality constraints.
+
+    Attributes
+    ----------
+    penalty: PenaltySetting
+        Custom penalty setting for indicator functions.
+    method: Literal["const", "str"]
+        Indicator function implementation method. Default: `"const"`
+        Two options are available:
+
+        - `"const"`: Applies a constant penalty for every constraint violation.
+        - `"if"`: Applies the objective function only if all constraints are satisfied.
+                  Automatically ensures objective to be negative.
+
+    enable : bool
+        Toggle to enable or disable this method. Default: True.
+    """
+
+    penalty: PenaltySetting = Field(
+        default_factory=lambda: PenaltySetting(scaling=1),
+        description="Penalty setting for indicator functions.",
+    )
+    method: Literal["if", "const"] = Field(
+        default="const",
+        description="Method of indicator function implementation. Constant Penalty "
+        "(const) or conditional application of cost function (if).",
+    )
+
+
+class XYMixerConfig(BaseModel, _EnableMixin):
+    """Configuration for XY-mixers to implement one-hot constraints.
+
+    Attributes
+    ----------
+    trotter : int
+        Number of trotter steps for XY-mixer implementation. Default: 1.
+    types: list[Literal["even", "odd", "last"]]
+        Mixer types in XY-ring-mixer. Default: `["even", "odd", "last"]`.
+    enable : bool
+        Toggle to enable or disable this method. Default: True.
+    """
+
+    trotter: int = Field(
+        default=1,
+        lt=1000,
+        ge=1,
+        description="Number of trotter steps for XY-mixer implementation.",
+    )
+    types: list[Literal["even", "odd", "last"]] = Field(
+        default=["even", "odd", "last"],
+        description='Mixer types in XY-ring-mixer. Default: `["even", "odd", "last"]`',
+    )
+
+
+class QuadraticPenaltyConfig(BaseModel, _EnableMixin):
+    """Configuration for quadratic penalties.
+
+    Adds penalty terms to the objective. Adds slack variables for inequality constraints
+    if neccessaray.
+
+    Attributes
+    ----------
+    penalty : PenaltySetting
+        Custom penalty setting for quadratic penalty terms.
+    enable : bool
+        Toggle to enable or disable this method. Default: True.
+    """
+
+    penalty: PenaltySetting = Field(
+        default_factory=lambda: PenaltySetting(scaling=2.0),
+        description="Penalty setting for quadratic penalties.",
+    )
+
+
+class SetpackingAsOnehotConfig(BaseModel, _EnableMixin):
+    """Configuration for set-packing to one-hot constraint transformation.
+
+    Attributes
+    ----------
+    enable : bool
+        Toggle to enable or disable this method. Default: True.
+    """
+
+
+class InequalityToEqualityConfig(BaseModel, _EnableMixin):
+    """Configuration for inequality to equality constraint transformation.
+
+    Attributes
+    ----------
+    max_slack : int
+        Maximum number of slack bits to add for each constraint. Default: 10.
+    enable : bool
+        Toggle to enable or disable this method. Default: True.
+    """
+
+    max_slack: int = Field(
+        default=10,
+        description="Maximum number of slack bits to add for each constraint.",
+    )
+
+
+class PipelineParams(BaseModel):
+    """Define the modular FlexQAOA Pipeline.
+
+    Attributes
+    ----------
+    penalty : PenaltySetting
+        General penalty factor settings.
+    inequality_to_equality : InequalityToEqualityConfig
+        Configuration of the "inequality to equality" transformation.
+    setpacking_as_onehot : SetpackingAsOnehotConfig
+        Configuration of the "setpacking to onehot" transformation.
+    xy_mixer : XYMixerConfig
+        Configuration of the XY-mixers.
+    indicator_function : IndicatorFunctionConfig
+        Configuration of the indicator functions.
+    sp_quadratic_penalty : QuadraticPenaltyConfig
+        Configuration of the setpacking quadratic penalty function.
+    quadratic_penalty : QuadraticPenaltyConfig
+        Configuration of the general quadratic penalty function.
+    """
+
+    penalty: PenaltySetting = Field(default_factory=lambda: PenaltySetting(scaling=2.0))
+    inequality_to_equality: InequalityToEqualityConfig = Field(
+        default_factory=InequalityToEqualityConfig
+    )
+    setpacking_as_onehot: SetpackingAsOnehotConfig = Field(
+        default_factory=SetpackingAsOnehotConfig
+    )
+    xy_mixer: XYMixerConfig = Field(default_factory=XYMixerConfig)
+    indicator_function: IndicatorFunctionConfig = Field(
+        default_factory=IndicatorFunctionConfig
+    )
+    sp_quadratic_penalty: QuadraticPenaltyConfig = Field(
+        default_factory=QuadraticPenaltyConfig
+    )
+    quadratic_penalty: QuadraticPenaltyConfig = Field(
+        default_factory=QuadraticPenaltyConfig
+    )