luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/schemas/solver_parameters/dwave/parallel_tempering_qpu.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import (
+    Decomposer,
+    FixedTemperatureSampler,
+    Loop,
+    Qpu,
+)
+
+
+class ParallelTemperingQpuParameters(BaseModel):
+    """
+    Parallel Tempering uses multiple optimization procedures per temperature. During the cooling process,
+    an exchange of replicas can take place between the parallel procedures, thus enabling higher energy mountains to be overcome.
+
+    Parameters
+    ----------
+    n_replicas: int
+        Number of replicas for the parallel tempering.
+    decomposer: Decomposer
+        Parameters for the decomposer.
+    qpu: Qpu
+        Parameters for the QPU.
+    fixed_temperature_sampler: FixedTemperatureSampler
+        Parameters for the fixed temperature sampler.
+    cpu_count_multiplier: int
+        Multiplier for the CPU count.
+    loop: Loop
+        Parameters for the main loop of the algorithm.
+    """
+
+    n_replicas: int = 4
+    decomposer: Decomposer = Decomposer()
+    qpu: Qpu = Qpu()
+    fixed_temperature_sampler: FixedTemperatureSampler = FixedTemperatureSampler()
+    cpu_count_multiplier: int = 5
+    loop: Loop = Loop()

luna_sdk/schemas/solver_parameters/dwave/population_annealing.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import FixedTemperatureSampler
+
+
+class PopulationAnnealingParameters(BaseModel):
+    """
+    Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population.
+    The population consists of walkers that can explore their neighborhood during the cooling process.
+    Afterwards, walkers are removed and duplicated using bias to lower energy.
+    Eventually, a population collapse occurs where all walkers are in the lowest energy state.
+
+    Parameters
+    ----------
+    fixed_temperature_sampler: FixedTemperatureSampler
+        Parameters for the fixed temperature sampler.
+    max_iter: int
+        Maximum number of iterations. Default is 20.
+    max_time: int
+        Maximum time in seconds that the algorithm is allowed to run. Default is 2.
+    """
+
+    fixed_temperature_sampler: FixedTemperatureSampler = FixedTemperatureSampler()
+    max_iter: int = 20
+    max_time: int = 2

luna_sdk/schemas/solver_parameters/dwave/population_annealing_qpu.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import (
+    Decomposer,
+    FixedTemperatureSampler,
+    Qpu,
+)
+
+
+class PopulationAnnealingQpuParameters(BaseModel):
+    """
+    Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population.
+    The population consists of walkers that can explore their neighborhood during the cooling process.
+    Afterwards, walkers are removed and duplicated using bias to lower energy.
+    Eventually, a population collapse occurs where all walkers are in the lowest energy state.
+
+    Parameters
+    ----------
+    decomposer: Decomposer
+        Parameters for the decomposer, which selects variables for the graph search to stop.
+    qpu: Qpu
+        Parameters for the Quantum Processing Unit (QPU).
+    fixed_temperature_sampler: FixedTemperatureSampler
+        Parameters for the fixed temperature sampler.
+    max_iter: int
+        Maximum number of iterations.
+    max_time: int
+        Maximum time in seconds that the algorithm is allowed to run.
+    """
+
+    decomposer: Decomposer = Decomposer()
+    qpu: Qpu = Qpu()
+    fixed_temperature_sampler: FixedTemperatureSampler = FixedTemperatureSampler()
+    max_iter: int = 20
+    max_time: int = 2

