luna-quantum 1.0.8rc2__cp311-cp311-win_amd64.whl → 1.0.8rc4__cp311-cp311-win_amd64.whl

luna_quantum/solve/parameters/algorithms/quantum_gate/{flex_qaoa/flex_qaoa.py → flexqaoa/flexqaoa.py}

@@ -1,9 +1,10 @@
 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.errors.solve_base_error import SolveBaseError
 from luna_quantum.solve.parameters.algorithms.base_params.qaoa_circuit_params import (
     BasicQAOAParams,
     LinearQAOAParams,
@@ -13,51 +14,20 @@ 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 luna_quantum.solve.parameters.backends.aqarios_gpu import AqariosGpu
+from luna_quantum.solve.parameters.errors import (
+    InterpolateOptimizerError,
+    QAOAParameterOptimizerError,
+    QAOAParameterRepsMismatchError,
 )
-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=}.")
+from .config import CustomConfig
+from .optimizers import CombinedOptimizerParams, InterpolateOptimizerParams
+from .pipeline import PipelineParams
 
 
-class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
-    """The FlexQAOA Algorithm for constrained quantum optimization.
+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
@@ -73,18 +43,11 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
     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
+    represented as quadratic penalties, the `xy_mixers` 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}
+    pipeline.xy_mixer.enable = False
+    pipeline.indicator_function.enable = False
     ```
 
     Following the standard protocol for QAOA, a classical optimizer is required that
@@ -100,24 +63,35 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
         Number of sampled shots.
     reps: int
         Number of QAOA layer repetitions
-    pipeline: PipelineParams | Dict
+    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 | LinearOptimizerParams | CombinedOptimizerParams |\
-        InterpolateOptimizerParams | None | Dict
-        The classical optimizer for parameter tuning. Default: ScipyOptimizer. Setting
+    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.
-    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.
+    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, description="Number of sampled shots.")
-    reps: int = Field(default=1, ge=1, description="Number of QAOA layer repetitions")
+    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 "
@@ -126,7 +100,6 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
     )
     optimizer: (
         ScipyOptimizerParams
-        | LinearOptimizerParams
         | CombinedOptimizerParams
         | InterpolateOptimizerParams
         | None
@@ -134,36 +107,25 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
         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.",
     )
+    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, 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, 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
@@ -177,7 +139,7 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
             isinstance(self.initial_params, BasicQAOAParams)
             and self.initial_params.reps != self.reps
         ):
-            raise QAOAParameterDepthMismatchError(self.initial_params.reps, self.reps)
+            raise QAOAParameterRepsMismatchError(self.initial_params.reps, self.reps)
         return self
 
     @property
@@ -213,7 +175,7 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
         return Aqarios()
 
     @classmethod
-    def get_compatible_backends(cls) -> tuple[type[Aqarios]]:
+    def get_compatible_backends(cls) -> tuple[type[Aqarios], type[AqariosGpu]]:
         """
         Check at runtime if the used backend is compatible with the solver.
 
@@ -223,4 +185,4 @@ class FlexQAOA(LunaAlgorithm[Aqarios], BaseModel):
             True if the backend is compatible with the solver, False otherwise.
 
         """
-        return (Aqarios,)
+        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
+    )

luna_quantum/solve/parameters/backends/__init__.py

@@ -1,4 +1,5 @@
 from .aqarios import Aqarios
+from .aqarios_gpu import AqariosGpu
 from .aws import AWS, IQM, IonQ, Rigetti
 from .dwave import DWave
 from .dwave_qpu import DWaveQpu
@@ -13,6 +14,7 @@ __all__: list[str] = [
     "IQM",
     "ZIB",
     "Aqarios",
+    "AqariosGpu",
     "DWave",
     "DWaveQpu",
     "Fujitsu",

luna_quantum/solve/parameters/backends/aqarios_gpu.py

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

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/usecases/solve_job_get_by_id_usecase.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING
+
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.interfaces.usecases.solve_job_get_by_id_usecase_i import (
+    ISolveJobGetByIdUseCase,
+)
+from luna_quantum.util.log_utils import Logging, progress
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.solve_job import SolveJobSchema
+
+
+class SolveJobGetByIdUseCase(ISolveJobGetByIdUseCase):
+    """
+    Represent an abstract base to retrieve a solve-job by its id.
+
+    This class interacts with a backend client to retrieve a solve job by its id.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        Client used to retrieve the solve job.
+    """
+
+    client: ILunaSolve
+    logger = Logging.get_logger(__name__)
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving solve job by id...")
+    def __call__(self, solve_job_id: str) -> SolveJob:
+        """
+        Retive a solve-job by its id.
+
+        Parameters
+        ----------
+        solve_job_id : str
+            The id of the solve-job to retrieve.
+        """
+        solve_job: SolveJobSchema = self.client.solve_job.get(solve_job_id=solve_job_id)
+
+        return SolveJob.model_validate(solve_job.model_dump())

luna_quantum/solve/usecases/solve_job_get_result_usecase.py

@@ -2,6 +2,9 @@ from luna_quantum._core import Solution
 from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
 from luna_quantum.client.schemas.enums.call_style import CallStyle
 from luna_quantum.client.schemas.enums.status import StatusEnum
+from luna_quantum.exceptions.luna_quantum_call_type_error import (
+    LunaQuantumCallStyleError,
+)
 from luna_quantum.solve.domain.solve_job import SolveJob
 from luna_quantum.solve.interfaces.usecases.solve_job_get_result_usecase_i import (
     ISolveJobGetResultUseCase,
@@ -61,19 +64,26 @@ class SolveJobGetResultUseCase(ISolveJobGetResultUseCase):
             The solution for the given solve job if successfully processed, otherwise
             None.
         """
-        if call_style is CallStyle.ACTIVE_WAITING:
-            final_states = StatusEnum.CANCELED, StatusEnum.DONE, StatusEnum.FAILED
+        match call_style:
+            case CallStyle.ACTIVE_WAITING:
+                final_states = StatusEnum.CANCELED, StatusEnum.DONE, StatusEnum.FAILED
 
-            ActiveWaiting.run(
-                loop_check=lambda: solve_job.get_status(
-                    client=self.client, status_source="remote"
+                ActiveWaiting.run(
+                    loop_check=lambda: solve_job.get_status(
+                        client=self.client, status_source="remote"
+                    )
+                    not in final_states,
+                    loop_call=None,
+                    sleep_time_max=sleep_time_max,
+                    sleep_time_increment=sleep_time_increment,
+                    sleep_time_initial=sleep_time_initial,
                 )
-                not in final_states,
-                loop_call=None,
-                sleep_time_max=sleep_time_max,
-                sleep_time_increment=sleep_time_increment,
-                sleep_time_initial=sleep_time_initial,
-            )
+            case CallStyle.SINGLE_FETCH:
+                solve_job.get_status(client=self.client, status_source="remote")
+
+            case _:
+                raise LunaQuantumCallStyleError(call_style)
+
         try:
             if solve_job.status == StatusEnum.CANCELED:
                 self.logger.warning(

{luna_quantum-1.0.8rc2.dist-info → luna_quantum-1.0.8rc4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luna-quantum
-Version: 1.0.8rc2
+Version: 1.0.8rc4
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent