qat.opt.QUBO

class qat.opt.QUBO(Q, offset_q=0, **kwargs)

Class representing Quadratic Unconstrained Binary Optimization (QUBO) problems.

The class allows for the representation of a problem as QUBO - by providing with a symmetric \(Q\) matrix and a QUBO offset energy \(E_Q\), both of which coming from the respective Hamiltonian encoding,

\[H = - x^T Q x - E_Q\]

where \(x\) is the vector of binary values \(\{0,1\}\) we look for, such that \(H\) is minimum.

The class can also translate from a QUBO problem to an Ising problem via to_ising() by returning an Ising object.

QUBO problems can be translated to a CombinatorialProblem object via to_combinatorial_problem().

This class also inherits from the CircuitGenerator class which allows to construct QAOA-Ansätze.

Parameters

  • Q (2D numpy array) – a symmetric array representing the \(Q\) matrix from the Hamiltonian of the problem

  • offset_q (optional, double) – the value of the QUBO offset energy in the Hamiltonian of the problem

aqo_job(tmax=None, mixing=None, **kwargs)

Generates an Adiabatic Quantum Optimization (AQO) job performing a linear interpolation between an initial mixing Hamiltonian and the problem’s Hamiltonian.

classmethod decode_rydberg(job, result)

Returns the MWIS simulation result of the input graph.

Parameters

  • job (Job) – generated job

  • result (Result) – result of the simulation of the crossing lattice graph.

Returns

MWIS simulation result of the input graph.

Return type

Result

static decode_rydberg_meta_data(meta_data: dict, result)

Returns the MWIS simulation result of the input graph.

Parameters

  • meta_data (dict[str, str]) – generated job meta_data

  • result (Result) – result of the simulation of the crossing lattice graph

Returns

MWIS simulation result of the input graph

Return type

Result

get_best_parameters()

A method returning a dictionary with the best annealing parameters found thus far after benchmarking for the respective QUBO problem. If the method is called directly from the parent QUBO class and not from one of the child problem classes (e.g. MaxCut, GraphColouring, etc.), it will raise an exception.

get_observable(obs_type)

Returns an ising- or a terms-type of Observable from the QUBO problem. If a ‘terms’ Observable is chosen, the QUBO problem will first be translated to a CombinatorialProblem.

Parameters

obs_type (string) –

The type of Observable to be returned: 'ising' or 'terms'.

  • 'ising' observables can be used to create a Schedule (by also proving gamma_t if SQAQPU will be used) and consecutively produce a Job to be sent for Simulated Quantum Annealing.

  • 'terms' observables can be used for gate-based quantum computations with a Circuit or analog quantum computations, also with a Schedule.

Returns

an Ising Observable or an Observable with terms representing the problem

Return type

Observable

get_q_and_offset()

This method returns the \(Q\) matrix and QUBO energy offset, which define the QUBO object.

Returns

2-element tuple containing

  • Q (2D numpy array) - a symmetric array representing the \(Q\) matrix from the Hamiltonian of the problem

  • offset_q (double) - the value of the QUBO offset energy in the Hamiltonian of the problem

property q_matrix

The Q-matrix of the QUBO Hamiltonian as a symmetric numpy 2D array

qaoa_job(depth, cnots=True, strategy='coloring', to_circ_args=None, **kwargs)

Generates a QAOA Ansatz Job for gate-based computations using the cost observable returned by the abstract method get_observable.

Warning

When setting the cnots option to False, the circuit might make use of generalized many-qubits Z rotations. In that case, you might want to instantiate your variational plugins using a gate set that contains definition of these gates. If not, some matrices in the circuit structure will be missing and some QPUs may not be able to handle the circuit.

The following piece of code should allow you to link the correct gate set to a variational plugin:

from qat.plugins import ScipyMinimizePlugin
from qat.vsolve.ansatz import get_qaoa_gate_set

# This plugin will no be able to bind variables inside a
# job generated with cnot set to False!
my_plugin = ScipyMinimizePlugin()

# This plugin can now be used with job generated with the
# cnots option sets to False!
my_plugin = ScipyMinimizePlugin(gate_set=get_qaoa_gate_set())
Parameters

  • depth (int) – the depth of the Ansatz

  • strategy (str) – the strategy to adopt to generate the circuit. Possible strategies are “default” or “coloring”. The “coloring” strategy uses a greedy coloring heuristics to try to optimize the overall depth of the Ansatz. Default is “default” which synthesize the circuit without optimizing the term ordering.

  • cnots (optional, bool) – If set to True the Ansatz will only use CNOT gates. If set to False, some abstract gates will be used to generate collective pauli rotations, resulting in a lower gate count. Defaults to True.

  • **kwargs – optional arguments that will be transfered to the job’s constructor (e.g nbshots, etc).

Returns

a Qaptiva job, ready to run

Return type

Job

ryd_job(optimize=True, time_budget_sec=3, tmax=10, **kwargs)

Returns a ryd-type job for the QUBO problem - ready to run with the AnalogQPU

Parameters

  • optimize (bool) – if True, the node overhead will be reduced.

  • time_budget_sec (float) – time budget allocated for the core part of the optimization function.

  • tmax (float) – time duration of the adiabatic simulation.

Returns

a ryd-type job

Return type

Job

sqa_job(gamma_t=None, tmax=1.0, **kwargs)

Returns a sqa-type of Job for the problem - ready to run with SQAQPU.

Parameters

  • tmax (float, optional) – time duration of the annealing. Default is 1.

  • gamma_t (ArithExpression, optional) – a function specifying the time dependence of Gamma. It should be produced using the variable ‘t’ created by the class Variable.

Returns

a ready to run sqa-type of Job for the problem

Return type

Job

Note

For the supported NP problems, some well performing max and min Gamma (for a linearly decreasing gamma_t) have been found and could be accessed via the method get_best_parameters of the respective problem class.

to_bqm()

Transforms a QUBO problem to DWave’s Binary Quadratic Model from the library dimod.

Returns

a BinaryQuadraticModel object

Return type

BinaryQuadraticModel

to_combinatorial_problem()

Translates the QUBO problem into a combinatorial problem.

Returns

a combinatorial problem instance

Return type

CombinatorialProblem

to_ising()

Translates the QUBO problem into an Ising problem over spins.

Returns

an Ising instance

Return type

Ising

to_job(job_type, *args, **kwargs)

A general method allowing the creation of an aqo-, qaoa- or sqa-type of Job from a problem description - ready to run on the respective QPU.

  • 'aqo' is for Adiabatic Quantum Optimization (with analog QPUs). Internally, method aqo_job() is used to generate the job.

  • 'qaoa' is for using the Quantum Approximate Optimization Algorithm (with gate-based QPUs). Internally, method qaoa_job() is used to generate the job.

  • 'sqa' is for Simulated Quantum Annealing (with SQAQPU). Internally, method sqa_job() is used to generate the job.

  • 'ryd' is for Rydberg (with AnalogQPU). Internally, method ryd_job() is used to generate the job.

Parameters
Returns

a ready to run Job for the respective type of problem

Return type

Job