diff --git a/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb
new file mode 100644
index 0000000000..0f76a36245
--- /dev/null
+++ b/examples/dbi/DBI_strategy_Pauli-Z_products.ipynb
@@ -0,0 +1,542 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Double-Bracket Iteration Strategy: Pauli-Z products\n",
+    "\n",
+    "In this example, we demonstrate the usage of a DBI strategy, where the diagonal operators for double bracket iterations are variationally chosen from all possible local Pauli-Z operators."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Initial setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python -m pip install seaborn # plotting library\n",
+    "!python -m pip install hyperopt # required to optimize the DBF step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import copy, deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration\n",
+    "from qibo.models.dbi.utils import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Below are some useful functions to visualize the diagonalization process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_matrix(matrix, title=\"\"):\n",
+    "    \"\"\"Visualize absolute values of a matrix in a heatmap form.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5, 5))\n",
+    "    ax.set_title(title)\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n",
+    "    fig.colorbar(im, ax=ax)\n",
+    "\n",
+    "\n",
+    "def visualize_drift(h0, h):\n",
+    "    \"\"\"Visualize drift of the evolved hamiltonian w.r.t. h0.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5, 5))\n",
+    "    ax.set_title(r\"Drift: $|\\hat{H}_0 - \\hat{H}_{1}|$\")\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(h0 - h), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute((h0 - h).get()), cmap=\"inferno\")\n",
+    "\n",
+    "    fig.colorbar(im, ax=ax)\n",
+    "\n",
+    "\n",
+    "def plot_histories(loss_histories: list, steps: list, labels: list = None):\n",
+    "    \"\"\"Plot off-diagonal norm histories over a sequential evolution.\"\"\"\n",
+    "    plt.figure(figsize=(5, 5 * 6 / 8))\n",
+    "    if len(steps) == 1:\n",
+    "        # fixed_step\n",
+    "        x_axis = [i * steps[0] for i in range(len(loss_histories))]\n",
+    "    else:\n",
+    "        x_axis = [sum(steps[:k]) for k in range(1, len(steps) + 1)]\n",
+    "    plt.plot(x_axis, loss_histories, \"-o\")\n",
+    "\n",
+    "    x_labels_rounded = [round(x, 2) for x in x_axis]\n",
+    "    x_labels_rounded = [0] + x_labels_rounded[0:5] + [max(x_labels_rounded)]\n",
+    "    x_labels_rounded.pop(3)\n",
+    "    plt.xticks(x_labels_rounded)\n",
+    "\n",
+    "    y_labels_rounded = [round(y, 1) for y in loss_histories]\n",
+    "    y_labels_rounded = y_labels_rounded[0:5] + [min(y_labels_rounded)]\n",
+    "    plt.yticks(y_labels_rounded)\n",
+    "\n",
+    "    if labels is not None:\n",
+    "        labels_copy = copy(labels)\n",
+    "        labels_copy.insert(0, \"Initial\")\n",
+    "        for i, label in enumerate(labels_copy):\n",
+    "            plt.text(x_axis[i], loss_histories[i], label)\n",
+    "\n",
+    "    plt.grid()\n",
+    "    plt.xlabel(r\"Flow duration $s$\")\n",
+    "    plt.title(\"Loss function histories\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example: TFIM\n",
+    "\n",
+    "As an example, we consider the Transverse Field Ising Model (TFIM):\n",
+    "$$ H_{\\rm TFIM} = - \\sum_{i=1}^{N}\\bigl( Z_i Z_{i+1} + h X_i \\bigr),$$\n",
+    "which is already implemented in `Qibo`. For this tutorial we set $N=5$ and $h=3$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Qibo 0.2.4|INFO|2024-01-24 19:59:31]: Using qibojit (numba) backend on /CPU:0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial off diagonal norm 8.48528137423857\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set the qibo backend (we suggest qibojit if N >= 20)\n",
+    "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 2\n",
+    "h = 3\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "H_TFIM = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# initialize class\n",
+    "# Note: use deepcopy to prevent h being edited\n",
+    "dbi = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "print(\"Initial off diagonal norm\", dbi.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-2.-0.j -0.-0.j -0.-0.j -0.-0.j]\n",
+      " [-0.-0.j  2.-0.j -0.-0.j -0.-0.j]\n",
+      " [-0.-0.j -0.-0.j  2.-0.j -0.-0.j]\n",
+      " [-0.-0.j -0.-0.j -0.-0.j -2.-0.j]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(H_TFIM.matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generate local Pauli-Z operators"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "generate_local_Z = generate_Z_operators(nqubits)\n",
+    "Z_ops = list(generate_local_Z.values())\n",
+    "Z_names = list(generate_local_Z.keys())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Iteration from a list of operators\n",
+    "The idea of this strategy is to chose the Z operator that reduces the off-diagonal norm of the hamiltonian most efficiently. Given a list of operators (np.array), the function `select_best_dbr_generator_and_run` searches for the maximum decrease in off-diagonal norm for each operator and runs one double bracket rotation using the optimal operator from the list.\n",
+    "\n",
+    "Note that the hyperopt settings can be set as positional arguments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NSTEPS = 15\n",
+    "max_evals = 100\n",
+    "step_max = 1\n",
+    "Z_optimal = []\n",
+    "# add in initial values for plotting\n",
+    "off_diagonal_norm_history = [dbi.off_diagonal_norm]\n",
+    "steps = [0]\n",
+    "for _ in range(NSTEPS):\n",
+    "    dbi, idx, step, flip_sign = select_best_dbr_generator(dbi, Z_ops, compare_canonical=False, max_evals=max_evals, step_max=step_max)\n",
+    "    off_diagonal_norm_history.append(dbi.off_diagonal_norm)\n",
+    "    steps.append(steps[-1]+step)\n",
+    "    if flip_sign < 0:\n",
+    "        Z_optimal.append('-' + Z_names[idx])\n",
+    "    else:\n",
+    "        Z_optimal.append(Z_names[idx])\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal[-1]}, loss {dbi.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_histories(off_diagonal_norm_history, steps, Z_optimal)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is worth noting that due to the nature of `hyperopt`, the iterations may be unstable and multiple runs may be required for the optimal result (alternatively, we can perform a grid search on the optimal step). Hence, it is sometimes needed to adjust its parameters including the following:\n",
+    "\n",
+    "- step_min\n",
+    "- step_max\n",
+    "- max_evals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare with canonical\n",
+    "\n",
+    "We compare the effectiveness at diagonalzation between the Pauli-Z operators and the canonical generator:\n",
+    "\n",
+    "$$ d = [H,\\sigma(H)]$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set the qibo backend (we suggest qibojit if N >= 20)\n",
+    "# alternatives: tensorflow (not optimized), numpy (when CPU not supported by jit)\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "\n",
+    "# initialize class|\n",
+    "# Note: use deepcopy to prevent h being edited\n",
+    "dbi_canonical = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n",
+    "print(\"Initial off diagonal norm\", dbi_canonical.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "off_diagonal_norm_history_canonical = [dbi_canonical.off_diagonal_norm]\n",
+    "steps_canonical = [0]\n",
+    "steps_canonical_plot = [0]\n",
+    "for s in range(NSTEPS):\n",
+    "    # same settings as iteration from list\n",
+    "    step = dbi_canonical.hyperopt_step(\n",
+    "        step_min = 1e-5,\n",
+    "        step_max = 1,\n",
+    "        space = hp.uniform,\n",
+    "        optimizer = tpe,\n",
+    "        max_evals = max_evals,\n",
+    "    )\n",
+    "    dbi_canonical(step=step)\n",
+    "    print(f\"New optimized step at iteration {s+1}/{NSTEPS}: {step}, loss {dbi_canonical.off_diagonal_norm}\")\n",
+    "    off_diagonal_norm_history_canonical.append(dbi_canonical.off_diagonal_norm)\n",
+    "    steps_canonical.append(step)\n",
+    "    steps_canonical_plot.append(steps_canonical_plot[-1]+step)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Norm off-diagonal restriction\")\n",
+    "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(off_diagonal_norm_history)\n",
+    "print(off_diagonal_norm_history_canonical)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we make 2 observations:\n",
+    "\n",
+    "1. The canonical strategy has a steeper decrease at the beginning than Pauli-Z operators.\n",
+    "2. However, the canonical strategy is also prone to getting stuck at a local minimum and hence resultting in a lesser degree of diagonalization.\n",
+    "\n",
+    "Therefore, we explore the possibility of mixing the two strategies by including the canonical generator in the list."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mixed strategy: optimal at each step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_mixed = DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.single_commutator)\n",
+    "print(\"Initial off diagonal norm\", dbi_mixed.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_eval = deepcopy(dbi_mixed)\n",
+    "dbi_eval.mode = DoubleBracketGeneratorType.canonical\n",
+    "if step is None:\n",
+    "    step = dbi_eval.hyperopt_step(\n",
+    "        step_max=step_max,\n",
+    "        space=hp.uniform,\n",
+    "        optimizer=tpe,\n",
+    "        max_evals=max_evals,\n",
+    "    )\n",
+    "dbi_eval(step=step)\n",
+    "print('canonical norm', dbi_eval.off_diagonal_norm, 'step', step)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Z_optimal_mixed = []\n",
+    "# add in initial values for plotting\n",
+    "off_diagonal_norm_history_mixed = [dbi_mixed.off_diagonal_norm]\n",
+    "steps = [0]\n",
+    "for _ in range(NSTEPS):\n",
+    "    dbi_mixed, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed, Z_ops, compare_canonical=True, max_evals=max_evals)\n",
+    "    off_diagonal_norm_history_mixed.append(dbi_mixed.off_diagonal_norm)\n",
+    "    steps.append(steps[-1]+step)\n",
+    "    if idx == len(Z_ops):\n",
+    "        Z_optimal_mixed.append('Canonical')\n",
+    "    elif flip_sign < 0:\n",
+    "        Z_optimal_mixed.append('-' + Z_names[idx])\n",
+    "    else:\n",
+    "        Z_optimal_mixed.append(Z_names[idx])\n",
+    "    print(f\"New optimized step at iteration {_+1}/{NSTEPS}: {step} with operator {Z_optimal_mixed[-1]}, loss {dbi_mixed.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Norm off-diagonal restriction\")\n",
+    "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After a few tests, we realize that the mixed strategy does not always outperform just using Pauli-Z operators. This could be caused by 2 reasons: \n",
+    "\n",
+    "1. Unstability of hyperopt\n",
+    "2. Tendency of canonical operator to get stuck at a near local minimum"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mixed strategy: initial canonical\n",
+    "\n",
+    "Since the canonical double bracket iteration performs better at the initial steps, we attempt to combine the two strategies: iterate a few steps using the canonical bracket before switching to the variational Z-operators."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbi_mixed_can= DoubleBracketIteration(deepcopy(H_TFIM),mode=DoubleBracketGeneratorType.canonical)\n",
+    "print(\"Initial off diagonal norm\", dbi_mixed_can.off_diagonal_norm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run the initial iterations using canonical iterations\n",
+    "off_diagonal_norm_history_mixed_can = [dbi_mixed_can.off_diagonal_norm]\n",
+    "steps_mixed_can = [0]\n",
+    "cannonical_NSTEPS = 2\n",
+    "for i in range(cannonical_NSTEPS):\n",
+    "    step = steps_canonical[i+1]\n",
+    "    dbi_mixed_can(step=step)\n",
+    "    off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n",
+    "    steps_mixed_can.append(step)\n",
+    "    \n",
+    "print(\"After 2 steps, off diagonal norm:\", dbi_mixed_can.off_diagonal_norm)\n",
+    "print(\"By comparison, the Pauli-Z:\", off_diagonal_norm_history[2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Continue the remaining steps with Pauli-Z operators\n",
+    "Z_optimal_mixed_can = [\"Cannonical\" for _ in range(cannonical_NSTEPS)]\n",
+    "remaining_NSTEPS = NSTEPS - cannonical_NSTEPS\n",
+    "dbi_mixed_can.mode = DoubleBracketGeneratorType.single_commutator\n",
+    "for _ in range(remaining_NSTEPS):\n",
+    "    dbi_mixed_can, idx, step, flip_sign = select_best_dbr_generator(dbi_mixed_can, Z_ops, compare_canonical=False)\n",
+    "    off_diagonal_norm_history_mixed_can.append(dbi_mixed_can.off_diagonal_norm)\n",
+    "    steps_mixed_can.append(step)\n",
+    "    if idx == len(Z_ops):\n",
+    "        Z_optimal_mixed.append('Canonical')\n",
+    "    elif flip_sign < 0:\n",
+    "        Z_optimal_mixed.append('-' + Z_names[idx])\n",
+    "    else:\n",
+    "        Z_optimal_mixed.append(Z_names[idx])\n",
+    "    print(f\"New optimized step at iteration {_+1}/{remaining_NSTEPS}: {step} with operator {Z_optimal_mixed_can[-1]}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure()\n",
+    "# plt.plot(steps, off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "# plt.plot(steps_canonical, off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.plot(off_diagonal_norm_history, label=\"Pauli-Z\")\n",
+    "plt.plot(off_diagonal_norm_history_canonical, label=\"Canonical\")\n",
+    "plt.plot(off_diagonal_norm_history_mixed, label=\"Mixed: optimal steps\")\n",
+    "plt.plot(off_diagonal_norm_history_mixed_can, label=\"Mixed: initial canonical\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Norm off-diagonal restriction\")\n",
+    "plt.title(\"Compare Variational Pauli-Z with Canonical\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This example also shows that the canonical generator is more likely to drive the model into a local minimum than variationally assigned diagonal operator, and that it is hard to get it unstuck even with the Pauli-Z operators."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/dbi/dbi.ipynb b/examples/dbi/dbi.ipynb
deleted file mode 100644
index 913899989c..0000000000
--- a/examples/dbi/dbi.ipynb
+++ /dev/null
@@ -1,764 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "cb748c1a-2ecd-44a2-91d8-c1255a00615b",
-   "metadata": {},
-   "source": [
-    "## Double-Bracket Iteration diagonalization algorithm\n",
-    "\n",
-    "In this example we present the `Qibo`'s implementation of the Double-Bracket Iteration (DBI) algorithm, which can be used to prepare the eigenstates of a quantum system. \n",
-    "\n",
-    "#### The initial setup\n",
-    "\n",
-    "At first we import some useful packages."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f270b1ea-ee6a-4eac-a0ff-3d7dae296cf0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from copy import deepcopy\n",
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from hyperopt import hp, tpe\n",
-    "\n",
-    "from qibo import hamiltonians, set_backend\n",
-    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ba6e5402-ea34-4979-bb79-fd395567f77d",
-   "metadata": {},
-   "source": [
-    "Here we define a simple plotting function useful to keep track of the diagonalization process."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "4aec7b46-19b9-4004-93c0-a90255e58fd9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def visualize_matrix(matrix, title=\"\"):\n",
-    "    \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n",
-    "    fig, ax = plt.subplots(figsize=(5,5))\n",
-    "    ax.set_title(title)\n",
-    "    try:\n",
-    "        im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n",
-    "    except TypeError:\n",
-    "        im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "\n",
-    "def visualize_drift(h0, h):\n",
-    "    \"\"\"Visualize drift of the evolved hamiltonian w.r.t. h0.\"\"\"\n",
-    "    fig, ax = plt.subplots(figsize=(5,5))\n",
-    "    ax.set_title(r\"Drift: $|\\hat{H}_0 - \\hat{H}_{\\ell}|$\")\n",
-    "    try:\n",
-    "        im = ax.imshow(np.absolute(h0 - h), cmap=\"inferno\")\n",
-    "    except TypeError:\n",
-    "        im = ax.imshow(np.absolute((h0 - h).get()), cmap=\"inferno\")\n",
-    "\n",
-    "    fig.colorbar(im, ax=ax)\n",
-    "\n",
-    "def plot_histories(histories, labels):\n",
-    "    \"\"\"Plot off-diagonal norm histories over a sequential evolution.\"\"\"\n",
-    "    colors = plt.get_cmap(\"coolwarm\", len(histories))\n",
-    "    plt.figure(figsize=(5,5*6/8))\n",
-    "    for i, (h, l) in enumerate(zip(histories, labels)):\n",
-    "        plt.plot(h, lw=2, color=colors(i), label=l, marker='.')\n",
-    "    plt.legend()\n",
-    "    plt.xlabel(\"Iterations\")\n",
-    "    plt.ylabel(r\"$\\| \\sigma(\\hat{H}) \\|^2$\")\n",
-    "    plt.title(\"Loss function histories\")\n",
-    "    plt.grid(True)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9f4cd7cc-9952-4da4-baef-e916300a9365",
-   "metadata": {},
-   "source": [
-    "We need to define a target hamiltonian which we aim to diagonalize. As an example, we consider the Transverse Field Ising Model (TFIM):\n",
-    "$$ H_{\\rm TFIM} = - \\sum_{q=0}^{N}\\bigl( Z_i Z_{i+1} + h X_i \\bigr),$$\n",
-    "which is already implemented in `Qibo`. For this tutorial we set $N=6$ and $h=3$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "2c4ed408-68ed-4054-825c-2a7df0979a4f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[Qibo 0.2.3|INFO|2023-11-28 23:17:34]: Using qibojit (numba) backend on /CPU:0\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# set the qibo backend (we suggest qibojit if N >= 20)\n",
-    "set_backend(\"qibojit\", \"numba\")\n",
-    "\n",
-    "# hamiltonian parameters\n",
-    "nqubits = 5\n",
-    "h = 3\n",
-    "\n",
-    "# define the hamiltonian\n",
-    "h = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
-    "\n",
-    "# vosualize the matrix\n",
-    "visualize_matrix(h.matrix, title=\"Target hamiltonian\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4794e779-bf2d-4ab5-97ce-f876d9522a35",
-   "metadata": {},
-   "source": [
-    "#### The generator of the evolution\n",
-    "\n",
-    "The model is implemented following the procedure presented in [1], and the first practical step is to define the generator of the iteration $\\hat{\\mathcal{U}}_{\\ell}$, which executes one diagonalization step $$\\hat{H}_{\\ell} = \\hat{\\mathcal{U}}_{\\ell}^{\\dagger} \\hat{H} \\hat{\\mathcal{U}}_{\\ell}.$$\n",
-    "In `Qibo`, we define the iteration type through a `DoubleBracketGeneratorType` object, which can be chosen between one of the following:\n",
-    "- `canonical`: the generator of the iteration at step $k+1$ is defined using the commutator between the off diagonal part $\\sigma(\\hat{H_k})$ and the diagonal part $\\Delta(\\hat{H}_k)$ of the target evolved hamiltonian:\n",
-    "  $$\\hat{\\mathcal{U}}_{k+1}=\\exp\\bigl\\{s[\\Delta(\\hat{H}_k), \\sigma(\\hat{H}_k)]\\bigr\\}.$$ \n",
-    "- `single_commutator`: the evolution follows a similar procedure of the previous point in this list, but any additional matrix $D_k$ can be used to control the evolution at each step:\n",
-    "    $$ \\hat{\\mathcal{U}}_{k+1}=\\exp\\bigl\\{s[D_k, \\hat{H}_k]\\bigr\\}. $$\n",
-    "- `group_commutator`: the following group commutator is used to compute the evolution:\n",
-    "  $$  \\hat{\\mathcal{U}}_{k+1}= e^{is\\hat{H_k}} e^{isD_k} e^{-is\\hat{H_k}} e^{-isD_k}, $$\n",
-    "which approximates the canonical commutator for small $s$.\n",
-    "\n",
-    "In order to set one of this evolution generators one can do as follow:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "id": "26a487e9-366b-4203-b660-e3d4af2bcb68",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "DoubleBracketGeneratorType.canonical\n",
-      "DoubleBracketGeneratorType.single_commutator\n",
-      "DoubleBracketGeneratorType.group_commutator\n"
-     ]
-    }
-   ],
-   "source": [
-    "# we have a look inside the DoubleBracketGeneratorType class\n",
-    "for generator in DoubleBracketGeneratorType:\n",
-    "    print(generator)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "id": "da8dce89-27f6-403d-982a-58d531fade48",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# here we set the canonical generator\n",
-    "iterationtype = DoubleBracketGeneratorType.canonical"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fc4f9f75-0548-4533-a13c-3aba3191e608",
-   "metadata": {},
-   "source": [
-    "#### The `DoubleBracketIteration` class\n",
-    "\n",
-    "A `DoubleBracketIteration` object can be initialize by calling the `qibo.models.double_braket.DoubleBracketIteration` model and passing the target hamiltonian and the generator type we want to use to perform the evolutionary steps."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "055870ec-55f2-4b99-a622-e3aa4c7dd0e9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dbf = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b38cf803-60b4-467a-be8e-cbad5d81f14a",
-   "metadata": {},
-   "source": [
-    "#### `DoubleBracketIteration` features"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "9e278c3d-9f34-4a40-b453-4e030c751ef5",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Backend: qibojit (numba)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# on which qibo backend am I running the algorithm?\n",
-    "print(f\"Backend: {dbf.backend}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "5b8e142b-a0a2-41bd-a16a-265a420b7360",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initial form of the target hamiltonian:\n",
-      "[[-5.-0.j -3.-0.j -3.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n",
-      " [-3.-0.j -1.-0.j -0.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n",
-      " [-3.-0.j -0.-0.j -1.-0.j ... -0.-0.j -0.-0.j -0.-0.j]\n",
-      " ...\n",
-      " [-0.-0.j -0.-0.j -0.-0.j ... -1.-0.j -0.-0.j -3.-0.j]\n",
-      " [-0.-0.j -0.-0.j -0.-0.j ... -0.-0.j -1.-0.j -3.-0.j]\n",
-      " [-0.-0.j -0.-0.j -0.-0.j ... -3.-0.j -3.-0.j -5.-0.j]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# the initial target hamiltonian is a qibo hamiltonian\n",
-    "# thus the matrix can be accessed typing h.matrix\n",
-    "print(f\"Initial form of the target hamiltonian:\\n{dbf.h0.matrix}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "4f9d1d41-3df7-49cf-96ca-fa1019c00c33",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# let's visualize it in a more graphical way\n",
-    "visualize_matrix(dbf.h0.matrix, r\"$H_0$\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "7b864712-219c-44b6-8337-19ef0100e318",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# since we didn't perform yet any evolutionary step they are the same\n",
-    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5e576bc4-4e79-4c71-9ea0-b3012e9f2ba1",
-   "metadata": {},
-   "source": [
-    "which shows $\\hat{H}$ is now identical to $\\hat{H}_0$ since no evolution step has been performed yet."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "id": "da3d3aaa-17e1-492e-bcd3-b510f44a5391",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# diagonal part of the H target\n",
-    "visualize_matrix(dbf.diagonal_h_matrix)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "id": "24d0dfa1-7039-4d7d-8aa3-5a937b9ab0b8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "HS norm of the off diagonal part of H: 1440.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Hilbert-Schmidt norm of the off-diagonal part\n",
-    "# which we want to bring to be close to zero\n",
-    "print(f\"HS norm of the off diagonal part of H: {dbf.off_diagonal_norm}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d75e35ab-66f4-49f9-af19-679c20065a11",
-   "metadata": {},
-   "source": [
-    "Finally, the energy fluctuation of the system at step $k$ over a given state $\\mu$\n",
-    "\n",
-    "$$ \\Xi(\\mu) = \\sqrt{\\langle \\mu | \\hat{H}_k^2 | \\mu \\rangle - \\langle \\mu | \\hat{H}_k | \\mu \\rangle^2} $$\n",
-    "\n",
-    "can be computed:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "id": "95f8d86f-07d4-498c-acb1-f6f6a4614c24",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "6.708203932499369"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# define a quantum state\n",
-    "# for example the ground state of a multi-qubit Z hamiltonian\n",
-    "Z = hamiltonians.Z(nqubits=nqubits)\n",
-    "state = Z.ground_state()\n",
-    "\n",
-    "# compute energy fluctuations using current H and given state\n",
-    "dbf.energy_fluctuation(state)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3d5b37f3-2477-49a0-9f80-7da5ddda1fff",
-   "metadata": {},
-   "source": [
-    "#### Call the `DoubleBracketIteration` to perform a DBF iteration\n",
-    "\n",
-    "If the DBF object is called, a Double Bracket Iteration iteration is performed. This can be done customizing the iteration by setting the iteration step and the desired `DoubleBracketGeneratorType`. If no generator is provided, the one passed at the initialization time is used (default is `DoubleBracketGeneratorType.canonical`)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "id": "9a886261-8aa6-4df0-a31b-9c39847db124",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Initial value of the off-diagonal norm: 1440.0\n",
-      "One step later off-diagonal norm: 1168.2530943739996\n"
-     ]
-    }
-   ],
-   "source": [
-    "# perform one evolution step\n",
-    "\n",
-    "# initial value of the off-diagonal norm\n",
-    "print(f\"Initial value of the off-diagonal norm: {dbf.off_diagonal_norm}\")\n",
-    "\n",
-    "dbf(step=0.01, mode=iterationtype)\n",
-    "\n",
-    "# after one step\n",
-    "print(f\"One step later off-diagonal norm: {dbf.off_diagonal_norm}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b78dd05d-ffe3-435a-b5ec-2a42f28066b2",
-   "metadata": {},
-   "source": [
-    "We can check now if something happened by plotting the drift:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "cc74812d-7c2c-44e4-afc2-e235968801b4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3465a422-eebf-4e80-ae96-bba894132330",
-   "metadata": {},
-   "source": [
-    "The set step can be good, but maybe not the best one. In order to do this choice in a wiser way, we can call the DBF hyperoptimization routine to search for a better initial step. The `dbf.hyperopt_step` method is built on top of the [`hyperopt`](https://hyperopt.github.io/hyperopt/) package. Any algorithm or sampling space provided by the official package can be used. We are going to use the default options (we sample new steps from a uniform space following a _Tree of Parzen estimators algorithm_)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "aad79966-7a11-4a45-aba5-4a4bb8315c50",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████████████████████████████████████████████████████████████████████| 1000/1000 [00:07<00:00, 135.71trial/s, best loss: 828.389600594478]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# restart\n",
-    "dbf.h = dbf.h0\n",
-    "\n",
-    "# optimization of the step, we allow to search in [1e-5, 1]\n",
-    "step = dbf.hyperopt_step(\n",
-    "    step_min = 1e-5,\n",
-    "    step_max = 1,\n",
-    "    space = hp.uniform,\n",
-    "    optimizer = tpe,\n",
-    "    max_evals = 1000,\n",
-    "    verbose = True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "id": "49483a47-d29d-440e-a4bc-143bfe6bb3cf",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "visualize_matrix(dbf.h.matrix)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "id": "6bdaf7f9-7e49-4a16-8b29-ae1f9746cd9b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b5f1d00e-e763-40d9-822f-e0e8d4c57d9a",
-   "metadata": {},
-   "source": [
-    "#### Let's evolve the model for `NSTEPS`\n",
-    "\n",
-    "We know recover the initial hamiltonian, and we perform a sequence of DBF iteration steps, in order to show how this mechanism can lead to a proper diagonalization of the target hamiltonian.\n",
-    "\n",
-    "#### Method 1: fixed step"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "59a6a485-a714-4e14-b27a-1df2930068ee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# restart\n",
-    "dbf_1 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n",
-    "off_diagonal_norm_history = [dbf_1.off_diagonal_norm]\n",
-    "histories, labels = [], [\"Fixed step\"]\n",
-    "\n",
-    "# set the number of evolution steps\n",
-    "NSTEPS = 20\n",
-    "step = 0.005\n",
-    "\n",
-    "for s in range(NSTEPS):\n",
-    "    dbf_1(step=step)\n",
-    "    off_diagonal_norm_history.append(dbf_1.off_diagonal_norm)\n",
-    "\n",
-    "histories.append(off_diagonal_norm_history)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "7e0b2f18-ca53-4f34-9fcf-0052dcc31dc5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x375 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_histories(histories, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "eb797d6c-0eba-4da4-b492-8b5d70f9123f",
-   "metadata": {},
-   "source": [
-    "#### Method 2: optimizing the step"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "a6fd1e33-3620-4f3b-b705-a120f6da0027",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "100%|███████████████████████████████████████████████████████████████████████████| 500/500 [00:03<00:00, 139.04trial/s, best loss: 828.4029086137314]\n",
-      "New optimized step at iteration 1/20: 0.00907435949552582\n",
-      "New optimized step at iteration 2/20: 0.011738278731277103\n",
-      "New optimized step at iteration 3/20: 0.0045987583077511385\n",
-      "New optimized step at iteration 4/20: 0.006865748082507235\n",
-      "New optimized step at iteration 5/20: 0.004652263378626265\n",
-      "New optimized step at iteration 6/20: 0.013253085844944746\n",
-      "New optimized step at iteration 7/20: 0.006779022070699562\n",
-      "New optimized step at iteration 8/20: 0.009886240467319665\n",
-      "New optimized step at iteration 9/20: 0.006399824883327991\n",
-      "New optimized step at iteration 10/20: 0.008592611420682158\n",
-      "New optimized step at iteration 11/20: 0.005012857617086527\n",
-      "New optimized step at iteration 12/20: 0.009802882048096942\n",
-      "New optimized step at iteration 13/20: 0.004481771967686691\n",
-      "New optimized step at iteration 14/20: 0.0028229524490823166\n",
-      "New optimized step at iteration 15/20: 0.002088243586292965\n",
-      "New optimized step at iteration 16/20: 0.0017036454928744684\n",
-      "New optimized step at iteration 17/20: 0.002065064398286409\n",
-      "New optimized step at iteration 18/20: 0.004597776617771068\n",
-      "New optimized step at iteration 19/20: 0.004651169821329501\n"
-     ]
-    }
-   ],
-   "source": [
-    "# restart\n",
-    "dbf_2 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n",
-    "off_diagonal_norm_history = [dbf_2.off_diagonal_norm]\n",
-    "\n",
-    "# set the number of evolution steps\n",
-    "NSTEPS = 20\n",
-    "\n",
-    "# optimize first step\n",
-    "step = dbf_2.hyperopt_step(\n",
-    "    step_min = 1e-5,\n",
-    "    step_max = 1,\n",
-    "    space = hp.uniform,\n",
-    "    optimizer = tpe,\n",
-    "    max_evals = 500,\n",
-    "    verbose = True\n",
-    ")\n",
-    "\n",
-    "for s in range(NSTEPS):\n",
-    "    if s != 0:\n",
-    "        step = dbf_2.hyperopt_step(\n",
-    "            step_min = 1e-5,\n",
-    "            step_max = 1,\n",
-    "            space = hp.uniform,\n",
-    "            optimizer = tpe,\n",
-    "            max_evals = 100,\n",
-    "        )\n",
-    "        print(f\"New optimized step at iteration {s}/{NSTEPS}: {step}\")\n",
-    "    dbf_2(step=step)\n",
-    "    off_diagonal_norm_history.append(dbf_2.off_diagonal_norm)\n",
-    "\n",
-    "histories.append(off_diagonal_norm_history)\n",
-    "labels.append(\"Optimizing step\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "id": "0f0212bf-b642-4fea-9203-037876e0b266",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x375 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_histories(histories, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "32341937-4178-41d2-a10e-5e4d2634098e",
-   "metadata": {},
-   "source": [
-    "The hyperoptimization can lead to a faster convergence of the algorithm."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "id": "82b89092-07e5-4788-9ae0-8907df2428eb",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "visualize_matrix(dbf_1.h.matrix)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "id": "ac8ed320-04a8-42af-a980-48ab4f1fff7c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 500x500 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "visualize_matrix(dbf_2.h.matrix)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/examples/dbi/dbi_tutorial_basic_intro.ipynb b/examples/dbi/dbi_tutorial_basic_intro.ipynb
new file mode 100644
index 0000000000..ecb28bb4d7
--- /dev/null
+++ b/examples/dbi/dbi_tutorial_basic_intro.ipynb
@@ -0,0 +1,562 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cb748c1a-2ecd-44a2-91d8-c1255a00615b",
+   "metadata": {},
+   "source": [
+    "## Double-Bracket Iteration diagonalization algorithm\n",
+    "\n",
+    "In this example we present the `Qibo`'s implementation of the Double-Bracket Iteration (DBI) algorithm, which can be used to prepare the eigenstates of a quantum system. \n",
+    "\n",
+    "#### The initial setup\n",
+    "\n",
+    "At first we import some useful packages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1f362b8-eb73-456e-ae48-94c5f2a12649",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!python -m pip install seaborn # plotting library\n",
+    "!python -m pip install hyperopt # required to optimize the DBF step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f270b1ea-ee6a-4eac-a0ff-3d7dae296cf0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from copy import deepcopy\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from hyperopt import hp, tpe\n",
+    "\n",
+    "from qibo import hamiltonians, set_backend\n",
+    "from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType, DoubleBracketIteration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba6e5402-ea34-4979-bb79-fd395567f77d",
+   "metadata": {},
+   "source": [
+    "Here we define a simple plotting function useful to keep track of the diagonalization process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4aec7b46-19b9-4004-93c0-a90255e58fd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def visualize_matrix(matrix, title=\"\"):\n",
+    "    \"\"\"Visualize hamiltonian in a heatmap form.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5,5))\n",
+    "    ax.set_title(title)\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(matrix), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute(matrix.get()), cmap=\"inferno\")\n",
+    "    fig.colorbar(im, ax=ax)\n",
+    "\n",
+    "def visualize_drift(h0, h):\n",
+    "    \"\"\"Visualize drift of the evolved hamiltonian w.r.t. h0.\"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(5,5))\n",
+    "    ax.set_title(r\"Drift: $|\\hat{H}_0 - \\hat{H}_{\\ell}|$\")\n",
+    "    try:\n",
+    "        im = ax.imshow(np.absolute(h0 - h), cmap=\"inferno\")\n",
+    "    except TypeError:\n",
+    "        im = ax.imshow(np.absolute((h0 - h).get()), cmap=\"inferno\")\n",
+    "\n",
+    "    fig.colorbar(im, ax=ax)\n",
+    "\n",
+    "def plot_histories(histories, labels):\n",
+    "    \"\"\"Plot off-diagonal norm histories over a sequential evolution.\"\"\"\n",
+    "    colors = sns.color_palette(\"inferno\", n_colors=len(histories)).as_hex()\n",
+    "    plt.figure(figsize=(5,5*6/8))\n",
+    "    for i, (h, l) in enumerate(zip(histories, labels)):\n",
+    "        plt.plot(h, lw=2, color=colors[i], label=l, marker='.')\n",
+    "    plt.legend()\n",
+    "    plt.xlabel(\"Iterations\")\n",
+    "    plt.ylabel(r\"$\\| \\sigma(\\hat{H}) \\|^2$\")\n",
+    "    plt.title(\"Loss function histories\")\n",
+    "    plt.grid(True)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9f4cd7cc-9952-4da4-baef-e916300a9365",
+   "metadata": {},
+   "source": [
+    "We need to define a target hamiltonian which we aim to diagonalize. As an example, we consider the Transverse Field Ising Model (TFIM):\n",
+    "$$ H_{\\rm TFIM} = - \\sum_{q=0}^{N}\\bigl( Z_i Z_{i+1} + h X_i \\bigr),$$\n",
+    "which is already implemented in `Qibo`. For this tutorial we set $N=6$ and $h=3$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c4ed408-68ed-4054-825c-2a7df0979a4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set the qibo backend (we suggest qibojit if N >= 20)\n",
+    "set_backend(\"qibojit\", \"numba\")\n",
+    "\n",
+    "# hamiltonian parameters\n",
+    "nqubits = 5\n",
+    "h = 3\n",
+    "\n",
+    "# define the hamiltonian\n",
+    "h = hamiltonians.TFIM(nqubits=nqubits, h=h)\n",
+    "\n",
+    "# vosualize the matrix\n",
+    "visualize_matrix(h.matrix, title=\"Target hamiltonian\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4794e779-bf2d-4ab5-97ce-f876d9522a35",
+   "metadata": {},
+   "source": [
+    "#### The generator of the evolution\n",
+    "\n",
+    "The model is implemented following the procedure presented in [1], and the first practical step is to define the generator of the iteration $\\hat{\\mathcal{U}}_{\\ell}$, which executes one diagonalization step $$\\hat{H}_{\\ell} = \\hat{\\mathcal{U}}_{\\ell}^{\\dagger} \\hat{H} \\hat{\\mathcal{U}}_{\\ell}.$$\n",
+    "In `Qibo`, we define the iteration type through a `DoubleBracketGeneratorType` object, which can be chosen between one of the following:\n",
+    "- `canonical`: the generator of the iteration at step $k+1$ is defined using the commutator between the off diagonal part $\\sigma(\\hat{H_k})$ and the diagonal part $\\Delta(\\hat{H}_k)$ of the target evolved hamiltonian:\n",
+    "  $$\\hat{\\mathcal{U}}_{k+1}=\\exp\\bigl\\{s[\\Delta(\\hat{H}_k), \\sigma(\\hat{H}_k)]\\bigr\\}.$$ \n",
+    "- `single_commutator`: the evolution follows a similar procedure of the previous point in this list, but any additional matrix $D_k$ can be used to control the evolution at each step:\n",
+    "    $$ \\hat{\\mathcal{U}}_{k+1}=\\exp\\bigl\\{s[D_k, \\hat{H}_k]\\bigr\\}. $$\n",
+    "- `group_commutator`: the following group commutator is used to compute the evolution:\n",
+    "  $$  \\hat{\\mathcal{U}}_{k+1}= e^{is\\hat{H_k}} e^{isD_k} e^{-is\\hat{H_k}} e^{-isD_k}, $$\n",
+    "which approximates the canonical commutator for small $s$.\n",
+    "\n",
+    "In order to set one of this evolution generators one can do as follow:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26a487e9-366b-4203-b660-e3d4af2bcb68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# we have a look inside the DoubleBracketGeneratorType class\n",
+    "for generator in DoubleBracketGeneratorType:\n",
+    "    print(generator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da8dce89-27f6-403d-982a-58d531fade48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# here we set the canonical generator\n",
+    "iterationtype = DoubleBracketGeneratorType.canonical"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc4f9f75-0548-4533-a13c-3aba3191e608",
+   "metadata": {},
+   "source": [
+    "#### The `DoubleBracketIteration` class\n",
+    "\n",
+    "A `DoubleBracketIteration` object can be initialize by calling the `qibo.models.double_braket.DoubleBracketIteration` model and passing the target hamiltonian and the generator type we want to use to perform the evolutionary steps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "055870ec-55f2-4b99-a622-e3aa4c7dd0e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dbf = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b38cf803-60b4-467a-be8e-cbad5d81f14a",
+   "metadata": {},
+   "source": [
+    "#### `DoubleBracketIteration` features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e278c3d-9f34-4a40-b453-4e030c751ef5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# on which qibo backend am I running the algorithm?\n",
+    "print(f\"Backend: {dbf.backend}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b8e142b-a0a2-41bd-a16a-265a420b7360",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the initial target hamiltonian is a qibo hamiltonian\n",
+    "# thus the matrix can be accessed typing h.matrix\n",
+    "print(f\"Initial form of the target hamiltonian:\\n{dbf.h0.matrix}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f9d1d41-3df7-49cf-96ca-fa1019c00c33",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# let's visualize it in a more graphical way\n",
+    "visualize_matrix(dbf.h0.matrix, r\"$H_0$\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b864712-219c-44b6-8337-19ef0100e318",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# since we didn't perform yet any evolutionary step they are the same\n",
+    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e576bc4-4e79-4c71-9ea0-b3012e9f2ba1",
+   "metadata": {},
+   "source": [
+    "which shows $\\hat{H}$ is now identical to $\\hat{H}_0$ since no evolution step has been performed yet."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da3d3aaa-17e1-492e-bcd3-b510f44a5391",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# diagonal part of the H target\n",
+    "visualize_matrix(dbf.diagonal_h_matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca0ce252",
+   "metadata": {},
+   "source": [
+    "The Hilbert-Schmidt norm of a Hamiltonian is defined as:\n",
+    "\n",
+    "$\\lang A\\rang_{HS}=\\sqrt{A^\\dagger A}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24d0dfa1-7039-4d7d-8aa3-5a937b9ab0b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hilbert-Schmidt norm of the off-diagonal part\n",
+    "# which we want to bring to be close to zero\n",
+    "print(f\"HS norm of the off diagonal part of H: {dbf.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d75e35ab-66f4-49f9-af19-679c20065a11",
+   "metadata": {},
+   "source": [
+    "Finally, the energy fluctuation of the system at step $k$ over a given state $\\mu$\n",
+    "\n",
+    "$$ \\Xi(\\mu) = \\sqrt{\\langle \\mu | \\hat{H}_k^2 | \\mu \\rangle - \\langle \\mu | \\hat{H}_k | \\mu \\rangle^2} $$\n",
+    "\n",
+    "can be computed:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95f8d86f-07d4-498c-acb1-f6f6a4614c24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define a quantum state\n",
+    "# for example the ground state of a multi-qubit Z hamiltonian\n",
+    "Z = hamiltonians.Z(nqubits=nqubits)\n",
+    "state = Z.ground_state()\n",
+    "\n",
+    "# compute energy fluctuations using current H and given state\n",
+    "dbf.energy_fluctuation(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d5b37f3-2477-49a0-9f80-7da5ddda1fff",
+   "metadata": {},
+   "source": [
+    "#### Call the `DoubleBracketIteration` to perform a DBF iteration\n",
+    "\n",
+    "If the DBF object is called, a Double Bracket Iteration iteration is performed. This can be done customizing the iteration by setting the iteration step and the desired `DoubleBracketGeneratorType`. If no generator is provided, the one passed at the initialization time is used (default is `DoubleBracketGeneratorType.canonical`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a886261-8aa6-4df0-a31b-9c39847db124",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# perform one evolution step\n",
+    "\n",
+    "# initial value of the off-diagonal norm\n",
+    "print(f\"Initial value of the off-diagonal norm: {dbf.off_diagonal_norm}\")\n",
+    "\n",
+    "dbf(step=0.01, mode=iterationtype)\n",
+    "\n",
+    "# after one step\n",
+    "print(f\"One step later off-diagonal norm: {dbf.off_diagonal_norm}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b78dd05d-ffe3-435a-b5ec-2a42f28066b2",
+   "metadata": {},
+   "source": [
+    "We can check now if something happened by plotting the drift:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cc74812d-7c2c-44e4-afc2-e235968801b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3465a422-eebf-4e80-ae96-bba894132330",
+   "metadata": {},
+   "source": [
+    "The set step can be good, but maybe not the best one. In order to do this choice in a wiser way, we can call the DBF hyperoptimization routine to search for a better initial step. The `dbf.hyperopt_step` method is built on top of the [`hyperopt`](https://hyperopt.github.io/hyperopt/) package. Any algorithm or sampling space provided by the official package can be used. We are going to use the default options (we sample new steps from a uniform space following a _Tree of Parzen estimators algorithm_)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aad79966-7a11-4a45-aba5-4a4bb8315c50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# restart\n",
+    "dbf.h = dbf.h0\n",
+    "\n",
+    "# optimization of the step, we allow to search in [1e-5, 1]\n",
+    "step = dbf.hyperopt_step(\n",
+    "    step_min = 1e-5,\n",
+    "    step_max = 1,\n",
+    "    space = hp.uniform,\n",
+    "    optimizer = tpe,\n",
+    "    max_evals = 1000,\n",
+    "    verbose = True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49483a47-d29d-440e-a4bc-143bfe6bb3cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_matrix(dbf.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6bdaf7f9-7e49-4a16-8b29-ae1f9746cd9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_drift(dbf.h0.matrix, dbf.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5f1d00e-e763-40d9-822f-e0e8d4c57d9a",
+   "metadata": {},
+   "source": [
+    "#### Let's evolve the model for `NSTEPS`\n",
+    "\n",
+    "We know recover the initial hamiltonian, and we perform a sequence of DBF iteration steps, in order to show how this mechanism can lead to a proper diagonalization of the target hamiltonian.\n",
+    "\n",
+    "#### Method 1: fixed step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "59a6a485-a714-4e14-b27a-1df2930068ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# restart\n",
+    "dbf_1 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n",
+    "off_diagonal_norm_history = [dbf_1.off_diagonal_norm]\n",
+    "histories, labels = [], [\"Fixed step\"]\n",
+    "\n",
+    "# set the number of evolution steps\n",
+    "NSTEPS = 20\n",
+    "step = 0.005\n",
+    "\n",
+    "for s in range(NSTEPS):\n",
+    "    dbf_1(step=step)\n",
+    "    off_diagonal_norm_history.append(dbf_1.off_diagonal_norm)\n",
+    "\n",
+    "histories.append(off_diagonal_norm_history)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e0b2f18-ca53-4f34-9fcf-0052dcc31dc5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_histories(histories, labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb797d6c-0eba-4da4-b492-8b5d70f9123f",
+   "metadata": {},
+   "source": [
+    "#### Method 2: optimizing the step"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6fd1e33-3620-4f3b-b705-a120f6da0027",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# restart\n",
+    "dbf_2 = DoubleBracketIteration(hamiltonian=deepcopy(h), mode=iterationtype)\n",
+    "off_diagonal_norm_history = [dbf_2.off_diagonal_norm]\n",
+    "\n",
+    "# set the number of evolution steps\n",
+    "NSTEPS = 20\n",
+    "\n",
+    "# optimize first step\n",
+    "step = dbf_2.hyperopt_step(\n",
+    "    step_min = 1e-5,\n",
+    "    step_max = 1,\n",
+    "    space = hp.uniform,\n",
+    "    optimizer = tpe,\n",
+    "    max_evals = 500,\n",
+    "    verbose = True\n",
+    ")\n",
+    "\n",
+    "for s in range(NSTEPS):\n",
+    "    if s != 0:\n",
+    "        step = dbf_2.hyperopt_step(\n",
+    "            step_min = 1e-5,\n",
+    "            step_max = 1,\n",
+    "            space = hp.uniform,\n",
+    "            optimizer = tpe,\n",
+    "            max_evals = 100,\n",
+    "        )\n",
+    "        print(f\"New optimized step at iteration {s}/{NSTEPS}: {step}\")\n",
+    "    dbf_2(step=step)\n",
+    "    off_diagonal_norm_history.append(dbf_2.off_diagonal_norm)\n",
+    "\n",
+    "histories.append(off_diagonal_norm_history)\n",
+    "labels.append(\"Optimizing step\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f0212bf-b642-4fea-9203-037876e0b266",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_histories(histories, labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32341937-4178-41d2-a10e-5e4d2634098e",
+   "metadata": {},
+   "source": [
+    "The hyperoptimization can lead to a faster convergence of the algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82b89092-07e5-4788-9ae0-8907df2428eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_matrix(dbf_1.h.matrix)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac8ed320-04a8-42af-a980-48ab4f1fff7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "visualize_matrix(dbf_2.h.matrix)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/poetry.lock b/poetry.lock
index 4833dbf4ee..1ecea2aeaa 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -4103,6 +4103,27 @@ files = [
 numpy = "*"
 scipy = "*"
 
+[[package]]
+name = "seaborn"
+version = "0.13.0"
+description = "Statistical data visualization"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "seaborn-0.13.0-py3-none-any.whl", hash = "sha256:70d740828c48de0f402bb17234e475eda687e3c65f4383ea25d0cc4728f7772e"},
+    {file = "seaborn-0.13.0.tar.gz", hash = "sha256:0e76abd2ec291c655b516703c6a022f0fd5afed26c8e714e8baef48150f73598"},
+]
+
+[package.dependencies]
+matplotlib = ">=3.3,<3.6.1 || >3.6.1"
+numpy = ">=1.20,<1.24.0 || >1.24.0"
+pandas = ">=1.2"
+
+[package.extras]
+dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"]
+docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"]
+stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"]
+
 [[package]]
 name = "setuptools"
 version = "69.1.0"
diff --git a/src/qibo/models/dbi/__init__.py b/src/qibo/models/dbi/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/qibo/models/dbi/double_bracket.py b/src/qibo/models/dbi/double_bracket.py
index 976fcbc021..512df0069c 100644
--- a/src/qibo/models/dbi/double_bracket.py
+++ b/src/qibo/models/dbi/double_bracket.py
@@ -5,7 +5,6 @@
 import hyperopt
 import numpy as np
 
-from qibo.config import raise_error
 from qibo.hamiltonians import Hamiltonian
 
 
@@ -33,13 +32,12 @@ class DoubleBracketIteration:
     Example:
         .. testcode::
 
-            import numpy as np
             from qibo.models.dbi.double_bracket import DoubleBracketIteration, DoubleBracketGeneratorType
-            from qibo.hamiltonians import Hamiltonian
             from qibo.quantum_info import random_hermitian
+            from qibo.hamiltonians import Hamiltonian
 
             nqubits = 4
-            h0 = random_hermitian(2**nqubits)
+            h0 = random_hermitian(2**nqubits, seed=2)
             dbf = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))
 
             # diagonalized matrix
@@ -68,14 +66,14 @@ def __call__(
             )
         elif mode is DoubleBracketGeneratorType.single_commutator:
             if d is None:
-                raise_error(ValueError, f"Cannot use group_commutator with matrix {d}")
+                d = self.diagonal_h_matrix
             operator = self.backend.calculate_matrix_exp(
                 1.0j * step,
                 self.commutator(d, self.h.matrix),
             )
         elif mode is DoubleBracketGeneratorType.group_commutator:
             if d is None:
-                raise_error(ValueError, f"Cannot use group_commutator with matrix {d}")
+                d = self.diagonal_h_matrix
             operator = (
                 self.h.exp(-step)
                 @ self.backend.calculate_matrix_exp(-step, d)
@@ -103,12 +101,12 @@ def off_diag_h(self):
 
     @property
     def off_diagonal_norm(self):
-        """Norm of off-diagonal part of H matrix."""
+        r"""Hilbert Schmidt norm of off-diagonal part of H matrix, namely :math:`\\text{Tr}(\\sqrt{A^{\\dagger} A})`."""
         off_diag_h_dag = self.backend.cast(
             np.matrix(self.backend.to_numpy(self.off_diag_h)).getH()
         )
-        return np.real(
-            np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h))
+        return np.sqrt(
+            np.real(np.trace(self.backend.to_numpy(off_diag_h_dag @ self.off_diag_h)))
         )
 
     @property
@@ -125,6 +123,7 @@ def hyperopt_step(
         optimizer: callable = None,
         look_ahead: int = 1,
         verbose: bool = False,
+        d: np.array = None,
     ):
         """
         Optimize iteration step.
@@ -136,7 +135,8 @@ def hyperopt_step(
             space: see hyperopt.hp possibilities;
             optimizer: see hyperopt algorithms;
             look_ahead: number of iteration steps to compute the loss function;
-            verbose: level of verbosity.
+            verbose: level of verbosity;
+            d: diagonal operator for generating double-bracket iterations.
 
         Returns:
             (float): optimized best iteration step.
@@ -148,28 +148,28 @@ def hyperopt_step(
 
         space = space("step", step_min, step_max)
         best = hyperopt.fmin(
-            fn=partial(self.loss, look_ahead=look_ahead),
+            fn=partial(self.loss, d=d, look_ahead=look_ahead),
             space=space,
             algo=optimizer.suggest,
             max_evals=max_evals,
             verbose=verbose,
         )
-
         return best["step"]
 
-    def loss(self, step: float, look_ahead: int = 1):
+    def loss(self, step: float, d: np.array = None, look_ahead: int = 1):
         """
         Compute loss function distance between `look_ahead` steps.
 
         Args:
             step: iteration step.
+            d: diagonal operator, use canonical by default.
             look_ahead: number of iteration steps to compute the loss function;
         """
         # copy initial hamiltonian
         h_copy = deepcopy(self.h)
 
         for _ in range(look_ahead):
-            self.__call__(mode=self.mode, step=step)
+            self.__call__(mode=self.mode, step=step, d=d)
 
         # off_diagonal_norm's value after the steps
         loss = self.off_diagonal_norm
diff --git a/src/qibo/models/dbi/utils.py b/src/qibo/models/dbi/utils.py
new file mode 100644
index 0000000000..27a92e8cb6
--- /dev/null
+++ b/src/qibo/models/dbi/utils.py
@@ -0,0 +1,159 @@
+from copy import deepcopy
+from itertools import product
+from typing import Optional
+
+import numpy as np
+from hyperopt import hp, tpe
+
+from qibo import symbols
+from qibo.hamiltonians import SymbolicHamiltonian
+from qibo.models.dbi.double_bracket import (
+    DoubleBracketGeneratorType,
+    DoubleBracketIteration,
+)
+
+
+def generate_Z_operators(nqubits: int):
+    """Generate a dictionary containing 1) all possible products of Pauli Z operators for L = n_qubits and 2) their respective names.
+    Return: Dictionary with operator names (str) as keys and operators (np.array) as values
+
+     Example:
+        .. testcode::
+
+            from qibo.models.dbi.utils import generate_Z_operators
+            from qibo.models.dbi.double_bracket import DoubleBracketIteration
+            from qibo.quantum_info import random_hermitian
+            from qibo.hamiltonians import Hamiltonian
+            import numpy as np
+
+            nqubits = 4
+            h0 = random_hermitian(2**nqubits)
+            dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))
+            generate_Z = generate_Z_operators(nqubits)
+            Z_ops = list(generate_Z.values())
+
+            delta_h0 = dbi.diagonal_h_matrix
+            dephasing_channel = (sum([Z_op @ h0 @ Z_op for Z_op in Z_ops])+h0)/2**nqubits
+            norm_diff = np.linalg.norm(delta_h0 - dephasing_channel)
+    """
+    # list of tuples, e.g. ('Z','I','Z')
+    combination_strings = product("ZI", repeat=nqubits)
+    output_dict = {}
+
+    for zi_string_combination in combination_strings:
+        # except for the identity
+        if "Z" in zi_string_combination:
+            op_name = "".join(zi_string_combination)
+            tensor_op = str_to_symbolic(op_name)
+            # append in output_dict
+            output_dict[op_name] = SymbolicHamiltonian(tensor_op).dense.matrix
+    return output_dict
+
+
+def str_to_symbolic(name: str):
+    """Convert string into symbolic hamiltonian.
+    Example:
+        .. testcode::
+
+            from qibo.models.dbi.utils import str_to_symbolic
+            op_name = "ZYXZI"
+            # returns 5-qubit symbolic hamiltonian
+            ZIXZI_op = str_to_symbolic(op_name)
+    """
+    tensor_op = 1
+    for qubit, char in enumerate(name):
+        tensor_op *= getattr(symbols, char)(qubit)
+    return tensor_op
+
+
+def select_best_dbr_generator(
+    dbi_object: DoubleBracketIteration,
+    d_list: list,
+    step: Optional[float] = None,
+    step_min: float = 1e-5,
+    step_max: float = 1,
+    max_evals: int = 200,
+    compare_canonical: bool = True,
+):
+    """Selects the best double bracket rotation generator from a list and execute the rotation.
+
+    Args:
+        dbi_object (`DoubleBracketIteration`): the target DoubleBracketIteration object.
+        d_list (list): list of diagonal operators (np.array) to run from.
+        step (float): fixed iteration duration.
+            Defaults to ``None``, uses hyperopt.
+        step_min (float): minimally allowed iteration duration.
+        step_max (float): maximally allowed iteration duration.
+        max_evals (int): maximally allowed number of evaluation in hyperopt.
+        compare_canonical (bool): if `True`, the optimal diagonal operator chosen from "d_list" is compared with the canonical bracket.
+
+    Returns:
+        The updated dbi_object, index of the optimal diagonal operator, respective step duration, and evolution direction.
+    """
+    norms_off_diagonal_restriction = [
+        dbi_object.off_diagonal_norm for _ in range(len(d_list))
+    ]
+    optimal_steps, flip_list = [], []
+    for i, d in enumerate(d_list):
+        # prescribed step durations
+        dbi_eval = deepcopy(dbi_object)
+        flip_list.append(cs_angle_sgn(dbi_eval, d))
+        if flip_list[i] != 0:
+            if step is None:
+                step_best = dbi_eval.hyperopt_step(
+                    d=flip_list[i] * d,
+                    step_min=step_min,
+                    step_max=step_max,
+                    space=hp.uniform,
+                    optimizer=tpe,
+                    max_evals=max_evals,
+                )
+            else:
+                step_best = step
+            dbi_eval(step=step_best, d=flip_list[i] * d)
+            optimal_steps.append(step_best)
+            norms_off_diagonal_restriction[i] = dbi_eval.off_diagonal_norm
+    # canonical
+    if compare_canonical is True:
+        flip_list.append(1)
+        dbi_eval = deepcopy(dbi_object)
+        dbi_eval.mode = DoubleBracketGeneratorType.canonical
+        if step is None:
+            step_best = dbi_eval.hyperopt_step(
+                step_min=step_min,
+                step_max=step_max,
+                space=hp.uniform,
+                optimizer=tpe,
+                max_evals=max_evals,
+            )
+        else:
+            step_best = step
+        dbi_eval(step=step_best)
+        optimal_steps.append(step_best)
+        norms_off_diagonal_restriction.append(dbi_eval.off_diagonal_norm)
+    # find best d
+    idx_max_loss = np.argmin(norms_off_diagonal_restriction)
+    flip = flip_list[idx_max_loss]
+    step_optimal = optimal_steps[idx_max_loss]
+    dbi_eval = deepcopy(dbi_object)
+    if idx_max_loss == len(d_list) and compare_canonical is True:
+        # canonical
+        dbi_eval(step=step_optimal, mode=DoubleBracketGeneratorType.canonical)
+
+    else:
+        d_optimal = flip * d_list[idx_max_loss]
+        dbi_eval(step=step_optimal, d=d_optimal)
+    return dbi_eval, idx_max_loss, step_optimal, flip
+
+
+def cs_angle_sgn(dbi_object, d):
+    """Calculates the sign of Cauchy-Schwarz Angle :math:`\\langle W(Z), W({\\rm canonical}) \\rangle_{\\rm HS}`."""
+    norm = np.trace(
+        np.dot(
+            np.conjugate(
+                dbi_object.commutator(dbi_object.diagonal_h_matrix, dbi_object.h.matrix)
+            ).T,
+            dbi_object.commutator(d, dbi_object.h.matrix),
+        )
+    )
+    return np.sign(norm)
diff --git a/tests/test_models_dbi.py b/tests/test_models_dbi.py
index d3e4236191..43f3034d4d 100644
--- a/tests/test_models_dbi.py
+++ b/tests/test_models_dbi.py
@@ -17,66 +17,66 @@
 @pytest.mark.parametrize("nqubits", [3, 4, 5])
 def test_double_bracket_iteration_canonical(backend, nqubits):
     h0 = random_hermitian(2**nqubits, backend=backend)
-    dbf = DoubleBracketIteration(
+    dbi = DoubleBracketIteration(
         Hamiltonian(nqubits, h0, backend=backend),
         mode=DoubleBracketGeneratorType.canonical,
     )
-    initial_off_diagonal_norm = dbf.off_diagonal_norm
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
     for _ in range(NSTEPS):
-        dbf(step=np.sqrt(0.001))
+        dbi(step=np.sqrt(0.001))
 
-    assert initial_off_diagonal_norm > dbf.off_diagonal_norm
+    assert initial_off_diagonal_norm > dbi.off_diagonal_norm
 
 
 @pytest.mark.parametrize("nqubits", [3, 4, 5])
 def test_double_bracket_iteration_group_commutator(backend, nqubits):
     h0 = random_hermitian(2**nqubits, backend=backend)
     d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))
-    dbf = DoubleBracketIteration(
+    dbi = DoubleBracketIteration(
         Hamiltonian(nqubits, h0, backend=backend),
         mode=DoubleBracketGeneratorType.group_commutator,
     )
-    initial_off_diagonal_norm = dbf.off_diagonal_norm
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
 
-    with pytest.raises(ValueError):
-        dbf(mode=DoubleBracketGeneratorType.group_commutator, step=0.01)
+    # test first iteration with default d
+    dbi(mode=DoubleBracketGeneratorType.group_commutator, step=0.01)
 
     for _ in range(NSTEPS):
-        dbf(step=0.01, d=d)
+        dbi(step=0.01, d=d)
 
-    assert initial_off_diagonal_norm > dbf.off_diagonal_norm
+    assert initial_off_diagonal_norm > dbi.off_diagonal_norm
 
 
 @pytest.mark.parametrize("nqubits", [3, 4, 5])
 def test_double_bracket_iteration_single_commutator(backend, nqubits):
     h0 = random_hermitian(2**nqubits, backend=backend)
     d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))
-    dbf = DoubleBracketIteration(
+    dbi = DoubleBracketIteration(
         Hamiltonian(nqubits, h0, backend=backend),
         mode=DoubleBracketGeneratorType.single_commutator,
     )
-    initial_off_diagonal_norm = dbf.off_diagonal_norm
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
 
-    with pytest.raises(ValueError):
-        dbf(mode=DoubleBracketGeneratorType.single_commutator, step=0.01)
+    # test first iteration with default d
+    dbi(mode=DoubleBracketGeneratorType.single_commutator, step=0.01)
 
     for _ in range(NSTEPS):
-        dbf(step=0.01, d=d)
+        dbi(step=0.01, d=d)
 
-    assert initial_off_diagonal_norm > dbf.off_diagonal_norm
+    assert initial_off_diagonal_norm > dbi.off_diagonal_norm
 
 
 @pytest.mark.parametrize("nqubits", [3, 4, 5])
 def test_hyperopt_step(backend, nqubits):
     h0 = random_hermitian(2**nqubits, backend=backend)
     d = backend.cast(np.diag(np.diag(backend.to_numpy(h0))))
-    dbf = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend))
+    dbi = DoubleBracketIteration(Hamiltonian(nqubits, h0, backend=backend))
 
     # find initial best step with look_ahead = 1
     initial_step = 0.01
     delta = 0.02
 
-    step = dbf.hyperopt_step(
+    step = dbi.hyperopt_step(
         step_min=initial_step - delta, step_max=initial_step + delta, max_evals=100
     )
 
@@ -84,12 +84,12 @@ def test_hyperopt_step(backend, nqubits):
 
     # evolve following the optimized first step
     for generator in DoubleBracketGeneratorType:
-        dbf(mode=generator, step=step, d=d)
+        dbi(mode=generator, step=step, d=d)
 
     # find the following step size with look_ahead
     look_ahead = 3
 
-    step = dbf.hyperopt_step(
+    step = dbi.hyperopt_step(
         step_min=initial_step - delta,
         step_max=initial_step + delta,
         max_evals=100,
@@ -98,12 +98,12 @@ def test_hyperopt_step(backend, nqubits):
 
     # evolve following the optimized first step
     for gentype in range(look_ahead):
-        dbf(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d)
+        dbi(mode=DoubleBracketGeneratorType(gentype + 1), step=step, d=d)
 
 
 def test_energy_fluctuations(backend):
     h0 = np.array([[1, 0], [0, -1]])
     state = np.array([1, 0])
-    dbf = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend))
-    energy_fluctuation = dbf.energy_fluctuation(state=state)
+    dbi = DoubleBracketIteration(Hamiltonian(1, matrix=h0, backend=backend))
+    energy_fluctuation = dbi.energy_fluctuation(state=state)
     assert energy_fluctuation == 0
diff --git a/tests/test_models_dbi_utils.py b/tests/test_models_dbi_utils.py
new file mode 100644
index 0000000000..a05266e1de
--- /dev/null
+++ b/tests/test_models_dbi_utils.py
@@ -0,0 +1,49 @@
+""""Testing utils for DoubleBracketIteration model"""
+
+import numpy as np
+import pytest
+
+from qibo.hamiltonians import Hamiltonian
+from qibo.models.dbi.double_bracket import (
+    DoubleBracketGeneratorType,
+    DoubleBracketIteration,
+)
+from qibo.models.dbi.utils import *
+from qibo.quantum_info import random_hermitian
+
+NSTEPS = 5
+"""Number of steps for evolution."""
+
+
+@pytest.mark.parametrize("nqubits", [2, 3])
+def test_generate_Z_operators(backend, nqubits):
+    h0 = random_hermitian(2**nqubits)
+    dbi = DoubleBracketIteration(Hamiltonian(nqubits=nqubits, matrix=h0))
+    generate_Z = generate_Z_operators(nqubits)
+    Z_ops = list(generate_Z.values())
+
+    delta_h0 = dbi.diagonal_h_matrix
+    dephasing_channel = (sum([Z_op @ h0 @ Z_op for Z_op in Z_ops]) + h0) / 2**nqubits
+    norm_diff = np.linalg.norm(delta_h0 - dephasing_channel)
+
+    assert norm_diff < 1e-3
+
+
+@pytest.mark.parametrize("nqubits", [2, 3])
+@pytest.mark.parametrize("step", [0.1, None])
+def test_select_best_dbr_generator(backend, nqubits, step):
+    h0 = random_hermitian(2**nqubits, seed=1, backend=backend)
+    dbi = DoubleBracketIteration(
+        Hamiltonian(nqubits, h0, backend=backend),
+        mode=DoubleBracketGeneratorType.single_commutator,
+    )
+    generate_Z = generate_Z_operators(nqubits)
+    Z_ops = list(generate_Z.values())
+    initial_off_diagonal_norm = dbi.off_diagonal_norm
+
+    for _ in range(NSTEPS):
+        dbi, idx, step_optimize, flip = select_best_dbr_generator(
+            dbi, Z_ops, step=step, compare_canonical=True
+        )
+
+    assert initial_off_diagonal_norm > dbi.off_diagonal_norm