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

Leap provides quantum-classical Hybrid Solvers and QPU Solvers 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 steepest descent 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 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 currently makes available the Advantage quantum computer.

In 2022, a small, experimental prototype of D-Wave’s next-generation QPU, Advantage2, was put online in Leap for study.