luna_sdk/schemas/solver_parameters/dwave/qaga.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
+
+class QAGAParameters(BaseModel):
+    """
+    Parameters for the Quantum Assisted Genetic Algorithm (QAGA).
+    QAGA combines the principles of genetic algorithms and quantum annealing to solve optimization problems.
+
+    Parameters
+    ----------
+    p_size: int
+        Size of the population.
+    p_inc_num: int
+        Number of individuals that are added to the population size after each iteration.
+    p_max: Optional[int]
+        Maximum size of the population.
+    pct_random_states: float
+        Percentage of random states that are added to the population after each iteration.
+    mut_rate: float
+        Mutation rate, i.e., probability to mutate an individual. Min: 0.0, Max: 1.0
+    rec_rate: int
+        Recombination rate, i.e. number of mates each individual is recombined with after each iteration
+    rec_method: Literal['cluster_moves', 'one_point_crossover', 'random_crossover']
+        The recombination method for the genetic algorithm.
+    select_method: Literal['simple', 'shared_energy']
+        Method used for the selection phase in the genetic algorithm.
+    target: Optional[float]
+        Energy level that the algorithm tries to reach. If `None`, the algorithm will run until any other stopping criterion is reached.
+    atol: float
+        Absolute tolerance used to compare the energies of the target and the individuals.
+    rtol: float
+        Relative tolerance used to compare the energies of the target and the individuals.
+    timeout: float
+        The total solving time after which the solver should be stopped. This total solving time includes preprocessing, network overhead when communicating with DWave's API, as well as the actual annealing time.
+    max_iter: Optional[int]
+        Maximum number of iterations after which the algorithm will stop.
+    """
+
+    p_size: int = 20
+    p_inc_num: int = 5
+    p_max: Optional[int] = 160
+    pct_random_states: float = 0.25
+    mut_rate: float = Field(default=0.5, ge=0.0, le=1.0)
+    rec_rate: int = 1
+    rec_method: Literal["cluster_moves", "one_point_crossover", "random_crossover"] = (
+        "random_crossover"
+    )
+    select_method: Literal["simple", "shared_energy"] = "simple"
+    target: Optional[float] = None
+    atol: float = 0.0
+    rtol: float = 0.0
+    timeout: float = 60.0
+    max_iter: Optional[int] = 100

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_qpu.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, Qpu
+
+
+class QbSolvLikeQpuParameters(BaseModel):
+    """
+    QBSolv QPU splits the problem into parts and solves them using the Tabu Search algorithm. For this purpose, the DWaveSampler is used.
+
+    Parameters
+    ----------
+    qbsolv_like: QBSOLVLike
+        Parameters for the QBSOLV-like solver.
+    qpu: Qpu
+        QPU parameters
+    """
+
+    qbsolv_like: QBSOLVLike = QBSOLVLike()
+    qpu: Qpu = Qpu()

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_simulated_annealing.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, SimulatedAnnealing
+
+
+class QbSolvLikeSimulatedAnnealingParameters(BaseModel):
+    """
+    QBSolv Like Simulated Annealing breaks down the problem and solves the parts individually using a classic solver that uses Simulated Annealing.
+    This particular implementation uses hybrid.SimulatedAnnealingSubproblemSampler
+    (https://docs.ocean.dwavesys.com/projects/hybrid/en/stable/reference/samplers.html#simulatedannealingsubproblemsampler)
+    as a sampler for the subproblems to achieve a QBSolv like behaviour.
+
+    Parameters
+    ----------
+    qbsolv_like: QBSOLVLike
+        Parameters for the QbSolveLike solver.
+    simulated_annealing: SimulatedAnnealing
+        Parameters for the Simulated Annealing.
+    """
+
+    qbsolv_like: QBSOLVLike = QBSOLVLike()
+    simulated_annealing: SimulatedAnnealing = SimulatedAnnealing()

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_tabu_search.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, Tabu
+
+
+class QbSolvLikeTabuSearchParameters(BaseModel):
+    """
+    QBSolv Like Tabu Search breaks down the problem and solves the parts individually using a classic solver that uses Tabu Search.
+    This particular implementation uses hybrid.TabuSubproblemSampler (https://docs.ocean.dwavesys.com/projects/hybrid/en/stable/reference/samplers.html#tabusubproblemsampler)
+    as a sampler for the subproblems to achieve a QBSolv like behaviour.
+
+    Parameters
+    ----------
+    qbsolv_like: QBSOLVLike
+        Parameters for the QbSolveLike solver.
+    tabu_search: Tabu
+        Parameters for the Tabu Search.
+    """
+
+    qbsolv_like: QBSOLVLike = QBSOLVLike()
+    tabu_search: Tabu = Tabu()

