General QPU Solver Properties

This section describes the properties in common to all QPU solvers and shows how you can query their values through SAPI; for properties specific to the hardware of a particular QPU, see the Per-QPU Solver Properties and Schedules section.

For the parameters you can configure, see the QPU Solver Parameters section.

anneal_offset_ranges

Array of ranges of valid anneal offset values, in normalized offset units, for each qubit. The negative values represent the largest number of normalized offset units by which a qubit’s anneal path may be delayed. The positive values represent the largest number of normalized offset units by which a qubit’s anneal path may be advanced.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["anneal_offset_ranges"][50:55]
[[-0.6437569799443247, 0.5093937328282595],
 [-0.6409899716199288, 0.5697835920492209],
 [-0.6468663649068287, 0.5211452841036136],
 [-0.6435316809914349, 0.5011584701861175],
 [-0.6500326191157569, 0.5392206819650301]]

anneal_offset_step

Quantization step size of anneal offset values in normalized units.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["anneal_offset_step"]
-0.00017565852000668507

anneal_offset_step_phi0

Quantization step size in physical units (annealing flux-bias units): \(\Phi_0\).

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["anneal_offset_step_phi0"]
1.486239425109832e-05

annealing_time_range

Range of time, in microseconds with a resolution of 0.01 \(\mu s\), possible for one anneal (read). The lower limit in this range is the fastest quench possible for this solver using the standard-anneal protocol. See also the fast_anneal_time_range.

Default annealing time is specified by the default_annealing_time property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["annealing_time_range"]
[0.5, 2000.0]

category

Type of solver.

• qpu: Quantum computers such as the Advantage2 system.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["category"]
'qpu'

chip_id

Name of the solver.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["chip_id"]
'Advantage_system1.1'

couplers

Indices of the couplers in the working graph. A coupler contains two elements [q1, q2], where both q1 and q2 appear in the list of working qubits, in the range [0, num_qubits - 1] and in ascending order (i.e., q1 < q2). These are the couplers that can be programmed with nonzero \(J\) values.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["couplers"][:5]
[[30, 31], [31, 32], [32, 33], [33, 34], [34, 35]]

default_annealing_time

Default time, in microseconds with a resolution of 0.01 \(\mu s\), for one anneal (read). You can change the annealing time for a given problem by using the annealing_time or anneal_schedule parameters, but do not exceed the upper limit given by the annealing_time_range or fast_anneal_time_range property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["default_annealing_time"]
20.0

default_programming_thermalization

Default time, in microseconds with a resolution of 0.01 \(\mu s\), that the system waits after programming the QPU for it to return to base temperature. This value contributes to the total qpu_programming_time, which is returned by SAPI with the problem solutions.

You can change this value using the programming_thermalization parameter.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["default_programming_thermalization"]
1000.0

default_readout_thermalization

Default time, in microseconds with a resolution of 0.01 \(\mu s\), that the system waits after each state is read from the QPU for it to cool back to base temperature. This value contributes to the qpu_delay_time_per_sample field, which is returned by SAPI with the problem solutions.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["default_readout_thermalization"]
0.0

extended_j_range

Extended range of values possible for the coupling strengths (quadratic coefficients), \(J\), for this solver. Strong negative couplings may be necessary for some embeddings; however, such chains may require additional calibration through the flux_biases parameter to compensate for biases introduced by strong negative couplings. See also per_qubit_coupling_range and per_group_coupling_range.

The auto_scale parameter, which rescales \(h\) and \(J\) values in the problem to use as much of the range of \(h\) (h_range) and the range of \(J\) (extended_j_range) as possible, enables you to submit problems with values outside these ranges and have the system automatically scale them to fit.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["extended_j_range"]
[-2.0, 1.0]

fast_anneal_time_range

Range of time, in microseconds with a resolution of up to picoseconds,[1] possible for one anneal (read). The lower limit in this range is the fastest quench possible for this solver.

Default annealing time is specified by the default_annealing_time property.

[1]

The fast-anneal protocol supports a time granularity of about 0.05% of the anneal time. For annealing times of about 10 ns, the granularity is about 5 ps; for anneals of about 20 \(\mu s\), it is reduced to around 10 ns.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["fast_anneal_time_range"]
[0.005, 2000.0]

