Ising Hamiltonians

Given \(n\) qubits, a 2-local Ising Hamiltonian is an operator of the form:

where \(\sigma_{z}^{i} = \begin{pmatrix}1 & 0 \\ 0 & -1 \end{pmatrix}\), \(h\) is a vector of real coefficients usually referred to as the local magnetic field, and \(J\) is a real symmetric matrix with a zero diagonal, usually referred to as the coupling matrix.

This Hamiltonian is the direct quantization of the following classical Ising cost function:

where \(s_{i}\in \{-1,1\}\).

Quantum annealing machines are typically designed to try and reach the minimum energy state of Ising Hamiltonians, also called ground state, relying on the Adiabatic Theorem. See for instance [AL18] for a general reference on adiabatic quantum computation.

Classical annealing codes like Simulated Quantum Annealing (SA) try and do the same thing: Given \(h\) and \(J\) as input, they will, starting from a random configuration, try to apply updates, as part of Markov chain over the configuration space, in order to look for low energy states, where “energy” is defined by the formulas above.

In other words, quantum annealing machines and, consequently, classical annealing codes, SA, aim at tackling the following optimization problem:

given \(h\) and \(J\) as input.

To produce such Ising-formulated problems, one can use the qat.opt.Ising class:

import numpy as np
from qat.opt import Ising

problem_size = 6  # number of qubits for annealing, can reach to 100s even 1000s

# Problem-specific parameters for Ising
# Magnetic field h
np.random.seed(248)
h_field = np.random.rand(problem_size)

# J-coupling matrix
any_mat = np.random.rand(problem_size, problem_size)
j_mat = ((any_mat + np.transpose(any_mat)) / 2  # make it symmetric
         - np.diag(np.diag(any_mat)))  # make it with 0s as the diagonal elements

# Offset - can be 0
offset = 2.18

# Create an Ising problem
problem_Ising = Ising(J=j_mat,
                      h=h_field,
                      offset_i=offset)

print("Magnetic field h:")
print(problem_Ising.magnetic_field_h, "\n")
print("J-coupling matrix:")
print(problem_Ising.j_coupling_matrix)

# Create a job
problem_Ising_job = problem_Ising.to_job(job_type="sqa", tmax=tmax)
print("\nAn Ising Job has been created - ready to run on an annealing QPU.")

# Create an Ising Observable
problem_Ising_obs = problem_Ising.get_observable("ising")
print("An Ising Observable has also been created - to be fed in a Schedule from which a Job can also be produced.")

Magnetic field h:
[0.69198662 0.48503501 0.02913885 0.56996588 0.84630373 0.99216786] 

J-coupling matrix:
[[0.         0.72490608 0.36270136 0.21518767 0.43237698 0.53659164]
 [0.72490608 0.         0.43329047 0.63995666 0.75877295 0.67301865]
 [0.36270136 0.43329047 0.         0.74051823 0.84432295 0.68663996]
 [0.21518767 0.63995666 0.74051823 0.         0.76994591 0.78961076]
 [0.43237698 0.75877295 0.84432295 0.76994591 0.         0.38143552]
 [0.53659164 0.67301865 0.68663996 0.78961076 0.38143552 0.        ]]
Traceback (most recent call last):
  File "<stdin>", line 30, in <module>
NameError: name 'tmax' is not defined

It is also possible to translate the Ising problem to qat.opt.QUBO via to_qubo() or to CombinatorialProblem via to_combinatorial_problem().

Ising problems can be further converted to both ising Observables and terms Observables, the second being used for gate-based or analog quantum computations.