# 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 Assign Problem Labels 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 binary quadratic models (BQM) or discrete[1] quadratic models.

[1] | Where the standard problems submitted to quantum computers have binary valued variables (\(0,1\) for QUBO and \(+1,-1\) for Ising formulation), discrete quadratic model (DQM) solvers solve problems with variables that have more than two values; for example, variables that represent colors or DNA bases. |

These solvers, which implement state-of-the-art classical algorithms together with intelligent allocation of the quantum processing unit (QPU) to parts of the problem where it benefits most, are designed to accommodate even very large problems. Leap’s solvers can relieve you of the burden of any current and future development and optimization of hybrid algorithms that best solve your problem.

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`

)These solvers solve arbitrary application problems formulated as binary quadratic models (BQM).

Hybrid DQM solver (e.g.,

`hybrid_discrete_quadratic_model_version1`

)These solvers solve arbitrary application problems formulated as

**discrete**quadratic models (DQM).

### QPU Solvers¶

The *Getting Started with the D-Wave System* guide is an introduction to QPU solvers. For a more
advanced, technical description of QPUs, see the *Technical Description of the D-Wave Quantum Processing Unit* guide.

#### Generally Available QPU Solvers¶

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

### VFYC Solvers¶

A virtual full-yield chip (VFYC) solver emulates a fully connected
DW-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 *Postprocessing Methods on D-Wave Systems* 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.