h_gain_schedule_range

Range of the time-dependent gain applied to qubit biases for this solver.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["h_gain_schedule_range"]
[-4.0, 4.0]

h_range

Range of values possible for the qubit biases (linear coefficients), \(h\), for this solver.

The auto_scale parameter, which rescales \(h\) and \(J\) values in the problem to use as much of the range of \(h\) (h_range) and the range of \(J\) (extended_j_range) as possible, enables you to submit problems with values outside these ranges and have the system automatically scale them to fit.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["h_range"]
[-4.0, 4.0]

j_range

Range of values possible for the coupling strengths (quadratic coefficients), \(J\), for this solver.

See also the extended_j_range solver property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["j_range"]
[-1.0, 1.0]

max_anneal_schedule_points

Maximum number of points permitted in a PWL waveform submitted to change the default anneal schedule.

For reverse annealing, the maximum number of points allowed is one more than the number given in the max_anneal_schedule_points property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["max_anneal_schedule_points"]
12

max_h_gain_schedule_points

Maximum number of points permitted in a PWL waveform submitted to set a time-dependent gain on linear coefficients (qubit biases, see the h parameter) in the Hamiltonian.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["max_h_gain_schedule_points"]
20

num_qubits

Total number of qubits, both working and nonworking,[2] in the QPU.

[2]

The qubits property provides the indices of qubits in the QPU’s working graph, which are the qubits you can use for problem solving.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["num_qubits"]
5760

num_reads_range

Range of values possible for the number of reads that you can request for a problem.

Example

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

parameters

List of the parameters supported for the solver.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["parameters"]["num_reads"]
'Number of states to read (answers to return), as a positive integer.'

per_group_coupling_range

Supported on Advantage2 QPUs only.

Coupling range permitted per group of qubits for this solver. The couplers of every qubit are divided into two similar sized groups to which apply limitations on the total of all coupling strengths.

Strong negative couplings may be necessary for some embeddings, and can be enabled by using the extended_j_range range of \(J\) values. However, total \(J\) values of the couplers for a group of qubits must not exceed the range specified by this property. Also, chains may require additional calibration through the flux_biases parameter to compensate for biases introduced by strong negative couplings.

The auto_scale parameter scales a problem’s \(J\) values such that the total \(J\) values of the couplers for a group of qubits is within the range specified by this property.

For more information, see the Ocean software’s coupling_groups() function.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler(solver={"topology__type": "zephyr"})
>>> sampler.properties["per_group_coupling_range"]
[-13.000 10.000]

per_qubit_coupling_range

Supported on Advantage QPUs only.

Coupling range permitted per qubit for this solver.

Strong negative couplings may be necessary for some embeddings, and can be enabled by using the extended_j_range range of \(J\) values. However, the total \(J\) values of the couplers for a qubit must not exceed the range specified by this property. Also, chains may require additional calibration through the flux_biases parameter to compensate for biases introduced by strong negative couplings.

The auto_scale parameter scales a problem’s \(J\) values such that the total \(J\) values of the couplers for a qubit is within the range specified by this property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler(solver={"topology__type": "pegasus"})
>>> sampler.properties["per_qubit_coupling_range"]
[-18.0, 15.0]

problem_run_duration_range

Range of time, in microseconds with a resolution of 0.01 \(\mu s\), that a submitted problem is allowed to run.

For details about how the run-duration limit is calculated, see QMI Runtime Limit.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["problem_run_duration_range"]
[0.0, 1000000.0]

problem_timing_data

Key-value pairs that contain sample timing data and specify the version 1.0.x problem-timing model used to estimate problem runtimes for a QPU solver. For details about using the timing data to estimate the QPU access times for problem submissions, see the Estimating Access Time section.

The key-value pairs are the following:

• decorrelation_max_nominal_anneal_time: Parameter, in microseconds, used in the calculation of inter-sample correlation time. For more information, see the reduce_intersample_correlation solver property.

