English
Languages
English
Bengali
Japanese
Spanish

# Release Notes¶

## 0.4.0¶

### New Features¶

• Adds a method prettyprint() to QuadraticProgram to generate a pretty-printed string of the object.

Here is an example of pretty printing.

qp.integer_var(-1, 2, 'x')
qp.integer_var(-1, 2, 'y')
qp.continuous_var(-1, name='z')
qp.binary_var('u')
qp.binary_var('v')
qp.binary_var_list(10)
qp.integer_var_list(3)
qp.continuous_var_list(3)
qp.minimize(constant=3, linear={'x': 2, 'y': 3}, quadratic={('u', 'x'): -1})
qp.linear_constraint({'x': 1, 'y': -2}, '>=', 2, name='lin_GE')
qp.linear_constraint({'x': 2, 'y': -1}, '==', 1, name='lin_EQ')
qp.quadratic_constraint({'x': 1, 'u': 1}, {(3, 4): 1, (5, 6): -1}, '<=', 1, name='quad_LE')
qp.quadratic_constraint({'x': 2, 'y': -1}, {('z', 'z'): -1}, '<=', 1)

print(qp.prettyprint())

The output is as follows.

Problem name: problem 1

Minimize
-x*u + 2*x + 3*y + 3

Subject to
Linear constraints (2)
x - 2*y >= 2  'lin_GE'
2*x - y == 1  'lin_EQ'

u*v - x5*x6 + u + x <= 1  'quad_LE'
-z^2 + 2*x - y <= 1  'q1'

Integer variables (5)
-1 <= x <= 2
-1 <= y <= 2
0 <= x15
0 <= x16
0 <= x17

Continuous variables (4)
-1 <= z
0 <= x18
0 <= x19
0 <= x20

Binary variables (12)
u v x5 x6 x7 x8 x9 x10 x11 x12 x13 x14

• Adds informative text formats to str and repr functions of the following objects. The formats are IDE friendly, i.e., the text is one line.

• If users set an empty variable name "" with binary_var(), integer_var(), and continuous_var(), they set the default variable name (e.g., x0) while they used to set the empty name as variable name.

x = qp.binary_var(name="")
y = qp.integer_var(name="")
z = qp.continuous_var(name="")
print(x.name)  # x0
print(y.name)  # x1
print(z.name)  # x2

• Added support for running with Python 3.10. At the the time of the release, Cplex didn’t have a python 3.10 version and Docplex failed inside docplex.mp.model.Model.binary_var_list().

• Updates the text format of str and repr of the following objects so that the output is one line.

If users want to display a multi-line text of QuadraticProgram and OptimizationResult, please use QuadraticProgram’s prettyprint() and OptimizationResult’s prettyprint(), respectively.

# An example of OptimizationResult
from qiskit_optimization.algorithms import OptimizationResult, OptimizationResultStatus

x = qp.binary_var_list(3)
result = OptimizationResult([1.0,2.0,3.0], 10.0, x, OptimizationResultStatus.SUCCESS)

print(repr(result))
# <OptimizationResult: fval=10.0, x0=1.0, x1=2.0, x2=3.0, status=SUCCESS>

print(str(result))
# fval=10.0, x0=1.0, x1=2.0, x2=3.0, status=SUCCESS

print(result.prettyprint())
# objective function value: 10.0
# variable values: x0=1.0, x1=2.0, x2=3.0
# status: SUCCESS

qp.integer_var(-1, 2, 'x')
qp.integer_var(-1, 2, 'y')
qp.continuous_var(-1, name='z')
qp.minimize(constant=3, linear={'x': 2, 'y': 3}, quadratic={('z', 'x'): -1})
qp.linear_constraint({'x': 1, 'y': -2}, '>=', 2, name='lin_GE')
qp.linear_constraint({'x': 2, 'y': -1}, '==', 1, name='lin_EQ')
qp.quadratic_constraint({'x': 2, 'y': -1}, {('z', 'z'): -1}, '<=', 1)

print(repr(qp))
# <QuadraticProgram: minimize -x*z + 2*x + 3*y + 3, 3 variables, 3 constraints, 'problem 1'>

print(str(qp))
# minimize -x*z + 2*x + 3*y + 3 (3 variables, 3 constraints, 'problem 1')

print(qp.prettyprint())
# Problem name: problem 1
#
# Minimize
#   -x*z + 2*x + 3*y + 3
#
# Subject to
#   Linear constraints (2)
#     x - 2*y >= 2  'lin_GE'
#     2*x - y == 1  'lin_EQ'
#
#     -z^2 + 2*x - y <= 1  'q0'
#
#   Integer variables (2)
#     -1 <= x <= 2
#     -1 <= y <= 2
#
#   Continuous variables (1)
#     -1 <= z