luna_sdk/schemas/solver_parameters/dwave/quantum_annealing.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.dwave import Embedding, SamplingParams
+
+
+class QuantumAnnealingParameters(BaseModel):
+    """
+    Parameters for the Quantum Annealing solver.
+
+    Parameters
+    ----------
+    embedding: Embedding
+        Parameters for the auto embedding.
+    sampling_params: SamplingParams
+        Parameters for the sampling. See https://docs.dwavesys.com/docs/latest/c_solver_parameters.html
+        for more details.
+    """
+
+    embedding: Embedding = Embedding()
+    sampling_params: SamplingParams = SamplingParams()

luna_sdk/schemas/solver_parameters/dwave/repeated_reverse_quantum_annealing.py

@@ -0,0 +1,82 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class RRQuantumAnnealingSamplingParams(BaseModel):
+    """
+    Parameters
+    ----------
+    anneal_offsets: Optional[Any]
+        Anneal offsets for the sampling.
+    annealing_time: Optional[Any]
+        Annealing time for the sampling.
+    auto_scale: Optional[Any]
+        Whether to auto scale for the sampling.
+    flux_biases: Optional[Any]
+        Flux biases for the sampling.
+    flux_drift_compensation: bool
+        Whether to use flux drift compensation.
+    h_gain_schedule: Optional[Any]
+        H gain schedule for the sampling.
+    max_answers: Optional[int]
+        Maximum number of answers for the sampling. Min: 1
+    programming_thermalization: Optional[float]
+        Programming thermalization for the sampling. Has to be positive.
+    readout_thermalization: Optional[float]
+        Readout thermalization for the sampling. Has to be positive.
+    reduce_intersample_correlation: bool
+        Whether to reduce intersample correlation for the sampling.
+    """
+
+    anneal_offsets: Optional[Any] = None
+    annealing_time: Optional[Any] = None
+    auto_scale: Optional[Any] = None
+    flux_biases: Optional[Any] = None
+    flux_drift_compensation: bool = True
+    h_gain_schedule: Optional[Any] = None
+    max_answers: Optional[int] = Field(default=None, ge=1)
+    programming_thermalization: Optional[float] = Field(default=None, gt=0)
+    readout_thermalization: Optional[float] = Field(default=None, gt=0)
+    reduce_intersample_correlation: bool = False
+
+
+class RepeatedReverseQuantumAnnealingParameters(BaseModel):
+    """
+    Repeated Reverse Quantum Annealing begins the annealing process from a previously initialized state and increases the temperature from there.
+    Afterwards, the temperature is decreased again until the solution is found.
+    This procedure is repeated several times with this particular solver. (for additional information see: D-Wave Reverse Annealing)
+
+    Parameters
+    ----------
+    sampling_params: RRQuantumAnnealingSamplingParams
+        Parameters for the RRQuantumAnnealingSamplingParams. See https://docs.dwavesys.com/docs/latest/c_solver_parameters.html for more details.
+    initial_states: Optional[List[Dict[str, int]]]
+        Initial states for the solver. For each list element `state`, one call to the sampler with the parameter `initial_state=state` will be made in the first iteration.
+    n_initial_states: int
+        Number of initial states to create when `initial_states` is None. If `initial_states` is not None, this parameter will be ignored. Min: 1
+    samples_per_state: int
+        How many samples to create per state in each iteration after the first. Min: 1
+    beta_schedule: List[float]
+        Beta schedule for the solver.
+    timeout: float
+        Timeout for the solver.
+    max_iter: int
+        Maximum number of iterations for the solver.
+    target: Optional[Any]
+        The target energy for the solving process.
+    check_trivial: bool
+        Whether to check for trivial variables. Checking for trivial variables means an overhead. On the other hand, when set to `False`, trivial variables, i.e., variables without interactions, will lead to a runtime error.
+    """
+
+    sampling_params: RRQuantumAnnealingSamplingParams = (
+        RRQuantumAnnealingSamplingParams()
+    )
+    initial_states: Optional[List[Dict[str, int]]] = None
+    n_initial_states: int = Field(default=1, ge=1)
+    samples_per_state: int = Field(default=1, ge=1)
+    beta_schedule: List[float] = [0.5, 3]
+    timeout: float = 300
+    max_iter: int = 10
+    target: Optional[Any] = None
+    check_trivial: bool = True