• decorrelation_time_range: Range of inter-sample correlation time, in microseconds, to add to the per-sample delay time as specified in the qpu_delay_time_per_sample field. Scales linearly with the anneal time from 0 to the amount returned in the decorrelation_max_nominal_anneal_time field. For more details, see the reduce_intersample_correlation solver parameter.

• default_annealing_time: See the default_annealing_time solver property.

• default_programming_thermalization: See the default_programming_thermalization solver property.

• default_readout_thermalization: See the default_readout_thermalization solver property.

• qpu_delay_time_per_sample: Default for the per-sample delay time in microseconds.

• readout_time_model: The readout-time model used to generate the set of data points; these data points define a piecewise-linear curve of typical readout times as a function of the number of qubits in a representative set of problems embedded on a QPU. The data points are provided in the readout_time_model_parameters field. Supported values that specify the scale of the curve are:

  • pwl_log_log: The log scale is used for both the horizontal and vertical axes.

  • pwl_linear: The linear scale is used for both the horizontal and vertical axes.

• readout_time_model_parameters: A set of \(2N\) data points generated by the readout-time model specified in the readout_time_model field.

• reverse_annealing_with_reinit_delay_time_delta: Extra per-sample delay time, in microseconds, when reverse annealing is used and the reinitialize_state parameter is true.

• reverse_annealing_with_reinit_prog_time_delta: Extra programming time, in microseconds, when reverse annealing is used and the reinitialize_state solver parameter is true.

• reverse_annealing_without_reinit_delay_time_delta: Extra per-sample delay time, in microseconds, when reverse annealing is used and the reinitialize_state solver parameter is false.

• reverse_annealing_without_reinit_prog_time_delta: Extra programming time, in microseconds, when reverse annealing is used and the reinitialize_state solver parameter is false.

• typical_programming_time: Typical programming time in microseconds.

• version: Version of the problem-timing model.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["problem_timing_data"]
{'version': '1.0.0', 'typical_programming_time': 14072.88,
'reverse_annealing_with_reinit_prog_time_delta': 0.0,
'reverse_annealing_without_reinit_prog_time_delta': 5.55,
'default_programming_thermalization': 1000.0, 'default_annealing_time': 20.0,
'readout_time_model': 'pwl_log_log',
'readout_time_model_parameters': [0.0, 0.7699665876947938, 1.7242758696010096,
2.711975459489206, 3.1639057672764026, 3.750276915153992, 1.539131714800995,
1.8726623164229292, 2.125631787097315, 2.332672340068556, 2.371606651233025,
2.3716219271760215], 'qpu_delay_time_per_sample': 20.54,
'reverse_annealing_with_reinit_delay_time_delta': -4.5,
'reverse_annealing_without_reinit_delay_time_delta': -1.5,
'default_readout_thermalization': 0.0, 'decorrelation_max_nominal_anneal_time': 2000.0,
'decorrelation_time_range': [500.0, 10000.0]}

programming_thermalization_range

Range of time, in microseconds with a resolution of 0.01 \(\mu s\), possible for the system to wait after programming the QPU for it to cool back to base temperature. This value contributes to the total qpu_programming_time, which is returned by SAPI with the problem solutions.

You can change this value using the programming_thermalization parameter, but be aware that values lower than the default accelerate solving at the expense of solution quality.

Default value for a solver is given in the default_programming_thermalization property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["programming_thermalization_range"]
[0.0, 10000.0]

qubits

Indices of the qubits in the working graph.

In a D-Wave QPU, the set of qubits and couplers that are available for computation is known as the working graph. The working graph typically does not contain all the qubits and couplers that are fabricated and physically present in the QPU. For example, an Advantage QPU with its 5760 qubits (the num_qubits property), of which a maximum of 5640 are calibrated for problem solving (the programmable fabric, or largest component of the full Pegasus™ graph), might have a working graph of 5627 qubits (a yield of 99.7%) due to 13 qubits that were not brought into a consistent parametric regime in the calibration process. For such a system, the value of the qubits property is the sequence of integers between 30, the first of the 5640 fabric qubits, and 5729, the last of those 5640 qubits, minus indices of the 13 non-working qubits.[3]

[3]

