# 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.

#### High-Throughput (“Bulk”) Hybrid Solvers¶

In addition to the generally available (GA) versions of Leap’s hybrid solvers, some accounts may have access to versions of these solvers optimized for high throughput. These (sometimes called “bulk solvers”) can performantly process the submission of multiple problem in rapid succession, and may accept problems of larger size than their GA counterparts.

However, to handle high throughput, these solvers first instantiate the needed compute resources, which adds latency. The cost of this latency tends to be small compared to the overall solution time for multiple, large problems.

If your account has access to both GA and high-throughput (“bulk”) hybrid solvers, ensure correct solver selection for your problems:

Use GA solvers for single submissions of problems that do not exceed size limitations.

Use high-throughput solvers when submitting multiple problems in a fast sequence or problems that exceed size limitations for the GA solvers.

The following example demonstrates the selection of a high-throughput CQM solver for use by an application that submits a sequence of problems and a standard BQM solver the user is experimenting with interactively.

```
>>> from dwave.system import LeapHybridBQMSampler, LeapHybridCQMSampler
...
>>> # Select a standard BQM solver
>>> bqm_solver_selection = LeapHybridBQMSampler.default_solver
>>> bqm_solver_selection.update(name__regex=".*(?<!bulk)$")
>>> sampler_bqm = LeapHybridBQMSampler(solver=bqm_solver_selection)
...
>>> # Select a high-throughput CQM solver
>>> cqm_solver_selection = LeapHybridCQMSampler.default_solver
>>> cqm_solver_selection.update(name__regex=".*bulk$")
>>> sampler_cqm = LeapHybridCQMSampler(solver=cqm_solver_selection)
```

For this user’s account selected2 solvers might be the following ones:

```
>>> sampler_cqm.solver.name
'hybrid_constrained_quadratic_model_version1_bulk'
>>> sampler_bqm.solver.name
'hybrid_binary_quadratic_model_version2'
```

- 2
Solvers have default selection criteria; for example, hybrid BQM solvers might be required to support the BQM problem type and prioritize the latest available version. The code above adds a requirement to find or not find a match to “bulk” at the end of the solver’s name. For the user’s account of this example, the updated selection criteria might look like this:

>>> bqm_solver_selection {'supported_problem_types__contains': 'bqm', 'order_by': '-properties.version', 'name__regex': '.*(?<!bulk)$'}

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 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 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.