QPU (Hardware) Solvers

These solvers submit problems to and return results from the D-Wave QPU. This section lists the properties of these solvers, lists the parameters they accept with a problem submission, and describes the answer format.

For a quick reference listing all parameters and how they interact with each other, see the QPU Solver Parameters Matrix section.

Properties

This section describes the properties of QPU solvers, in alphabetical order.

anneal_offset_step

Quantization step size of anneal offset values in normalized units.

anneal_offset_step_phi0

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

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.

Check these ranges before using the anneal_offsets parameter.

annealing_time_range

Range of time, in microseconds, possible for one anneal (read). The lower limit in this range is the fastest quench possible for this solver. When adjusting the anneal schedule, using either the annealing_time or anneal_schedule parameter, ensure that you do not exceed the limits in this range.

chip_id

Name of the solver.

couplers

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; for example, [[0, 4], [1, 4], [2, 4], ...]

default_annealing_time

Default time, in microseconds, 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 property.

default_programming_thermalization

Default time, in microseconds, 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, but be aware that values lower than the default accelerate solving at the expense of solution quality.

default_readout_thermalization

Default time, in microseconds, 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.

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.

Note

Flux-bias offsets and extended \(J\) ranges cannot be used with autoscaling or spin-reversal transforms.

h_range

Range of values possible for the qubit biases (linear coefficients), \(h\), for this solver. The auto_scale parameter enables you to submit problems with values outside these ranges and have the system automatically scale them to fit.

j_range

Range of values possible for the coupling strengths (quadratic coefficients), \(J\), for this solver. The auto_scale parameter enables you to submit problems with values outside these ranges and have the system automatically scale them to fit. See also extended_j_range.

max_anneal_schedule_points

Maximum number of points permitted in a PWL waveform submitted to change the default anneal schedule. Check this value before defining a new schedule with the anneal_schedule parameter.

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

num_reads_range

Range of values possible for the number of reads that you can request for a problem; for example, [1, 1000].

num_qubits

Total number of qubits, both working and nonworking, in the QPU; for example, 2048.

parameters

List of the parameters supported for the solver.

per_qubit_coupling_range

Coupling range permitted per qubit for this solver. Check this property when using an extended \(J\) range to strongly couple qubits in a chain. Strong negative couplings may be necessary for some embeddings; however, chains may require additional calibration through the flux_biases parameter to compensate for biases introduced by strong negative couplings. See also extended_j_range.

Note

Flux-bias offsets and extended \(J\) ranges cannot be used with autoscaling or spin-reversal transforms.

problem_run_duration_range

Range of time, in microseconds, that a problem can run.

The upper limit of this range is calculated according to the following formula:

\begin{equation} Duration = ((P_1 + P_2) * P_3) + P_4 \end{equation}

where \(P_1\), \(P_2\), \(P_3\), and \(P_4\) are the values specified for the annealing_time, readout_thermalization, num_reads (samples), and programming_thermalization parameters, respectively.

programming_thermalization_range

Range of time, in microseconds, 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. The default value for a solver is given in the default_programming_thermalization property.

qubits

Indices of the working qubits in the working graph. For example, [0, 1, 2, 3, ...]

Note

In a D-Wave QPU, the set of qubits and couplers that are available for computation is known as the working graph. The yield of a working graph is typically less than the total number of qubits and couplers that are fabricated and physically present in the QPU.

readout_thermalization_range

Range of time, in microseconds, 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.

Note

The readout_thermalization parameter is deprecated and will eventually be removed from the API. Plan code updates accordingly.

supported_problem_types

Indicates what problem types are supported for the solver. QPU and QPU-like 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.

vfyc

Flag indicating whether this solver is a VFYC solver.

Parameters

This section describes the parameters accepted by QPU solvers, in alphabetical order. See QPU Solver Parameters Matrix for a summary.

anneal_offsets

Provides offsets to annealing paths, per qubit.