You can see the qubit indexing scheme of such an Advantage QPU with Ocean software’s dwave_networkx.pegasus_graph() function, which enables you to generate Pegasus graphs.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["qubits"][:5]
[30, 31, 32, 33, 34]

quota_conversion_rate

Rate at which user or project quota is consumed for the solver as a ratio to QPU solver usage. Different solver types may consume quota at different rates.

Time is deducted from your quota according to:

\[\frac{num\_seconds}{quota\_conversion\_rate}\]

See the Solver Usage Charges section for more information.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["quota_conversion_rate"]
1

readout_thermalization_range

Range of time, in microseconds with a resolution of 0.01 \(\mu s\), possible for the system to wait after each state is read from the QPU for it to cool back to base temperature. This value contributes to the qpu_delay_time_per_sample field, which is returned by SAPI with the problem solutions.

Default readout thermalization time is specified in the default_readout_thermalization property.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["readout_thermalization_range"]
[0.0, 10000.0]

supported_problem_types

Indicates what problem types are supported for the solver.

QPU solvers support the following energy-minimization problem types:

• qubo: Quadratic unconstrained binary optimization (QUBO) problems; use \(0/1\)-valued variables.

• ising: Ising model problems; use \(-1/1\)-valued variables.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["supported_problem_types"]
['ising', 'qubo']

tags

May hold attributes about a solver that you can use to have a client program choose one solver over another.

Example

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["tags"]
[]

topology

Indicates the topology type (pegasus or zephyr) and shape of the QPU graph.

Example

The topology seen in this example is a P16 Pegasus graph. See the Topologies section for a description of QPU topologies.

>>> from dwave.system import DWaveSampler
...
>>> sampler = DWaveSampler()
>>> sampler.properties["topology"]
{'type': 'pegasus', 'shape': [16]}

x_get_fast_reverse_anneal_exp_feature_info

Returns information about supported parameters for fast reverse anneal.

Note

This property supports an advanced annealing feature used in experimental research on designated research QPUs. Not all accounts have access to such research quantum computers.

Also note that this is a parameter that functions as a property. For convenience, you can instead use the utility functions described in the dwave-experimental Utilities section.

Submit a placeholder problem with this parameter set to True to return the information, as a Python list with a dict for each of the QPU’s anneal lines, under the returned result’s x_get_fast_reverse_anneal_exp_feature_info field.

Example

This example prints the the supported (calibrated) nominal-pause-duration values and the range for the target normalized control bias \(c(s)\) for a QPU.

