Introduction¶

SAPI Solvers—compute resources D-Wave makes available through SAPI that you can submit problems to—can be queried for their properties, which characterize behaviors and supported features; accept certain parameters that define the problem to be solved; and accept other parameters that control how the problem is run.

For example, Advantage™ quantum computers have a num_reads_range property that advertises the supported range for the number of requested anneals on a problem submitted to such a solver:

>>> from dwave.system import DWaveSampler
>>> DWaveSampler().properties["num_reads_range"]
[1, 10000]

Similarly, a Leap hybrid solver might accept a bqm and label as its problem parameters and time_limit as a controlling parameter, where the supported values of the latter are specified by this solver’s minimum_time_limit property.

>>> from dwave.system import LeapHybridDQMSampler
>>> dqm = dimod.DiscreteQuadraticModel.from_file("my_dqm_problem")   
>>> LeapHybridDQMSampler().sample_dqm(dqm, time_limit=10)       

About This Document¶

This document describes the available SAPI Solvers and the supported

SAPI Solvers¶

D-Wave provides quantum-classical Hybrid Solvers, QPU Solvers, and QPU-like solvers (VFYC Solvers and emulators) that are available through SAPI.

Note

Not all accounts have access to all these solvers. You can see the solvers your account can access on the Leap dashboard for your account or by using the dwave CLI (e.g., dwave solvers -la).

Additionally, Ocean software provides classical solvers such as dwave-greedy that you can run locally. Those are not described in this document. See the Ocean documentation for information on parameters of such solvers.

Hybrid Solvers¶

Leap’s quantum-classical hybrid solvers are intended to solve arbitrary application problems formulated as quadratic models1.

1: Problems submitted directly to quantum computers are in the binary quadratic model (BQM) format, unconstrained with binary-valued variables and structured for the topology of the quantum processing unit (QPU). Hybrid solvers may accept arbitrarily structured quadratic models (QM), constrained or unconstrained, with real, integer, and binary variables.

These solvers, which implement state-of-the-art classical algorithms together with intelligent allocation of the quantum computer to parts of the problem where it benefits most, are designed to accommodate even very large problems. Leap’s hybrid solvers enable you to benefit from D-Wave’s deep investment in researching, developing, optimizing, and maintaining hybrid algorithms.

These solvers have the following characteristics:

There is no fixed problem structure. In particular, these solvers do not have properties num_qubits, qubits, and couplers.

Solvers may return one solution or more, depending on the solver, the problem, and the time allowed for solution. Returned solutions are not guaranteed to be optimal.

Solver properties and parameters are entirely disjoint from those of QPU and QPU-like solvers.
Maximum problem size and solution times differ between solvers and might change with subsequent versions of the solver: always check your selected solver’s relevant properties. For example, the solver selected below has limits on maximum_number_of_biases and maximum_number_of_variables that restrict problem size, and requirements on minimum_time_limit and maximum_time_limit_hrs that restrict solution time.
>>> sampler = LeapHybridDQMSampler()                         
>>> sampler.properties.keys()                                
dict_keys(['minimum_time_limit',
           'maximum_time_limit_hrs',
           'maximum_number_of_variables',
           'maximum_number_of_biases',
           'parameters',
           'supported_problem_types',
           'category',
           'version',
           'quota_conversion_rate'])
 >>> sampler.properties["maximum_time_limit_hrs"]           
 24.0

Generally Available Hybrid Solvers¶

The generally available hybrid solvers depend on your Leap™ account. Check your Leap dashboard to see which hybrid solvers are available to you.

Generally-available hybrid solvers currently supported in Leap include:

Hybrid BQM solver (e.g., hybrid_binary_quadratic_model_version2)

Binary quadratic models (BQM) typically represent problems of decisions that could either be true (or yes) or false (no); for example, should an antenna transmit, or did a network node fail?

These solvers accept arbitrarily structured, unconstrained problems formulated as BQMs, with any constraints typically represented through penalty models.
Hybrid CQM solver (e.g., hybrid_constrained_quadratic_model_version1)

Constrained quadratic models (CQM) typically represent problems that might include real, integer and/or binary variables and one or more constraints.

These solvers accept arbitrarily structured problems formulated as CQMs, with any constraints represented natively.
Hybrid DQM solver (e.g., hybrid_discrete_quadratic_model_version1)

Discrete quadratic models (DQM) typically represent problems with several distinct options; for example, which shift should employee X work, or should the state on a map be colored red, blue, green, or yellow?

These solvers accept arbitrarily structured, unconstrained problems formulated as DQMs, with any constraints typically represented through penalty models.

Contact D-Wave at sales@dwavesys.com if your application requires scale or performance that exceeds the currently advertised capabilities of Leap’s generally available hybrid solvers.

QPU Solvers¶

The Getting Started with D-Wave Solvers guide is an introduction to QPU solvers. For a more advanced, technical description of QPUs, see the QPU Solver Datasheet guide.

Generally Available QPU Solvers¶

D-Wave makes available two QPU solvers: the Advantage and the D-Wave 2000Q.

VFYC Solvers¶

A virtual full-yield chip (VFYC) solver emulates a fully connected D-Wave 2000Q QPU working graph based on an idealized abstraction of the system. Through this solver, variables corresponding to a Chimera-structured graph that are not representable on a specific working graph are determined via hybrid use of the QPU and the integrated postprocessing system, which effectively fills in any missing qubits and couplers that may affect the QPU. For more information on the VFYC solver and how it is integrated with the postprocessing system, see the QPU Solver Datasheet guide.

Generally Available VFYC Solvers¶

VFYC solvers for D-Wave 2000Q systems are available server-side for some accounts. Check your Leap dashboard to see if such solvers are available to you.

Emulators¶

Software solvers are useful for prototyping optimization or sampling algorithms that make multiple calls to the hardware.

Optimizing emulator solvers solve the same type of optimization problems as the QPU, but using a classical software algorithm.

This class of solvers is entirely deterministic, so the semantics of some parameters are different from the QPU. The number of solutions returned is always the lesser of num_reads and max_answers. The solutions returned are the lowest-energy states, sorted in increasing-energy order.
Sampling emulator solvers mimic the probabilistic nature of the QPU to draw samples that can be used to train a probabilistic model.

This class of solvers mimic the probabilistic nature of the QPU, drawing samples from a Boltzmann distribution; that is, state s is sampled with probability proportional to:

\[\exp(-\beta E(s))\]

where \(\beta\) is some parameter and \(E(s)\) is the energy of state \(s\).

Generally Available Emulators¶

These solvers have names ending with the following strings:

-sw_optimize
-sw_sample

Emulator solvers are not available for all accounts. Check your Leap dashboard to see if such solvers are available to you.