Provide an array of anneal offset values, in normalized offset units, for all qubits, working or not. Use 0 for no offset. Negative values produce a negative offset (qubits are annealed after the standard annealing trajectory); positive values produce a positive offset (qubits are annealed before the standard trajectory). Before using this parameter, query the solver properties to see whether the anneal_offset_ranges property exists and, if so, to obtain the permitted offset values per qubit.

Format varies by SAPI client:

  • For C, this parameter is a pointer to the sapi_DoubleArray structure.
  • For MATLAB, supply the values as a vector.
  • For Python, supply the values as a list or a tuple.

anneal_schedule

Introduces variations to the global anneal schedule. For a reverse anneal, use the anneal_schedule parameter with the initial_state and reinitialize_state parameters.

An anneal schedule variation is defined by a series of pairs of floating-point numbers identifying points in the schedule at which to change slope. The first element in the pair is time \(t\) in microseconds; the second, normalized persistent current \(s\) in the range [0,1]. The resulting schedule is the piecewise-linear curve that connects the provided points.

The following rules apply to the set of anneal schedule points provided:

  • Time \(t\) must increase for all points in the schedule.

  • For forward annealing, the first point must be \((0, 0)\) and the anneal fraction \(s\) must increase monotonically.

  • For reverse annealing, the anneal fraction \(s\) must start and end at \(s = 1\).

  • In the final point, anneal fraction \(s\) must equal 1 and time \(t\) must not exceed the maximum value in the annealing_time_range property.

  • The number of points must be \(\geq 2\).
    The upper bound is system-dependent; check the max_anneal_schedule_points property. For reverse annealing, the maximum number of points allowed is one more than the number given by this property.
  • Additional rules that govern maximum slope vary by product; check the QPU properties document for your system.

The max_anneal_schedule_points property shows the maximum number of points permitted in an anneal schedule, and default_annealing_time shows the annealing time range for the solver.

Format varies by SAPI client:

  • For C, this parameter is a pointer to the sapi_AnnealSchedule structure.
  • For MATLAB, provide the schedule as a cell array of two-element matrices; for example: {[0.0, 0.0], [10.0, 0.3], [20.0, 1.0]}
  • For Python, provide the schedule as a list or tuple of two-element lists or tuples; for example: [[0.0, 0.0], [10.0, 0.3], [20.0, 1.0]]

Note

The annealing_time and anneal_schedule parameters are mutually exclusive.

annealing_time

Sets the duration (in microseconds) of quantum annealing time, per read. This value populates the qpu_anneal_time_per_sample field returned in the timing structure.

Must be a positive integer falling within the range given by the annealing_time_range solver property.

Note

The annealing_time and anneal_schedule parameters are mutually exclusive.

answer_mode

Indicates how to return answers from the solver; one of:

  • histogram (default)—Answers returned as a histogram sorted in order of increasing energies. Duplicate answers are merged and include a num_occurrences field.
  • raw—Answers returned individually in the order they were read from the solver. Use this setting if the returned time sequences are an important part of the solution data.

See also the Answer Format section below.

auto_scale

Indicates whether \(h\) and \(J\) values are rescaled:

  • true\(h\) and \(J\) values in the problem are rescaled to use as much of the range of \(h\) (h_range) and the range of \(J\) (j_range) as possible. When enabled, \(h\) and \(J\) values need not lie within the solver’s range of \(h\) and \(J\), but must still be finite.
  • false\(h\) and \(J\) values in the problem are used as is. If the \(h\) and \(J\) values are outside the range of the solver, problem submission fails.

Each QPU has an allowed range of values for the biases and strengths of qubits and couplers. Unless you explicitly disable auto-scaling, the D-Wave software adjusts the values defined in a problem to take the entire range available before sending it to the solver.

For problems that use the regular \(J\) range of a solver, this parameter is enabled by default. For problems that use the extended \(J\) range, it is disabled (and cannot be enabled while the extended range is in use). See also j_range and extended_j_range.

Note

Flux-bias offsets and extended \(J\) ranges cannot be used with autoscaling or spin-reversal transforms.

beta