luna_sdk/schemas/solver_parameters/dwave/repeated_reverse_simulated_annealing.py

@@ -0,0 +1,89 @@
+from typing import Any, List, Optional, Sequence
+
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
+from luna_sdk.schemas.solver_parameters.dwave import SimulatedAnnealing
+
+
+class RRSimulatedAnnealing(SimulatedAnnealing):
+    """
+    Parameters
+    ----------
+    num_reads: Optional[int]
+        Number of reads. Each read is generated by one run of the simulated annealing
+        algorithm. If `num_reads` is not explicitly given, it is selected to match the
+        number of initial states given. If initial states are not provided, only one
+        read is performed.
+    num_sweeps: Optional[int]
+        Number of sweeps used in annealing.
+    beta_range: Union[List[float], Tuple[float, float], NoneType]
+        A 2-tuple defining the beginning and end of the beta schedule, where beta is the
+        inverse temperature. The schedule is applied linearly in beta. Default range is
+        set based on the total bias associated with each node.
+    beta_schedule_type: Literal['linear', 'geometric']
+        Beta schedule type, or how the beta values are interpolated between the given
+        'beta_range'.
+    initial_states_generator: Literal['none', 'tile', 'random']
+        Defines the expansion of `initial_states` if fewer than `num_reads` are
+        specified:
+        'none:' if the number of initial states specified is smaller than `num_reads`,
+        raises an error.
+        'tile': reuses the specified initial states if fewer than `num_reads` or
+        truncates if greater.
+        'random': expands the specified initial states with randomly generated states if
+        fewer than `num_reads` or truncates if greater.
+    num_sweeps_per_beta: int
+        Number of sweeps to perform at each `beta`. One sweep consists of a sequential
+        Metropolis update of all spins.
+    beta_schedule: Optional[Sequence[float]]
+        Sequence of `beta` values swept. Format must be compatible with
+        `numpy.array(beta_schedule, dtype=float)`. Values should be non-negative.
+    randomize_order: bool
+        When `True`, each spin update selects a variable uniformly at random. This
+        method is ergodic, obeys detailed balance and preserves symmetries of the model.
+        When `False`, updates proceed sequentially through the labeled variables on each
+        sweep so that all variables are updated once per sweep. This method:
+        * can be non-ergodic in special cases when used with
+        `proposal_acceptance_critera=='Metropolis'`.
+        * can introduce a dynamical bias as a function of variable order.
+        * has faster per spin update than the True method.
+    proposal_acceptance_criteria: Literal['Gibbs', 'Metropolis']
+        When 'Gibbs', each spin flip proposal is accepted according to the Gibbs
+        criteria. When 'Metropolis', each spin flip proposal is accepted according to
+        the Metropolis-Hastings criteria.
+    """
+
+    num_sweeps: Optional[int] = None
+    num_sweeps_per_beta: int = 1
+    beta_schedule: Optional[Sequence[float]] = None
+    randomize_order: bool = False
+    proposal_acceptance_criteria: Literal["Gibbs", "Metropolis"] = "Metropolis"
+
+
+class RepeatedReverseSimulatedAnnealingParameters(BaseModel):
+    """
+    Parameters for the Repeated Reverse Simulated Annealing solver.
+
+    Parameters
+    ----------
+    simulated_annealing: RRSimulatedAnnealing
+        Simulated Annealing params in each iteration.
+    num_reads_per_iter: Optional[List[int]]
+        Number of reads in each iteration. Use `num_reads_per_iter[i]` in iteration `i`, and `num_reads_per_iter[-1]` once the list is exhausted. If the parameter is `None`, fall back to `simulated_annealing.num_reads`. Min length: 1.
+    initial_states: Optional[Any]
+        One or more samples, each defining an initial state for all the problem variables. Initial states are given one per read, but if fewer than additional values are generated as specified by `initial_states_generator`. See `~dimod.as_samples` for a description of 'samples-like.
+    timeout: float
+        Timeout for the solver.
+    max_iter: int
+        Maximum number of iterations for the solver.
+    target: Optional[Any]
+        The target energy for the solver.
+    """
+
+    simulated_annealing: RRSimulatedAnnealing = RRSimulatedAnnealing()
+    num_reads_per_iter: Optional[List[int]] = Field(default=None, min_length=1)
+    initial_states: Optional[Any] = None
+    timeout: float = 5.0
+    max_iter: int = 10
+    target: Optional[Any] = None