• The previously deprecated BaseBackend class has been removed. It was originally deprecated in the Qiskit Terra 0.18.0 release.

• Enable installation of CPLEX for Python 3.10.

• Support for running with Python 3.6 has been removed. To run Optimization you need a minimum Python version of 3.7.

### Bug Fixes¶

• Fixed an issue that from_ising() raises an error when Pauli I is given.

• Fixed an issue that to_ising() returns a wrong operator when there is no variable in an input problem.

### Other Notes¶

• Shows a warning message if non-printable strings are set to QuadraticProgram as problem name, variable name, or constraint name.

• Updated the documentation of SUCCESS of OptimizationResultStatus. SUCCESS means the obtained solution is feasible, but not always optimal because some algorithms do not guarantee the optimality.

• Reword the documentation of all methods and the multi-line text format of OptimizationResult as follows because some algorithms do not guarantee the optimality.

• “optimal function value” → “objective function value”

• “optimal value” → “variable values”

## 0.3.0¶

### New Features¶

• Added the runtime client QAOAClient to execute the QAOA algorithm on Qiskit runtime. This runtime program leverages QAOA dedicated transpiler passes such as swap strategies and pulse-efficient transpiler passes for cross-resonance based hardware. Both these optimizations can significantly reduce circuit depth and improve execution time and results. Further, the QAOA runtime also allows using CVaR expectation values, which can improve the performance of ground state calculations in optimization settings.

The client can for instance be used as

from qiskit import IBMQ
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import I, Z
from qiskit_optimization.runtime import QAOAClient

# get the provider and backend we use to run the program
provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main")
backend = provider.get_backend("ibmq_qasm_simulator")

# define diagonal Hamiltonian whose minimum eigenvalue we want to find
op =  (Z ^ Z ^ I ^ I ^ I) - (I ^ I ^ Z ^ Z ^ I)

# set up the client and solve the problem
client = QAOAClient(
reps=2,  # use p=2 repetitions in the QAOA ansatz
optimizer=COBYLA(),
alpha=0.75,  # use CVaR expectation with 75% of the best readouts
provider=provider,
backend=backend
)
result = client.compute_minimum_eigenvalue(op)

See also the new QAOA Runtime tutorial in docs/tutorials/12_qaoa_runtime.ipynb for more details.

• Introduced the Sherrington-Kirkpatrick (SK) model [1] qiskit_optimization.applications.SKModel. The model has all-to-all ferromagnetic and antiferromagnetic interactions given by a random disorder and represents a mean-field approximation of a spin glass.

Let $$x\in\{\pm 1\}^n$$ be a configuration of spins. The SK model Hamiltonian on $$n$$ sites is

$\begin{array}{} H(x)=-1/\sqrt{n} \sum_{i<j} w_{i,j}x_ix_j,\text{ where } i,j\in [n], \end{array}$

$$w_{i,j}\in\{\pm 1\}$$ are called disorder and are chosen independently and uniformly at random.

The computational problem associated with this class is to find the ground state of the SK Hamiltonian instance and its energy.

[1]: Dmitry Panchenko. “The Sherrington-Kirkpatrick model: an overview”, https://arxiv.org/abs/1211.1094

• The deprecated methods QuadraticProgram.from_docplex and QuadraticProgram.to_docplex have been removed and no longer exist. These methods were deprecated as part of the 0.2.0 release. Instead you should use from_docplex_mp() and to_docplex_mp().

## 0.2.0¶

### New Features¶

• Adds the support of indicator constraints (e.g. x=1 -> y+z=1) in from_docplex_mp() using the big-M formulation.

• Introduced a new converter class qiskit_optimization.converters.LinearInequalityToPenalty. It converts the following inequality constraints to penalty terms where x, y, $$x_i$$ are binary variables and P is a penalty factor.

$\begin{split}\begin{array}{} \text { Inequality constraint } & & \text { Penalty term } \\ x \leq y & \rightarrow & P(x-x y) \\ x \geq y & \rightarrow & P(y-x y) \\ \sum_{i=1}^n x_i \leq 1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} x_i x_j\\ \sum_{i=1}^n x_i \geq n-1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} (1 - x_i) (1 - x_j) \end{array}\end{split}$
• Allow leveraging Qiskit Runtime to execute VQE and QAOA in the cloud using the VQEProgram and QAOAProgram.