Provides a value for the Boltzmann distribution parameter. Used when sampling postprocessing is enabled.

Note

As in statistical mechanics, \(\beta\) represents inverse temperature: \(1/(k_B T)\), where \(T\) is the thermodynamic temperature in kelvin and \(k_B\) is Boltzmann’s constant. In the D-Wave software, postprocessing refines the returned solutions to target a Boltzmann distribution characterized by \(\beta\), which is represented by a floating point number without units. When choosing a value for \(\beta\), be aware that lower values result in samples less constrained to the lowest energy states. For more information on \(\beta\) and how it is used in the sampling postprocessing algorithm, see Postprocessing Methods on D-Wave Systems.

chains

Defines which qubits represent the same logical variable. Used only when postprocessing is enabled. Ensures that all qubits in the same chain have the same value within each sample.

Provide the indices of the qubits that are in a chain. Qubits in a chain must be connected, and no qubit may appear more than once. Format varies by SAPI client:

  • For C and Python, provide the qubit indices as a list of lists. The inner lists are the indices of the qubits in the same chain; for example, [4, 12, 20, 28, 36, 44]. An example with two parallel horizontal 4-qubit chains is [[4, 12, 20, 28], [5, 13, 21, 29]].
  • For MATLAB, provide the qubit indices as a cell array.

flux_biases

List of flux-bias offset values with which to calibrate a chain. Often required when using the extended \(J\) range to create a strongly coupled chain for certain embeddings. See also the extended_j_range and per_qubit_coupling_range properties.

Provide an array of flux-bias offset values, in normalized offset units[1], for all qubits, working or not. Use 0 for no offset. Before using this parameter, query the solver properties to determine whether extended_J_range and per_qubit_coupling_range properties exist. Format varies by SAPI client:

  • For C, this parameter is a pointer to the sapi_DoubleArray structure.
  • For MATLAB, supply the values as a vector.
  • For Python, supply the values as a list or a tuple.

Note

Flux-bias offsets and extended \(J\) ranges cannot be used with autoscaling or spin-reversal transforms.

[1]Flux-biases applied to the qubit body are in units of \(\Phi_0\).

flux_drift_compensation

Boolean flag indicating whether the D-Wave system compensates for flux drift. The procedure it follows to do so is described in detail in Appendix A of Technical Description of the D-Wave Quantum Processing Unit.

  • flux_drift_compensation=true (default)—Compensate for flux drift.
  • flux_drift_compensation=false—Do not compensate for flux drift. If you disable this parameter, you may want to apply flux-bias offsets manually; see flux_biases.

h

For Ising problems, the \(h\) values are the linear coefficients (biases) applied to the qubits in a problem.

Because the quantum annealing process[2] minimizes the energy function of the Hamiltonian, and \(h\) is multiplied with the answer, returned states tend toward the opposite sign as that provided as a bias. For example, if you bias a qubit with an \(h\) value of \(-1\), it is more likely to have a final state of \(+1\) in the solution.

[2]QPU-like solvers emulate this process.

A problem definition comprises both \(h\) and \(J\) values. For example, the following is a 7-qubit problem in which \(q_1\) and \(q_4\) are biased with \(-1\) and \(q_0\), \(q_2\), \(q_3\), \(q_4\), and \(q_6\) are biased with \(+1\). Qubits \(q_0\) and \(q_6\) have a ferromagnetic coupling between them with a strength of \(-1\).

h = [1, -1, 1, 1, -1, 1, 1]
J = {(0, 6): -1}

To see the supported \(h\) range for a solver, check its h_range property. The auto_scale parameter enables you to submit problems with values outside h_range and j_range and have the system automatically scale them to fit.

Note

For QPU solvers, the programming cycle programs the solver to the specified \(h\) and \(J\) values for a given Ising problem (or \(Q\) values for a given QUBO problem). However, since QPU precision is limited, the \(h\) and \(J\) values (or \(Q\) values) realized on the solver may deviate slightly from the requested values. For more information, see Technical Description of the D-Wave Quantum Processing Unit.