luna_sdk/schemas/solver_parameters/dwave/saga.py

@@ -0,0 +1,61 @@
+from typing import Any, Literal, Optional, Tuple
+
+from pydantic import Field
+
+from luna_sdk.schemas.solver_parameters.dwave.qaga import QAGAParameters
+
+
+class SAGAParameters(QAGAParameters):
+    """
+    Parameters for the Simulated Annealing Assisted Genetic Algorithm (SAGA).
+    SAGA combines the principles of genetic algorithms and simulated annealing to solve optimization problems.
+
+    Parameters
+    ----------
+    p_size: int
+        Size of the population.
+    p_inc_num: int
+        Number of individuals that are added to the population size after each iteration.
+    p_max: Optional[int]
+        Maximum size of the population.
+    pct_random_states: float
+        Percentage of random states that are added to the population after each iteration.
+    mut_rate: float
+        Mutation rate, i.e., probability to mutate an individual. Min: 0.0, Max: 1.0
+    rec_rate: int
+        Recombination rate, i.e. number of mates each individual is recombined with after each iteration
+    rec_method: Literal['cluster_moves', 'one_point_crossover', 'random_crossover']
+        The recombination method for the genetic algorithm.
+    select_method: Literal['simple', 'shared_energy']
+        Method used for the selection phase in the genetic algorithm.
+    target: Optional[float]
+        Energy level that the algorithm tries to reach. If `None`, the algorithm will run until any other stopping criterion is reached.
+    atol: float
+        Absolute tolerance used to compare the energies of the target and the individuals.
+    rtol: float
+        Relative tolerance used to compare the energies of the target and the individuals.
+    timeout: float
+        The total solving time after which the solver should be stopped. This total solving time includes preprocessing, network overhead when communicating with DWave's API, as well as the actual annealing time.
+    max_iter: Optional[int]
+        Maximum number of iterations after which the algorithm will stop.
+    num_sweeps: int
+        The number of sweeps for simulated annealing.
+    num_sweeps_inc_factor: float
+        factor of increasement for `num_sweeps` after each iteration
+    num_sweeps_inc_max: Optional[int]
+        Maximum number of num_sweeps that may be reached when increasing the `num_sweeps` value.
+    beta_range_type: Literal['default', 'percent', 'fixed', 'inc']
+        Method that is used to compute the beta range.
+                default': the same as percent with values [50, 1]
+                'percent': the percentage chance of flipping qubits from hot to cold temperature
+                'fixed': a fixed temperature as a value
+                'inc': the default or percentage beta range but with decreasing percentages from iteration to iteration
+    beta_range: Optional[Tuple[float, float]]
+        Explicit beta range that is used for beta_range_type 'fixed' and 'percent'.
+    """
+
+    num_sweeps: int = 10
+    num_sweeps_inc_factor: float = 1.2
+    num_sweeps_inc_max: Optional[int] = 7_000
+    beta_range_type: Literal["default", "percent", "fixed", "inc"] = "default"
+    beta_range: Optional[Tuple[float, float]] = None

luna_sdk/schemas/solver_parameters/dwave/simulated_annealing.py

