Skip to content

Kerberos

Kerberos divides the problem into subproblems and solves them using Tabu Search, Simulated Annealing and QPU Subproblem Sampling. These algorithms are executed in parallel and afterwards the best solutions are combined. This procedure is applied iteratively until the best solution is found or a termination criterion is met.

Compatible Backends

Backend Default
DWaveQpu

Initialization

Python
from luna_quantum.solve.parameters.algorithms.base_params.decomposer import Decomposer
from luna_quantum.solve.parameters.algorithms.base_params.quantum_annealing_params import QuantumAnnealingParams
from luna_quantum.solve.parameters.algorithms.base_params.simulated_annealing_params import SimulatedAnnealingBaseParams
from luna_quantum.solve.parameters.algorithms.base_params.tabu_kerberos_params import TabuKerberosParams
from luna_quantum.solve.parameters.algorithms.quantum_annealing.kerberos import Kerberos

algorithm = Kerberos(
    backend=None,
    num_reads=100,
    num_retries=0,
    max_iter=100,
    max_time=5,
    convergence=3,
    target=None,
    rtol=1e-05,
    atol=1e-08,
    simulated_annealing_params=SimulatedAnnealingBaseParams(
        num_reads=None,
        num_sweeps=1000,
        beta_range=None,
        beta_schedule_type='geometric',
        initial_states_generator='random'
    ),
    quantum_annealing_params=QuantumAnnealingParams(
        anneal_offsets=None,
        anneal_schedule=None,
        annealing_time=None,
        auto_scale=None,
        fast_anneal=False,
        flux_biases=None,
        flux_drift_compensation=True,
        h_gain_schedule=None,
        initial_state=None,
        max_answers=None,
        num_reads=1,
        programming_thermalization=None,
        readout_thermalization=None,
        reduce_intersample_correlation=False,
        reinitialize_state=None
    ),
    tabu_kerberos_params=TabuKerberosParams(
        num_reads=None,
        tenure=None,
        timeout=100,
        initial_states_generator='random',
        max_time=None
    ),
    decomposer=Decomposer(
        size=10,
        min_gain=None,
        rolling=True,
        rolling_history=1.0,
        silent_rewind=True,
        traversal='energy'
    )
)

Usage

Python
from luna_quantum.algorithms import Kerberos

algorithm = Kerberos()
solve_job = algorithm.run(model, name="my-solve-job")