luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/parameters/backends/__init__.py

@@ -0,0 +1,27 @@
+from .aqarios import Aqarios
+from .aqarios_gpu import AqariosGpu
+from .aws import AWS, IQM, IonQ, Rigetti
+from .cudaq import CudaqCpu, CudaqGpu
+from .dwave import DWave
+from .dwave_qpu import DWaveQpu
+from .fda import Fujitsu
+from .ibm import IBM
+from .qctrl import Qctrl
+from .zib import ZIB
+
+__all__: list[str] = [
+    "AWS",
+    "IBM",
+    "IQM",
+    "ZIB",
+    "Aqarios",
+    "AqariosGpu",
+    "CudaqCpu",
+    "CudaqGpu",
+    "DWave",
+    "DWaveQpu",
+    "Fujitsu",
+    "IonQ",
+    "Qctrl",
+    "Rigetti",
+]

luna_quantum/solve/parameters/backends/aqarios.py

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

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/backends/aws/__init__.py

@@ -0,0 +1,11 @@
+from .aws import AWS
+from .ionq import IonQ
+from .iqm import IQM
+from .rigetti import Rigetti
+
+__all__ = [
+    "AWS",
+    "IQM",
+    "IonQ",
+    "Rigetti",
+]

luna_quantum/solve/parameters/backends/aws/aws.py

@@ -0,0 +1,36 @@
+from typing import Literal
+
+from pydantic import computed_field
+
+from .aws_backend_base import AWSBackendBase
+
+
+class AWS(AWSBackendBase):
+    """
+    Configuration parameters for AWS simulator backends.
+
+    Attributes
+    ----------
+    device: Literal["SV1", "DM1", "TN1"], default="SV1"
+        The specific AWS simulator to use for computations. Options are:
+
+        - "SV1": State vector simulator for smaller quantum circuits
+        - "DM1": Density matrix simulator for noisy quantum circuits
+        - "TN1": Tensor network simulator for larger quantum circuits
+
+        See the [AWS Braket
+        docs](https://docs.aws.amazon.com/braket/latest/developerguide/choose-a-simulator.html)
+    aws_access_key: str | QpuToken | None
+        The AWS access key
+    aws_secret_access_key: str | QpuToken | None
+        The AWS secret access key
+    aws_session_token: str | QpuToken | None
+        The AWS session token
+    """
+
+    @computed_field
+    def device_provider(self) -> str:
+        """Return the device provider identifier."""
+        return "Amazon"
+
+    device: Literal["SV1", "DM1", "TN1"] = "SV1"

luna_quantum/solve/parameters/backends/aws/aws_backend_base.py

@@ -0,0 +1,74 @@
+from pydantic import Field
+
+from luna_quantum.client.schemas.qpu_token.qpu_token import (
+    QpuToken,
+    QpuTokenSource,
+    TokenProvider,
+)
+from luna_quantum.solve.domain.abstract.qpu_token_backend import QpuTokenBackend
+
+
+class AWSBackendBase(QpuTokenBackend):
+    """AWS Backend Mixin.
+
+    Attributes
+    ----------
+    aws_access_key: str | QpuToken | None
+        The AWS access key
+    aws_secret_access_key: str | QpuToken | None
+        The AWS secret access key
+    aws_session_token: str | QpuToken | None
+        The AWS session token
+    """
+
+    aws_access_key: str | QpuToken | None = Field(
+        repr=False, exclude=True, default=None
+    )
+    aws_secret_access_key: str | QpuToken | None = Field(
+        repr=False, exclude=True, default=None
+    )
+    aws_session_token: str | QpuToken | None = Field(
+        repr=False, exclude=True, default=None
+    )
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "aws"
+
+    def _get_token(self) -> TokenProvider | None:
+        if self.aws_access_key is None and self.aws_secret_access_key is None:
+            return None
+
+        token_provider = TokenProvider()
+        if isinstance(self.aws_access_key, QpuToken):
+            token_provider.aws_access_key = self.aws_access_key
+        elif isinstance(self.aws_access_key, str):
+            token_provider.aws_access_key = QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=self.aws_access_key,
+            )
+
+        if isinstance(self.aws_secret_access_key, QpuToken):
+            token_provider.aws_secret_access_key = self.aws_secret_access_key
+        elif isinstance(self.aws_secret_access_key, str):
+            token_provider.aws_secret_access_key = QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=self.aws_secret_access_key,
+            )
+
+        if isinstance(self.aws_session_token, QpuToken):
+            token_provider.aws_session_token = self.aws_session_token
+        elif isinstance(self.aws_session_token, str):
+            token_provider.aws_session_token = QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=self.aws_session_token,
+            )
+        return token_provider