@@ -0,0 +1,74 @@
+from typing import Any, Optional, Sequence
+
+from typing_extensions import Literal
+
+from luna_sdk.schemas.solver_parameters.dwave import SimulatedAnnealing
+
+
+class SimulatedAnnealingParameters(SimulatedAnnealing):
+    """
+    Simulated Annealing finds the solution to a problem using a annealing process.
+    Initially, random states are chosen in the solution landscape.
+    Afterwards, as the temperature decreases, states are chosen that are more energetically favorable.
+    At the end of the complete annealing process, the resulting states make up the solution.
+
+    Parameters
+    ----------
+    num_reads: Optional[int]
+        Number of reads. Each read is generated by one run of the simulated annealing
+        algorithm. If `num_reads` is not explicitly given, it is selected to match the
+        number of initial states given. If initial states are not provided, only one
+        read is performed.
+    num_sweeps: Optional[int]
+        Number of sweeps used in annealing.
+    beta_range: Union[List[float], Tuple[float, float], NoneType]
+        A 2-tuple defining the beginning and end of the beta schedule, where beta is the
+        inverse temperature. The schedule is applied linearly in beta. Default range is
+        set based on the total bias associated with each node.
+    beta_schedule_type: Literal['linear', 'geometric']
+        Beta schedule type, or how the beta values are interpolated between the given
+        'beta_range'.
+    initial_states_generator: Literal['none', 'tile', 'random']
+        Defines the expansion of `initial_states` if fewer than `num_reads` are
+        specified:
+        'none:' if the number of initial states specified is smaller than `num_reads`,
+        raises an error.
+        'tile': reuses the specified initial states if fewer than `num_reads` or
+        truncates if greater.
+        'random': expands the specified initial states with randomly generated states if
+        fewer than `num_reads` or truncates if greater.
+    num_sweeps_per_beta: int
+        Number of sweeps to perform at each `beta`. One sweep consists of a sequential
+        Metropolis update of all spins.
+    seed: Optional[int]
+        Seed to use for the PRNG. Specifying a particular seed with a constant set of
+        parameters produces identical results. If not provided, a random seed is chosen.
+    beta_schedule: Optional[Sequence[float]]
+        Sequence of `beta` values swept. Format must be compatible with
+        `numpy.array(beta_schedule, dtype=float)`. Values should be non-negative.
+    initial_states: Optional[Any]
+        One or more samples, each defining an initial state for all the problem
+        variables. Initial states are given one per read, but if fewer than additional
+        values are generated as specified by `initial_states_generator`. See
+        `~dimod.as_samples` for a description of 'samples-like.
+    randomize_order: bool
+        When `True`, each spin update selects a variable uniformly at random. This
+        method is ergodic, obeys detailed balance and preserves symmetries of the model.
+        When `False`, updates proceed sequentially through the labeled variables on each
+        sweep so that all variables are updated once per sweep. This method:
+        * can be non-ergodic in special cases when used with
+        `proposal_acceptance_critera=='Metropolis'`.
+        * can introduce a dynamical bias as a function of variable order.
+        * has faster per spin update than the True method.
+    proposal_acceptance_criteria: Literal['Gibbs', 'Metropolis']
+        When 'Gibbs', each spin flip proposal is accepted according to the Gibbs
+        criteria. When 'Metropolis', each spin flip proposal is accepted according to
+        the Metropolis-Hastings criteria.
+    """
+
+    num_sweeps_per_beta: int = 1
+    seed: Optional[int] = None
+    beta_schedule: Optional[Sequence[float]] = None
+    initial_states: Optional[Any] = None
+    randomize_order: bool = False
+    proposal_acceptance_criteria: Literal["Gibbs", "Metropolis"] = "Metropolis"

luna_sdk/schemas/solver_parameters/dwave/tabu_search.py