Note

For QUBO problems, use \(\rm \textbf{Q}\) instead of \(h\) and \(J\); see Q for more information and instructions on converting between the formulations.

initial_state

When using the reverse annealing feature, you must supply the initial state to which the system is set. When you include this parameter with the anneal_schedule parameter, this indicates that the requested anneal schedule change is also a reverse anneal.

The initial_state parameter specifies the initial classical state of all qubits. Provide (qubit, state) pairs, where qubit is the qubit index, i, and state is:

  • -1 or 1—Ising problems, active qubits
  • 0 or 1—QUBO problems, active qubits
  • 3—Unused or inactive qubits

Format varies by SAPI client; for all, length equals the total number of qubits:

  • For C, provide an array using the sapi_ReverseAnneal structure.
  • For MATLAB, provide the dense set of (qubit, state) pairs as a vector.
  • For Python, provide the dense set of (qubit, state) pairs as a list or tuple.

You have the option to reassert this state for each anneal, although this impacts timing; see also reinitialize_state.

J

For Ising problems, the \(J\) values are the quadratic coefficients applied to the couplers in a problem. This parameter defines the type and the strength of the coupling between a pair of qubits:

  • \(\textbf {J < 0}\): Ferromagnetic coupling; coupled qubits prefer to be in the same state, \((1,1)\) or \((-1,-1)\).
  • \(\textbf {J > 0}\): Antiferromagnetic coupling; coupled qubits prefer to be in opposite states, \((-1,1)\) or \((1,-1)\).
  • \(\textbf {J = 0}\): No coupling; qubit states do not affect each other.

The larger the absolute value of \(J\), the stronger the coupling.

A problem definition comprises both \(h\) and \(J\) values. The following is a 7-qubit problem with a coupling strength of \(-1\) between \(q_0\) and \(q_6\):

h = [1, -1, 1, 1, -1, 1, 1]
J = {(0, 6): -1}

To see the supported \(J\) range for a solver, check its j_range property. The auto_scale parameter enables you to submit problems with values outside h_range and j_range range and have the system automatically scale them to fit. Some solvers support an extended \(J\) range for stronger couplings; however, be aware that you cannot use the extended \(J\) range with autoscaling or spin-reversal transforms. See extended_j_range for more information.

Note

For QPU solvers, the programming cycle programs the solver to the specified \(h\) and \(J\) values for a given Ising problem (or \(Q\) values for a given QUBO problem). However, since QPU precision is limited, the \(h\) and \(J\) values (or \(Q\) values) realized on the solver may deviate slightly from the requested values. For more information, see Technical Description of the D-Wave Quantum Processing Unit.

Note

For QUBO problems, use \(\rm \textbf{Q}\) instead of \(h\) and \(J\); see Q for more information and instructions on converting between the formulations.

max_answers

Specifies the maximum number of answers returned from the solver:

Must be an integer > 0; default is num_reads.

num_reads

Indicates the number of states (output solutions) to read[3] from the solver. Must be a positive integer; default is 1.

[3]Terms synonymous to reads are anneals and samples.

num_spin_reversal_transforms

Specifies the number of spin-reversal transforms[4] to perform.

[4]Also known as gauge transformations.
Use this parameter to specify how many spin-reversal transforms to perform on the problem. Valid values range from 0 (do not transform the problem; the default value) to a value equal to but no larger than the num-reads specified. If you specify a nonzero value, the system divides the number of reads by the number of spin-reversal transforms to determine how many reads to take for each transform. For example, if the number of reads is 10 and the number of transforms is 2, then 5 reads use the first transform and 5 use the second.

Applying a spin-reversal transform can improve results by reducing the impact of analog errors that may exist on the QPU. This technique works as follows: Given an \(n\)-variable Ising problem, we can select a random \(g\in\{\pm1\}^n\) and transform the problem via \(h_i\mapsto h_ig_i\) and \(J_{ij}\mapsto J_{ij}g_ig_j\). A spin-reversal transform does not alter the mathematical nature of the Ising problem. Solutions \(s\) of the original problem and \(s^\prime\) of the transformed problem are related by \(s^\prime_i=s_ig_i\) and have identical energies. However, the sample statistics can be affected by the spin-reversal transform because the QPU is a physical object with asymmetries.