luna_quantum/solve/parameters/backends/aws/ionq.py

@@ -0,0 +1,43 @@
+from typing import Literal
+
+from pydantic import computed_field
+
+from .aws_backend_base import AWSBackendBase
+
+
+class IonQ(AWSBackendBase):
+    """
+    Configuration parameters for IonQ quantum backends, accessed via AWS.
+
+    Attributes
+    ----------
+    device: Literal["Aria1", "Aria2", "Forte1", "ForteEnterprise1"], \
+        default="Aria1"
+        The specific IonQ quantum device to use for computations. Options are:
+
+        - "Aria1": IonQ's flagship trapped-ion quantum computer
+        - "Aria2": Next-generation IonQ system with improved connectivity
+        - "Forte1": IonQ's enterprise-grade quantum system
+        - "ForteEnterprise1": Enhanced enterprise version with dedicated access
+
+        Different devices have varying characteristics such as qubit count,
+        connectivity, and error rates.
+    aws_access_key: str | QpuToken | None
+        The AWS access key
+    aws_secret_access_key: str | QpuToken | None
+        The AWS secret access key
+    aws_session_token: str | QpuToken | None
+        The AWS session token
+    """
+
+    device: Literal[
+        "Aria1",
+        "Aria2",
+        "Forte1",
+        "ForteEnterprise1",
+    ] = "Aria1"
+
+    @computed_field
+    def device_provider(self) -> str:
+        """Return the device provider identifier."""
+        return "IonQ"

luna_quantum/solve/parameters/backends/aws/iqm.py

@@ -0,0 +1,31 @@
+from typing import Literal
+
+from pydantic import computed_field
+
+from .aws_backend_base import AWSBackendBase
+
+
+class IQM(AWSBackendBase):
+    """
+    Configuration parameters for IQM quantum backends, accessed via AWS.
+
+    Attributes
+    ----------
+    device: Literal["Garnet"], default="Garnet"
+        The specific IQM quantum device to use for computations. Currently only
+        "Garnet" is available - IQM's superconducting quantum processor with
+        native two-qubit gates and optimized for near-term algorithms.
+    aws_access_key: str | QpuToken | None
+        The AWS access key
+    aws_secret_access_key: str | QpuToken | None
+        The AWS secret access key
+    aws_session_token: str | QpuToken | None
+        The AWS session token
+    """
+
+    device: Literal["Garnet"] = "Garnet"
+
+    @computed_field
+    def device_provider(self) -> str:
+        """Return the device provider identifier."""
+        return "IQM"

luna_quantum/solve/parameters/backends/aws/rigetti.py

@@ -0,0 +1,31 @@
+from typing import Literal
+
+from pydantic import computed_field
+
+from .aws_backend_base import AWSBackendBase
+
+
+class Rigetti(AWSBackendBase):
+    """
+    Configuration parameters for Rigetti quantum backends, accessed via AWS.
+
+    Attributes
+    ----------
+    device: Literal["Ankaa3"], default="Ankaa3"
+        The specific Rigetti quantum device to use for computations. Currently only
+        "Ankaa-3" is available - Rigetti's latest superconducting quantum processor
+        featuring improved coherence times and gate fidelities.
+    aws_access_key: str | QpuToken | None
+        The AWS access key
+    aws_secret_access_key: str | QpuToken | None
+        The AWS secret access key
+    aws_session_token: str | QpuToken | None
+        The AWS session token
+    """
+
+    device: Literal["Ankaa3"] = "Ankaa3"
+
+    @computed_field
+    def device_provider(self) -> str:
+        """Return the device provider identifier."""
+        return "Rigetti"

luna_quantum/solve/parameters/backends/cudaq/__init__.py

@@ -0,0 +1,5 @@
+from .cudaq_base import BaseCudaqBackend
+from .cudaq_cpu import CudaqCpu
+from .cudaq_gpu import CudaqGpu
+
+__all__ = ["BaseCudaqBackend", "CudaqCpu", "CudaqGpu"]

luna_quantum/solve/parameters/backends/cudaq/cudaq_base.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from pydantic import SerializationInfo, SerializerFunctionWrapHandler, model_serializer
+
+from luna_quantum.solve.interfaces.backend_i import IBackend
+
+
+class BaseCudaqBackend(IBackend):
+    """CudaQBackend."""
+
+    @model_serializer(mode="wrap")
+    def _serialize(
+        self, serializer: SerializerFunctionWrapHandler, _: SerializationInfo
+    ) -> dict[str, dict[str, Any]]:
+        data = serializer(self)
+        return {"backend": data}