@@ -0,0 +1,72 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+
+class TabuSearchParameters(BaseModel):
+    """
+    Tabu Search is a heuristic optimization method that works with the help of a tabu list.
+    Initially, random states are chosen in the solution landscape.
+    Afterwards, an iterative search for energetically better states in the neighborhood is started from these states.
+    According to a tabu strategy, states are added to the tabu list that are not allowed to be selected as successor states for a tabu duration.
+    The tabu search ends as soon as there are no better successor states in the neighborhood.
+    The resulting state is therefore the solution to the problem.
+
+    Parameters
+    ----------
+    num_reads: Optional[int]
+        Number of reads. Each read is generated by one run of the tabu algorithm. If
+        `num_reads` is not explicitly given, it is selected to match the number of
+        initial states given. If initial states are not provided, only one read is
+        performed.
+    tenure: Optional[int]
+        Tabu tenure, which is the length of the tabu list, or number of recently
+        explored solutions kept in memory. Default is a quarter of the number of problem
+        variables up to a maximum value of 20.
+    timeout: float
+        Maximum running time per read in milliseconds.
+    initial_states_generator: Literal['none', 'tile', 'random']
+        Defines the expansion of `initial_states` if fewer than `num_reads` are
+        specified:
+        'none': if the number of initial states specified is smaller than `num_reads`,
+        raises ``ValueError``.
+        'tile': reuses the specified initial states if fewer than `num_reads` or
+        truncates if greater.
+        'random': expands the specified initial states with randomly generated states if
+        fewer than `num_reads` or truncates if greater.
+    initial_states: Optional[Any]
+        One or more samples, each defining an initial state for all the problem
+        variables. Initial states are given one per read, but if fewer than `num_reads`
+        initial states are defined, additional values are generated as specified by
+        `initial_states_generator`.
+    seed: Optional[int]
+        32-bit unsigned integer seed to use for the PRNG. If the `timeout` parameter is
+        not None, results from the same seed may not be identical between runs due to
+        finite clock resolution.
+    num_restarts: int
+        Maximum number of tabu search restarts per read. Setting this value to zero
+        results in a simple tabu search.
+    energy_threshold: Optional[float]
+        Terminate when an energy lower than or equal to `energy_threshold` is found.
+    coefficient_z_first: Optional[int]
+        `max(bqm.num_variables*coefficient_z_first, lower_bound_z)` bounds the number of
+        variable updates considered in the first simple tabu search (STS). Variable
+        updates arising from the STS greedy-descent subroutine, invoked upon discovery
+        of new global optima, are excluded from the count. The coefficient defaults to
+        10_000 for small problems (up to 500 variables) and 25_000 for larger problems.
+    coefficient_z_restart: Optional[int]
+        Controls the number of variable updates on restarted simple tabu search stages,
+        matching the description for `coefficient_z_first`. The coefficient defaults to
+        `coefficient_z_first/4`
+    lower_bound_z: Optional[int]
+        Sets a minimum number of variable updates on all simple tabu searches, see
+        `coefficient_z_first`. The bound defaults to 500_000.
+    """
+
+    initial_states: Optional[Any] = None
+    seed: Optional[int] = None
+    num_restarts: int = 1_000_000
+    energy_threshold: Optional[float] = None
+    coefficient_z_first: Optional[int] = None
+    coefficient_z_restart: Optional[int] = None
+    lower_bound_z: Optional[int] = None

luna_sdk/schemas/solver_parameters/fujitsu/__init__.py

@@ -0,0 +1,20 @@
+"""Solver Parameters"""
+
+from luna_sdk.schemas.solver_parameters.fujitsu.digital_annealer_cpu import (
+    DigitalAnnealerCPUParameters,
+)
+from luna_sdk.schemas.solver_parameters.fujitsu.digital_annealer_v2 import (
+    DigitalAnnealerV2Parameters,
+)
+from luna_sdk.schemas.solver_parameters.fujitsu.digital_annealer_v3 import (
+    DigitalAnnealerV3Parameters,
+)
+from luna_sdk.schemas.solver_parameters.fujitsu.partial_config import (
+    BitArrayShape,
+    Category,
+    OneHot,
+    OneHotGroup,
+    PartialConfig,
+    Variable,
+    VarShapeSet,
+)