1. Using the get_parameters() function (recommended).

   >>> from dwave.experimental import fast_reverse_anneal as fra
   >>> from dwave.system import DWaveSampler
   ...
   >>> with DWaveSampler(solver="Advantage2_research1.4") as sampler:
   ...     param_info = fra.get_parameters(sampler)
   

   >>> print(param_info["x_nominal_pause_time"]["limits"])
   {'set': [0.0, 0.01, 0.02, 0.03, 0.04, 0.05]}
   >>> print(param_info["x_target_c"]["limits"])
   {'rang
   

2. Directly using the x_get_fast_reverse_anneal_exp_feature_info parameter.

   >>> from dwave.cloud.client import Client
   ...
   >>> with Client.from_config() as client:
   ...     solver = client.get_solver(name="Advantage2_research1.4")
   ...     computation = solver.sample_ising(
   ...         {next(iter(solver.nodes)): 0}, {}, x_get_fast_reverse_anneal_exp_feature_info=True)
           result = computation.result()
           exp_feature_info = result['x_get_fast_reverse_anneal_exp_feature_info']
   >>> print(exp_feature_info)
   ['fastReverseAnnealNominalPauseTimeValues', [0.0, 0.01, 0.02, 0.03, 0.04, 0.05], 'fastReverseAnnealTargetCRange', [0, 1]]
   

x_get_multicolor_annealing_exp_feature_info

Returns information about per-line anneal schedules, such as the subset of the QPU’s qubits indexed to each line, supported minimum time steps, and ranges of normalized control bias, \(c(s)\), etc.

Note

This property supports an advanced annealing feature used in experimental research on designated research QPUs. Not all accounts have access to such research quantum computers.

Also note that this is a parameter that functions as a property. For convenience, you can instead use the utility functions described in the dwave-experimental Utilities section.

Submit a placeholder problem with this parameter set to True to return the information, as a Python list with a dict for each of the QPU’s anneal lines, under the returned result’s x_get_multicolor_annealing_exp_feature_info field. (The length of the returned list is the number of anneal lines of the QPU.)

The returned information contains the following fields.

Table 23 x_get_multicolor_annealing_exp_feature_info Fields

Field Name	Type	Value
annealingLine	Integer	Index of the annealing line for which the other field values are defined. Values range between 0 to \(N - 1\), where \(N\) is the number of anneal lines for the QPU.
minAnnealingTimeStep	Float	Minimum supported time step, in microseconds, for the x_anneal_schedules parameter. Values specified with greater precision are rounded.
minPolarizingTimeStep	Float	Minimum supported time step, in microseconds, for the x_polarizing_schedules parameter. Values specified with greater precision are rounded.
holdOvershootFor	Float	Maximum supported duration, in microseconds, that you can specify a value exceeding the range of [minC, maxC] in the anneal schedules you set through the x_anneal_schedules parameter.
minCOvershoot	Float	Lowest supported value that you can specify for the normalized control bias, \(c(s)\), element of the x_anneal_schedules parameter. The duration in which \(c(s) <\) minC must not exceed the maximum supported time specified in the holdOvershootFor field. Values of \(c(s)\) lower than minC do not correspond to a greater transverse energy \(A(c)\) than \(c(s) =\) minC; by specifying such a value for a short time, you increase the generated waveform’s rate of change.
maxCOvershoot	Float	Highest supported value that you can specify for the normalized control bias, \(c(s)\), element of the x_anneal_schedules parameter. The duration in which \(c(s) >\) maxC must not exceed the maximum supported time specified in the holdOvershootFor field. Values of \(c(s)\) higher than maxC do not correspond to a lower transverse energy \(A(c)\) than \(c(s) =\) maxC; by specifying such a value for a short time, you increase the generated waveform’s rate of change.
maxC	Float	Highest value of the normalized control bias, \(c(s)\), element of the x_anneal_schedules parameter that is supported for durations that exceed holdOvershootFor. Corresponds to the highest possible barrier or lowest possible transverse (tunneling) energy \(A(c)\).
minC	Float	Lowest value of the normalized control bias, \(c(s)\), element of the x_anneal_schedules parameter that is supported for durations that exceed holdOvershootFor. Corresponds to the lowest possible barrier or highest possible transverse (tunneling) energy \(A(c)\).
scheduleDelayStep	Float	Maximum supported precision, in microseconds, of the x_schedule_delays parameter. Values specified with greater precision are rounded.
depolarizationAnneal ScheduleRequiredDelay	Float	Time, in microseconds, after the x_polarizing_schedules parameter changes the polarization value from \(\pm 1\) to \(0\) for the qubits of an anneal line, during which the x_anneal_schedules parameter must not set a new value of the normalized control bias, \(c(s)\), on that same line.
qubits	Array of integers	Indices of qubits controlled by the annealing line with the index indicated by the value of annealingLine.

Example

This example prints the first 5 qubits on annealing line 0.

1. Using the get_properties() function (recommended).

   >>> from dwave.experimental import multicolor_anneal as mca
   >>> exp_feature_info = mca.get_properties()
   >>> print(exp_feature_info[0]['qubits'][:5])
   [2, 5, 6, 9, 14]
   

2. Directly using the x_get_multicolor_annealing_exp_feature_info parameter.

   >>> from dwave.cloud.client import Client
   >>> with Client.from_config() as client:
   ...     solver = client.get_solver(name="Advantage2_research1.4")
   ...     computation = solver.sample_ising(
   ...         {next(iter(solver.nodes)): 0}, {}, x_get_multicolor_annealing_exp_feature_info=True)
   ...     result = computation.result()
   ...     exp_feature_info = result['x_get_multicolor_annealing_exp_feature_info']
   >>> print(exp_feature_info[0]['qubits'][:5])
   [2, 5, 6, 9, 14]