luna_quantum/solve/parameters/backends/cudaq/cudaq_cpu.py

@@ -0,0 +1,30 @@
+from typing import Literal
+
+from .cudaq_base import BaseCudaqBackend
+
+
+class CudaqCpu(BaseCudaqBackend):
+    """CUDA-Q CPU Simulator.
+
+    Use a NVIDIA CUDA-Q CPU simulator for circuit execution on Aqarios servers.
+
+    You have the choice between the statevector simulator `"qpp-cpu"` and the density
+    matrix based simulator `"density-matrix-cpu"`.
+
+    For more information on the simulators pelase refer to the
+    [CUDA-Q documentation.](https://nvidia.github.io/cuda-quantum/latest/using/backends/simulators.html)
+    """
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "cudaq"
+
+    target: Literal["qpp-cpu", "density-matrix-cpu"] = "qpp-cpu"

luna_quantum/solve/parameters/backends/cudaq/cudaq_gpu.py

@@ -0,0 +1,32 @@
+from typing import Literal
+
+from luna_quantum.solve.parameters.backends.cudaq.cudaq_base import BaseCudaqBackend
+
+
+class CudaqGpu(BaseCudaqBackend):
+    """CUDA-Q GPU Simulator.
+
+    Use a NVIDIA CUDA-Q GPU simulator for circuit execution on Aqarios servers.
+
+    You have the choice between the statevector simulator `"nvidia"`, and two tensor
+    network based simulators `"tensornet"` and `"tensornet-mps"`.
+    The floating point precision can be increased by setting `option` to `"fp64"`.
+
+    For more information on the simulators pelase refer to the
+    [CUDA-Q documentation.](https://nvidia.github.io/cuda-quantum/latest/using/backends/simulators.html)
+    """
+
+    @property
+    def provider(self) -> str:
+        """
+        Retrieve the name of the provider.
+
+        Returns
+        -------
+        str
+            The name of the provider.
+        """
+        return "cudaq-gpu"
+
+    target: Literal["nvidia", "tensornet", "tensornet-mps"] = "nvidia"
+    option: Literal["fp64", "fp32"] = "fp32"

luna_quantum/solve/parameters/backends/dwave.py

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

