Dbi cost functions

[wrightjandrew]

Features include:

Changes in double_bracket.py which has new cost functions

• off diagonal norm $||\sigma( H)||$
  see https://github.com/qiboteam/qibo/blob/4d4c45295499fd7ccf559bdff63ab494a0bc0c3e/src/qibo/models/dbi/double_bracket.py#L152
• least squares $||H-D||-||D||$
  see https://github.com/qiboteam/qibo/blob/4d4c45295499fd7ccf559bdff63ab494a0bc0c3e/src/qibo/models/dbi/double_bracket.py#L166
• energy fluctuation $(\langle \psi | H^2 |\psi\rangle - \langle \psi | H |\psi\rangle^2)^{1/2}$ where $|\psi\rangle$ is the reference state (e.g. arising from a circuit that approximates an eigenstate preparation so that the energy fluctuation vanishes)
  https://github.com/qiboteam/qibo/blob/4d4c45295499fd7ccf559bdff63ab494a0bc0c3e/src/qibo/models/dbi/double_bracket.py#L223

These are used via the loss function

qibo/src/qibo/models/dbi/double_bracket.py

Lines 211 to 221 in 4d4c452

	if self.cost is DoubleBracketCostFunction.off_diagonal_norm:
	loss = self.off_diagonal_norm
	elif self.cost is DoubleBracketCostFunction.least_squares:
	loss = self.least_squares(d)
	elif self.cost == DoubleBracketCostFunction.energy_fluctuation:
	loss = self.energy_fluctuation(self.ref_state)
	# set back the initial configuration
	self.h = h_copy
	return loss

Scheduling strategies for find the local minimum given a bracket $W=[D,H]$.

These are implemented in utils_scheduling.py and include:

• grid_search_step
• hyperopt_step
• polynomial_step
• simulated_annealing_step

Gradient descent methods for finding $D$ operators

This is done in utils_gradients.py. There are 2 ways of finding gradients defined by how we parametrize $D$.
We parametrize the ansatz for $D$ based on two possible choices of representing a matrix

• the computational basis representation of the matrix $A = \sum_{i,j=0}^{2^L} A_{i,j} |i\rangle\langle j|$ where $L$ is the number of qubits.
• the Pauli operator basis using the orthogonality in the Hilbert-Schmidt scalar product $A = \sum_{\mu,\nu} A_{\mu,\nu} \otimes_{k=1}^L (Z^{\mu_k}X^{\nu_k})$ where $A_{\mu,\nu} = \langle A, \otimes_{k=1}^L (Z^{\mu_k}X^{\nu_k})\rangle_{HS}$

More specifically we have the cases for parametrizing diagonal matrices $D$ as

• via coupling strengths of local Pauli operators $D(B,J) = \sum_i B_i Z_i +\sum_{i,j} J_{i,j} Z_i Z_j$
• via matrix elements in the computational basis $D(d) = \sum_i d_i |i\rangle\langle i|$.

The comutational basis ansatz is there for completeness, once an operator $D$ is found it has to be compiled and so in any case a Pauli basis representation will be used. We recommend using gradient descent directly in the Pauli basis representation. In principle the full optimization in the computational basis could allow for finding operators that outperform an Ising model ansatz but then the operator may be inefficient to compile.

For these parametrizations there is the associated gradient descent method to find the numerical values of the parameters $(B,J)$ or $(d)$
See https://github.com/qiboteam/qibo/blob/dbi_cost_functions/examples/dbi/dbi_cost_functions_and_d_gradients_tutorial.ipynb for results

• For $D(B,0)$ ie the 1-local magnetic field we have the default
  gradient_descent_dbr_pauli_basis - the naming convention reflects that we perform the gradient descent aiming to optimize a double-bracket rotation and we parametrized the ansatz in the Pauli basis
• For the element wise search of the $D(d)$ operator we have
  d_opt, loss_opt, grad_opt, diags_opt = gradient_descent_dbr_computational_basis(dbi, params, 100,lr=1e-2, d_type = d_ansatz_type.element_wise)

Checklist:

• Reviewers confirm new code works as expected.
• Tests are passing.
• Coverage does not decrease.
• Documentation is updated.

Still some work to be done but just wanted to try how the pull request works and see if I'm doing things correctly

[marekgluza]

@Sam-XiaoyueLi please check that including this will not impact some function using it?

[marekgluza]

@scarrazza that was a long one! :) Many thanks among others to @wrightjandrew for the initiative on adding cost functions that help gradient descent and to @Sam-XiaoyueLi for suggesting the new optimizers and implementing the strategies + tests (there's a lot of things that went into this multi branch PR). Also thanks @andrea-pasquale for helping us finalize the tests!