Spin-reversal transforms work correctly with postprocessing and chains. Majority voting happens on the original problem state, not on the transformed state.

Be aware that each transform reprograms the QPU; therefore, using more than 1 transform will increase the amount of time required to solve the problem. For more information about timing, see Measuring Computation Time on D-Wave Systems.

Note

Flux-bias offsets and extended \(J\) ranges cannot be used with autoscaling or spin-reversal transforms.

postprocess

Defines what type of postprocessing to run on raw solutions:

  • “” (empty string)—No postprocessing (default). Note that if this option is selected for the VFYC solver, sampling postprocessing runs.
  • sampling—Runs a short Markov-chain Monte Carlo (MCMC) algorithm with single bit-flips starting from each sample. The target probability distribution is a Boltzmann distribution at inverse temperature \(\beta\).
  • optimization—Performs a local search on each sample, stopping at a local minimum.

Note

For problems that use the VFYC solver, postprocessing always runs. By default, sampling postprocessing runs using a default \(\beta\) value of \(10\).

When postprocessing is enabled, qubits in the same chain, defined by the chains parameter, are first set to the same value by majority vote. Postprocessing is performed on the logical problem but qubit-level answers are returned. For more information about postprocessing, see Postprocessing Methods on D-Wave Systems.

programming_thermalization

Gives the time (in microseconds) to wait after programming the QPU for it to cool back to base temperature (i.e., post-programming thermalization time). Lower values accelerate solving at the expense of solution quality. Must be an integer. This value contributes to the total qpu_programming_time, which is returned by SAPI with the problem solutions.

The default value for a solver is given in the default_programming_thermalization property; the range of possible values is given in the programming_thermalization_range property.

Q

A quadratic unconstrained binary operation (QUBO) problem is defined using an upper-triangular matrix, \(\rm \textbf{Q}\), which is an \(N \times N\) matrix of real coefficients, and \(\textbf{x}\), a vector of binary variables. The diagonal entries of \(\rm \textbf{Q}\) are the linear coefficients that bias the qubits (analogous to \(h\), in Ising problems). The nonzero off-diagonal terms are the quadratic coefficients that define the strength of the coupling between variables (analogous to \(J\), in Ising problems).

Input may be full or sparse. Both upper- and lower-triangular values can be used; (\(i\), \(j\)) and (\(j\), \(i\)) entries are added together. If a \(Q\) value is assigned to a coupler not present, an exception is raised. Only entries indexed by working couplers may be nonzero.

Format depends on SAPI client:

  • C—See the sapi_Problem structure in Developer Guide for C.
  • MATLAB—Matrix of QUBO coefficients.
  • Python—Dictionary of QUBO coefficients.

QUBO problems are converted to Ising format before they run on the solver. Ising format uses \(h\) (qubit bias) and \(J\) (coupling strength) to represent the problem; see also h and J.

Before sending a problem, check the h_range and j_range properties for the ranges permitted for the solver. Be aware that problems with values outside the supported range will, by default, be scaled down to fit within the supported range; see the auto_scale parameter for more information. Some solvers support an extended \(J\) range for stronger couplings; however, be aware that you cannot use the extended \(J\) range with autoscaling or spin-reversal transforms. See extended_j_range for more information.

Note

For QPU solvers, the programming cycle programs the solver to the specified \(h\) and \(J\) values for a given Ising problem (or \(Q\) values for a given QUBO problem). However, since QPU precision is limited, the \(h\) and \(J\) values (or \(Q\) values) realized on the solver may deviate slightly from the requested values. For more information, see Technical Description of the D-Wave Quantum Processing Unit.

Problem Conversion

Conversion between QUBO and Ising problem formulations is as follows:

\begin{equation} s = q2 - 1. \end{equation}

To convert the coefficients from QUBO to Ising:

\begin{equation} J_{i,j} = \frac{1}{4} \rm \textbf{Q}_{i,j}, \end{equation} \begin{equation} h_i = \frac{1}{2} \textbf{Q}_{i,i} + \frac{1}{4} \sum_{i < j} \textbf{Q}_{i,j}, \end{equation}

or from Ising to QUBO:

\begin{equation} \textbf{Q}_{i,j} = 4J_{i,j} \end{equation} \begin{equation} \textbf{Q}_{i,i} = 2h_i - \frac{1}{2} \sum_{i < j} \textbf{Q}_{i,j}. \end{equation}

For example, this two-qubit problem in QUBO format,

Q = (0,5): -10,

is as follows in Ising format:

h = [-2.5, 0, 0, 0, 0, -2.5], J = {(0, 5): -2.5}.

The energies for the corresponding solutions have the constant difference of

\begin{equation} \frac{1}{2} \sum_i \textbf{Q}_{i,i} + \frac{1}{4} \sum_{i < j} \textbf{Q}_{i,j}. \end{equation}

qpu_access_overhead_time

A small amount of initialization time spent in low-level operations during the processing of a problem; roughly 1 ms. This value is including in the timing information returned by the Solver API for a completed problem.

readout_thermalization

Gives the time (in microseconds) to wait after each state is read from the QPU for it to cool back to base temperature (i.e., post-readout thermalization time). This value contributes to the qpu_delay_time_per_sample field, which is returned by SAPI with the problem solutions. Must be an integer.

Note

The readout_thermalization parameter is deprecated and will eventually be removed from the API. Plan code updates accordingly.

reduce_intersample_correlation

Reduces sample-to-sample correlations caused by the spin-bath polarization effect[5] by adding a delay between reads.

[5]See the Technical Description of the D-Wave Quantum Processing Unit for more information on this effect.

Boolean flag indicating whether the system adds a delay.

  • reduce_intersample_correlation=true—Adds delay.
  • reduce_intersample_correlation=false (default)—Does not add delay.

Important

Enabling this parameter drastically increases problem run times. To avoid exceeding the maximum problem run time configured for your system, limit the number of reads when using this feature. For more information on timing, see Measuring Computation Time on D-Wave Systems.

reinitialize_state

When using the reverse annealing feature, you must supply the initial state to which the system is set; see the initial_state parameter. If multiple reads are requested in a single call to the Solver API, you have two options for the starting state of the system. These are controlled by the reinitialize_state Boolean parameter:

  • reinitialize_state=true (default)—Reinitialize the initial state for every anneal-readout cycle. Each anneal begins from the state given in the initial_state parameter. The amount of time required to reinitialize varies by system; typical D-Wave 2000Q systems require between 100 and 600 microseconds microseconds for this operation.
  • reinitialize_state=false—Initialize only at the beginning, before the first anneal cycle. Each anneal (after the first) is initialized from the final state of the qubits after the previous cycle. Be aware that even this parameter is disabled, reverse annealing adds a small amount of time (\(\approx 10 \ \mu s\)).

For the C client, this parameter is part of the sapi_ReverseAnneal structure.

See also anneal_schedule.

reverse_anneal

Relevant only to the C client. Pointer to the sapi_ReverseAnneal structure, which defines the initial state of the system at the start of a reverse anneal.

Answer Format

The format of answers returned by QPU solvers depends on the setting of the answer_mode parameter:

  • If raw—The answer contains two fields, solutions and energies. The solutions field is a list of lists; the inner lists all have length num_qubits and entries from \({-1, +1}\) for Ising problems or \({0, 1}\) for QUBO problems. Values of \(3\) denote used or inactive qubits. The energies field contains the energy of each corresponding solution.
  • If histogram—The answer still contains the solutions and energies fields, but in this case the solutions are unique and sorted in increasing-energy order. An additional field, num_occurrences, indicates how many times each solution appeared.