luna_quantum/solve/parameters/backends/dwave_qpu.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+from pydantic import BaseModel, Field, StringConstraints
+
+from luna_quantum.client.schemas import QpuToken, QpuTokenSource, TokenProvider
+from luna_quantum.solve.domain.abstract.qpu_token_backend import QpuTokenBackend
+from luna_quantum.solve.parameters.backends.dwave import DWave
+
+
+class DWaveQpu(DWave, QpuTokenBackend):
+    """
+    Configuration for D-Wave quantum processing backends.
+
+    This class provides settings for problem decomposition and embedding when using
+    D-Wave quantum processors. It can be configured to use either manual embedding
+    parameters or automatic embedding based on problem characteristics.
+
+    Attributes
+    ----------
+    embedding_parameters: Embedding | AutoEmbedding | None
+        Detailed configuration for manual embedding when not using auto-embedding.
+        If None and decomposer is also None, default embedding parameters will be used.
+        Ignored if decomposer is set to AutoEmbedding. Default is None.
+    qpu_backend: str
+        Specific D-Wave quantum processing unit (QPU) for your optimization
+    """
+
+    class Embedding(BaseModel):
+        """
+        Configuration parameters for embedding problems onto D-Wave QPUs.
+
+        Embedding maps logical variables from a problem to physical qubits on the QPU,
+        with chains of qubits representing individual variables.
+
+        Attributes
+        ----------
+        max_no_improvement: int, default=10
+            Maximum number of consecutive failed iterations to improve the current
+            solution before giving up. Each iteration attempts to find an embedding for
+            each variable such that it is adjacent to all its neighbors.
+
+        random_seed: Optional[int], default=None
+            Seed for the random number generator. If None, seed is set by
+            `os.urandom()`.
+
+        timeout: int, default=1000
+            Maximum time in seconds before the algorithm gives up.
+
+        max_beta: Optional[float], default=None
+            Controls qubit weight assignment using formula (beta^n) where n is the
+            number of chains containing that qubit. Must be greater than 1 if specified.
+             If None, `max_beta` is effectively infinite.
+
+        tries: int, default=10
+            Number of restart attempts before the algorithm stops. On D-Wave 2000Q, a
+            typical restart takes between 1 and 60 seconds.
+
+        inner_rounds: Optional[int], default=None
+            Maximum iterations between restart attempts. Restart attempts are typically
+            terminated due to `max_no_improvement`. If None, effectively infinite.
+
+        chainlength_patience: int, default=10
+            Maximum number of consecutive failed iterations to improve chain lengths
+            before moving on. Each iteration attempts to find more efficient embeddings.
+
+        max_fill: Optional[int], default=None
+            Restricts the number of chains that can simultaneously use the same qubit
+            during search. Values above 63 are treated as 63. If None, effectively
+            infinite.
+
+        threads: int, default=1
+            Maximum number of threads to use. Parallelization is only advantageous when
+            the expected variable degree significantly exceeds the thread count. Min: 1.
+
+        return_overlap: bool, default=False
+            Controls return value format:
+
+            - True: Returns (embedding, validity_flag) tuple
+            - False: Returns only the embedding
+
+            This function returns an embedding regardless of whether qubits are used by
+            multiple variables.
+
+        skip_initialization: bool, default=False
+            If True, skips the initialization pass. Only works with semi-valid
+            embeddings provided through `initial_chains` and `fixed_chains`.
+            A semi-valid embedding has chains where every adjacent variable pair (u,v)
+            has a coupler (p,q) in the hardware with p in chain(u) and q in chain(v).
+
+        initial_chains: Any, default=()
+            Initial chains inserted before `fixed_chains` and before initialization.
+            Can be used to restart algorithm from a previous state. Missing or empty
+            entries are ignored. Each value is a list of qubit labels.
+
+        fixed_chains: Any, default=()
+            Fixed chains that cannot change during the algorithm. Qubits in these chains
+            are not used by other chains. Missing or empty entries are ignored.
+            Each value is a list of qubit labels.
+
+        restrict_chains: Any, default=()
+            Restricts each chain[i] to be a subset of `restrict_chains[i]` throughout
+            the algorithm. Missing or empty entries are ignored. Each value is a list
+            of qubit labels.
+
+        suspend_chains: Any, default=()
+            A metafeature only implemented in the Python interface. For each suspended
+            variable i, `suspend_chains[i]` is an iterable of iterables (blobs).
+            For each blob in a suspension, at least one qubit from that blob must be
+            in the chain for variable i.
+        """
+
+        max_no_improvement: int = 10
+        random_seed: int | None = None
+        timeout: int = 1_000
+        max_beta: float | None = None
+        tries: int = 10
+        inner_rounds: int | None = None
+        chainlength_patience: int = 10
+        max_fill: int | None = None
+        threads: int = Field(default=1, ge=1)
+        return_overlap: bool = False
+        skip_initialization: bool = False
+        initial_chains: dict = Field(default_factory=dict)  # type: ignore[type-arg]
+        fixed_chains: dict = Field(default_factory=dict)  # type: ignore[type-arg]
+        restrict_chains: dict = Field(default_factory=dict)  # type: ignore[type-arg]
+        suspend_chains: dict = Field(default_factory=dict)  # type: ignore[type-arg]
+
+    class AutoEmbedding(BaseModel):
+        """
+        Configuration for automatic embedding of problems onto D-Wave hardware.
+
+        This class provides a simpler interface to configure the embedding process
+        when the details of the underlying hardware are not known or when optimal
+        embedding parameters should be determined automatically.
+
+        Attributes
+        ----------
+        embedding_parameters: EmbeddingParameters, default=EmbeddingParameters()
+            Detailed configuration parameters for the embedding algorithm.
+            See EmbeddingParameters documentation for details on specific settings.
+        """
+
+        embedding_parameters: DWaveQpu.Embedding = Field(
+            default_factory=lambda: DWaveQpu.Embedding()
+        )
+
+    embedding_parameters: Embedding | AutoEmbedding | None = None
+    qpu_backend: Annotated[
+        str, StringConstraints(strip_whitespace=True, min_length=1)
+    ] = "default"
+
+    token: str | QpuToken | None = Field(repr=False, exclude=True, default=None)
+
+    def _get_token(self) -> TokenProvider | None:
+        if self.token is None:
+            return None
+        if isinstance(self.token, QpuToken):
+            return TokenProvider(dwave=self.token)
+        return TokenProvider(
+            dwave=QpuToken(
+                source=QpuTokenSource.INLINE,
+                token=self.token,
+            )
+        )

luna_quantum/solve/parameters/backends/fda.py

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