Quantum Annealing

Quantum Annealing

  • Short Name: QA
  • Algorithm Type: Quantum
  • Category: Quantum
  • Native Input Format: BQM
Quantum Annealing uses a minor embedding to map problems onto a specified D-Wave sampler. The sampler solves the problem with the specified sampler method. With each call of the sampling method, the minor embedding is recalculated.

Usage via LunaSolve

# Example of using QA using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="QA",
    provider="dwave",
    solver_parameters={
        "embedding": {
            "chain_strength": None,
            "chain_break_fraction": True,
            "embedding_parameters": {
                "max_no_improvement": 10,
                "random_seed": None,
                "timeout": 1000,
                "max_beta": None,
                "tries": 10,
                "inner_rounds": None,
                "chainlength_patience": 10,
                "max_fill": None,
                "threads": 1,
                "return_overlap": False,
                "skip_initialization": False,
                "initial_chains": (),
                "fixed_chains": (),
                "restrict_chains": (),
                "suspend_chains": (),
            },
        },
        "sampling_params": {
            "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,
        },
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding QA using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "QA": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Quantum Annealing available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Leap Hybrid BQM

  • Short Name: LBQM
  • Algorithm Type: Hybrid
  • Category: Hybrid-External
  • Native Input Format: BQM
Leap’s quantum-classical hybrid solvers are intended to solve arbitrary application problems formulated as quadratic models. This solver accepts arbitrarily structured, unconstrained problems formulated as BQMs, with any constraints typically represented through penalty models.

Usage via LunaSolve

# Example of using LBQM using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="LBQM",
    provider="dwave",
    solver_parameters={
        "time_limit": None,
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding LBQM using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "LBQM": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Leap Hybrid BQM available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Leap Hybrid CQM

  • Short Name: LCQM
  • Algorithm Type: Hybrid
  • Category: Hybrid-External
  • Native Input Format: CQM
Leap’s quantum-classical hybrid solvers are intended to solve arbitrary application problems formulated as quadratic models. This solver accepts arbitrarily structured problems formulated as CQMs, with any constraints represented natively.

Usage via LunaSolve

# Example of using LCQM using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="LCQM",
    provider="dwave",
    solver_parameters={
        "time_limit": None,
        "spin_variables": None,
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding LCQM using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "LCQM": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Leap Hybrid CQM available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Repeated Reverse Quantum Annealing

This solver is only available for commercial and academic licenses.
  • Short Name: RRQA
  • Algorithm Type: Hybrid
  • Category: Hybrid-Internal
  • Native Input Format: BQM
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)

Usage via LunaSolve

# Example of using RRQA using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="RRQA",
    provider="dwave",
    solver_parameters={
        "sampling_params": {
            "anneal_offsets": None,
            "annealing_time": None,
            "auto_scale": None,
            "flux_biases": None,
            "flux_drift_compensation": True,
            "h_gain_schedule": None,
            "max_answers": None,
            "programming_thermalization": None,
            "readout_thermalization": None,
            "reduce_intersample_correlation": False,
        },
        "initial_states": None,
        "n_initial_states": 1,
        "samples_per_state": 1,
        "beta_schedule": [0.5, 3],
        "timeout": 300,
        "max_iter": 10,
        "target": None,
        "check_trivial": True,
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding RRQA using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "RRQA": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Repeated Reverse Quantum Annealing available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Population Annealing QPU

This solver is only available for commercial and academic licenses.
  • Short Name: PAQ
  • Algorithm Type: Hybrid
  • Category: Hybrid-Internal
  • Native Input Format: BQM
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.

Usage via LunaSolve

# Example of using PAQ using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="PAQ",
    provider="dwave",
    solver_parameters={
        "decomposer": {
            "size": 10,
            "min_gain": None,
            "rolling": True,
            "rolling_history": 1.0,
            "silent_rewind": True,
            "traversal": "energy",
        },
        "qpu": {
            "num_reads": 100,
            "num_retries": 0,
            "sampling_params": {
                "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,
            },
            "auto_embedding_params": {
                "embedding_parameters": {
                    "max_no_improvement": 10,
                    "random_seed": None,
                    "timeout": 1000,
                    "max_beta": None,
                    "tries": 10,
                    "inner_rounds": None,
                    "chainlength_patience": 10,
                    "max_fill": None,
                    "threads": 1,
                    "return_overlap": False,
                    "skip_initialization": False,
                    "initial_chains": (),
                    "fixed_chains": (),
                    "restrict_chains": (),
                    "suspend_chains": (),
                },
            },
        },
        "fixed_temperature_sampler": {
            "num_sweeps": 10000,
            "num_reads": None,
        },
        "max_iter": 20,
        "max_time": 2,
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding PAQ using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "PAQ": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Population Annealing QPU available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Parallel Tempering QPU

This solver is only available for commercial and academic licenses.
  • Short Name: PTQ
  • Algorithm Type: Hybrid
  • Category: Hybrid-Internal
  • Native Input Format: BQM
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.

Usage via LunaSolve

# Example of using PTQ using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="PTQ",
    provider="dwave",
    solver_parameters={
        "n_replicas": 4,
        "decomposer": {
            "size": 10,
            "min_gain": None,
            "rolling": True,
            "rolling_history": 1.0,
            "silent_rewind": True,
            "traversal": "energy",
        },
        "qpu": {
            "num_reads": 100,
            "num_retries": 0,
            "sampling_params": {
                "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,
            },
            "auto_embedding_params": {
                "embedding_parameters": {
                    "max_no_improvement": 10,
                    "random_seed": None,
                    "timeout": 1000,
                    "max_beta": None,
                    "tries": 10,
                    "inner_rounds": None,
                    "chainlength_patience": 10,
                    "max_fill": None,
                    "threads": 1,
                    "return_overlap": False,
                    "skip_initialization": False,
                    "initial_chains": (),
                    "fixed_chains": (),
                    "restrict_chains": (),
                    "suspend_chains": (),
                },
            },
        },
        "fixed_temperature_sampler": {
            "num_sweeps": 10000,
            "num_reads": None,
        },
        "cpu_count_multiplier": 5,
        "loop": {
            "max_iter": 100,
            "max_time": 5,
            "convergence": 3,
            "target": None,
            "rtol": 1e-05,
            "atol": 1e-08,
        },
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding PTQ using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "PTQ": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Parallel Tempering QPU available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

QBSolv Like QPU

This solver is only available for commercial and academic licenses.
  • Short Name: QLQ
  • Algorithm Type: Hybrid
  • Category: Hybrid-Internal
  • Native Input Format: BQM
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 as a sampler for the subproblems to achieve a QBSolv like behaviour.

Usage via LunaSolve

# Example of using QLQ using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="QLQ",
    provider="dwave",
    solver_parameters={
        "qbsolv_like": {
            "decomposer_size": 50,
            "rolling": True,
            "rolling_history": 0.15,
            "cpu_count_multiplier": 1,
            "loop": {
                "max_iter": 100,
                "max_time": 5,
                "convergence": 3,
                "target": None,
                "rtol": 1e-05,
                "atol": 1e-08,
            },
        },
        "qpu": {
            "num_reads": 100,
            "num_retries": 0,
            "sampling_params": {
                "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,
            },
            "auto_embedding_params": {
                "embedding_parameters": {
                    "max_no_improvement": 10,
                    "random_seed": None,
                    "timeout": 1000,
                    "max_beta": None,
                    "tries": 10,
                    "inner_rounds": None,
                    "chainlength_patience": 10,
                    "max_fill": None,
                    "threads": 1,
                    "return_overlap": False,
                    "skip_initialization": False,
                    "initial_chains": (),
                    "fixed_chains": (),
                    "restrict_chains": (),
                    "suspend_chains": (),
                },
            },
        },
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding QLQ using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "QLQ": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

QBSolv Like QPU available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Kerberos

  • Short Name: K
  • Algorithm Type: Hybrid
  • Category: Hybrid-Internal
  • Native Input Format: BQM
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.

Usage via LunaSolve

# Example of using K using the D-Wave backend in LunaSolve
solution = ls.solution.create(
    optimization_id=optimization.id,
    solver_name="K",
    provider="dwave",
    solver_parameters={
        "tabu": {
            "num_reads": None,
            "tenure": None,
            "timeout": 20,
            "initial_states_generator": "random",
            "max_time": None,
        },
        "simulated_annealing": {
            "num_reads": None,
            "num_sweeps": 1000,
            "beta_range": None,
            "beta_schedule_type": "geometric",
            "initial_states_generator": "random",
        },
        "decomposer": {
            "size": 10,
            "min_gain": None,
            "rolling": True,
            "rolling_history": 1.0,
            "silent_rewind": True,
            "traversal": "energy",
        },
        "qpu": {
            "num_reads": 100,
            "num_retries": 0,
            "sampling_params": {
                "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,
            },
            "auto_embedding_params": {
                "embedding_parameters": {
                    "max_no_improvement": 10,
                    "random_seed": None,
                    "timeout": 1000,
                    "max_beta": None,
                    "tries": 10,
                    "inner_rounds": None,
                    "chainlength_patience": 10,
                    "max_fill": None,
                    "threads": 1,
                    "return_overlap": False,
                    "skip_initialization": False,
                    "initial_chains": (),
                    "fixed_chains": (),
                    "restrict_chains": (),
                    "suspend_chains": (),
                },
            },
        },
        "loop": {
            "max_iter": 100,
            "max_time": 5,
            "convergence": 3,
            "target": None,
            "rtol": 1e-05,
            "atol": 1e-08,
        },
        "cpu_count_multiplier": 1,
    },
    qpu_tokens=TokenProvider(
        dwave=QpuToken(
            source="inline",
            token="<dwave token>",
        ),
    ),
)

Usage via LunaBench

# Example of adding K using the D-Wave backend as an algorithm to LunaBench
algorithms = {
    "K": {
        "location": "cloud",
        "provider": "dwave",
        # Provide your token (see user guide on QPU tokens for more details)
        "qpu_tokens": {
            "dwave": {
                "source": "inline",
                "token": "<dwave token>",
            },
        },
    },
}

Backends

This algorithm can be run on the following backends:

D-Wave

Kerberos available on D-Wave
D-Wave Systems, based in Burnaby, Canada, is renowned for its quantum annealing technology, specifically designed for solving optimization problems. Unlike traditional gate-based quantum computers, D-Wave’s annealers are optimized to find the lowest-energy solutions to complex problems by leveraging quantum tunneling. Their latest quantum systems offer thousands of qubits and are used extensively in applications like logistics, machine learning, and material science. D-Wave’s focus on quantum annealing sets it apart as a leader in delivering commercial quantum solutions to real-world challenges.

Read more about D-Wave Systems here.

Was this page helpful?