diff --git a/algorithms/adapt_vqe/adapt_vqe.ipynb b/algorithms/adapt_vqe/adapt_vqe.ipynb
new file mode 100644
index 000000000..c1c57c1fc
--- /dev/null
+++ b/algorithms/adapt_vqe/adapt_vqe.ipynb
@@ -0,0 +1,1206 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0",
+   "metadata": {},
+   "source": [
+    "# ADAPT VQE"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1",
+   "metadata": {},
+   "source": [
+    "> The **Adaptive Derivative-Assembled Pseudo-Trotter Variational Quantum Eigensolver (ADAPT-VQE)** [[1](#ADAPT-VQE)] is a variational hybrid algorithm, which constitutes an extension of the Variational Quantum Eigensolver (VQE) framework [[2](#VQE)], that constructs problem-specific ansätze in a systematic and adaptive manner. Instead of relying on a fixed, heuristic circuit structure, ADAPT-VQE iteratively grows the state ansatz by selecting operators from a predefined pool based on their energy gradients with respect to the current variational state. At each iteration, the operator that yields the largest energy reduction is appended to the circuit and its parameters are reoptimized. This adaptive procedure significantly reduces the number of variational parameters and circuit depth, making ADAPT-VQE particularly well suited for near-term quantum hardware. Importantly, the algorithm is heuristic, leading to an approximate solution with no proven convergence guarantees.  \n",
+    ">\n",
+    "> The algorithm treats the following problem:\n",
+    ">\n",
+    "> - **Input:** System Hamiltonian $H$, reference state $| \\Psi_{\\text{ref}}\\rangle$ and an operator pool of anti-Hermitian operators ${\\cal O} =\\{O_1,\\dots,O_M\\}$.\n",
+    "> - **Output:** Approximation of the ground state and energy of $H$.\n",
+    ">\n",
+    "> **Complexity:** The major overhead generally comes from the evaluation of the elements of the energy gradient by repeated measurements of different observables. We therefore focus on the measurement complexity of the algorithm. The complexity depends on the chosen operator pool and classical optimization scheme. The total cost incorporates the two main components of the algorithm, (i) evaluating the energy gradient, and (ii) re-optimization of the current state-ansatz (corresponds to the standard VQE optimization). As a result, at each iteration step the cost is a sum of two terms, corresponding to the two algorithm components:\n",
+    "$$\\text{Cost}\\approx \\sum_{k = 1}^K (M \\cdot C_G(n)+ N_{\\text{opt}^{(k)}}\\cdot C_E(n))~~,$$ where $n$ is the number of qubits, $K$ is the total number of iterations, $C_G(n)$ is the measurement cost to estimate a single operator gradient, $N_{\\text{opt}}^{(k)}$ is the number of optimizer steps at iteration $k$, and $C_E(n)$ is the measurement cost to estimate the energy once. \n",
+    "> \n",
+    "> ---\n",
+    ">\n",
+    "> **Keywords:**  Variational quantum algorithm, Chemistry, Optimization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2",
+   "metadata": {},
+   "source": [
+    "## Overview"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3",
+   "metadata": {},
+   "source": [
+    "The following  notebook begins with a theoretical explanation of the algorithm. We then consider an explicit example, consisting of a system of four qubits. The ADAPT-VQE algorithm is employed to evaluate the ground state energy and state. Following, we provide a modified version of the algorithm, and the results of both versions of the ADAPT-VQE algorithms are compared to the results obtained by the standard VQE algorithm. The notebook concludes with a short summary and analysis of the algorithm and results."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
+   "source": [
+    "## Algorithm steps\n",
+    "The algorithm builds and constructs the ansatz iteratively, one operator at a time, including only the most significant operators. This approach builds a minimal, problem-specific ansatz, avoiding unnecessary parameters and allowing systematic improvement of the accuracy. Similarly to VQE, the algorithms essentially reduce the circuit depth at the expense of measurements. \n",
+    "\n",
+    "Initially, we define an operator pool ${\\cal O}=\\{O_1,O_2,\\cdots,O_M\\}$, containing a collection of anti-Hermitian operators that are employed in the ansatz construction.\n",
+    "\n",
+    "We then follow the following procedure:\n",
+    "1. Initialize the qubits to the reference state, $| \\Psi_{\\text{ref}}\\rangle$, and define the initial iterative state as $| \\psi^{(0)}\\rangle = | \\Psi_{\\text{ref}} \\rangle$.\n",
+    "2. Prepare a trial quantum state with the current ansatz, denoted by $|\\psi^{(k)}\\rangle$, where $k=0,1,\\dots$ corresponds to the iteration step number (initially set to zero).\n",
+    "3. Measure the commutator of the Hamiltonian with the operators of $\\cal{O}$. The expectation value corresponds to the partial derivative of the energy (in the $k$ iteration step) with respect to the coefficient of $O_j$: $$\\frac{\\partial E^{(k+1)}}{\\partial \\theta_j}\\bigg |_{\\theta_j=0} = \\langle\\psi^{(k)}|\\partial_{\\theta_i}e^{-\\theta_i O_j} H e^{O_j \\theta_j}|\\psi^{(l)}\\rangle {\\bigg |}_{\\theta_j = 0}+ \\langle\\psi^{(k)}|e^{-\\theta_j O_j} H \\partial_{\\theta_j}e^{O_j \\theta_j}|\\psi^{(k)}\\rangle {\\bigg |}_{\\theta_j = 0}$$ $$= {{\\langle \\psi^{(k)}|  [H, O_j] |\\psi^{(k)}\\rangle}}~.$$ Hence, the measured commutation relations, provides the gradiant $\\nabla_\\vec{\\theta} E$, where $\\vec{\\theta} = \\{\\theta_1,\\dots,\\theta_k\\}^T~~.$ \n",
+    "4. If the magnitude of the gradient vector is below a certain threshold, stop. Otherwise, identify the operator with the largest gradient, and add it to the left end of the ansatz, with a new variational parameter. If $A_k\\in \\{O_i\\}$ is an operator with the largest gradient on the step $k$, the update rule is given by $$|\\psi^{(k+1)} \\rangle = e^{\\theta_k A_k} |\\psi^{(k)}\\rangle~~.$$  Note, that the added operator still remains in the operator pool, therefore may be added again later on.\n",
+    "5. Conduct a VQE experiment to re-optimize all the ansatz parameters, $\\{\\theta_1,\\dots,\\theta_k\\}$.\n",
+    "6. Go back to step 3 and take $k\\rightarrow k+1$.\n",
+    "\n",
+    "\n",
+    "The final optimized ansatz is of the form $$| \\psi^{\\text{ADAPT}}(\\vec{\\theta}) \\rangle = \\Pi_{n=1}^{K} e^{\\theta_k A_k}|\\psi_{\\text{ref}}\\rangle~~,$$ where $K$ is the total number of iterations.\n",
+    "\n",
+    "Note that when multiple quantum computers are available or sufficiently many qubits on a single computer, the preparation of the trial state and measurement of the commutation relations with the Hamiltonian can be performed in parallel, substantially reducing the runtime."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5",
+   "metadata": {},
+   "source": [
+    "## Implementation of ADPT-VQE with Classiq\n",
+    "\n",
+    "We consider a simple example, consisting of a four-qubit system. The Hamiltonian and operator pool are defined in terms of the [SparsePauliOp](https://docs.classiq.io/latest/qmod-reference/api-reference/classical-types/?h=sparsepauliop#classiq.qmod.builtins.structs.SparsePauliOp) data structure, allowing for rapid and efficient algebraic computations.\n",
+    "For implementation convenience, we consider an operator pool of Hermitian operators (instead of anti-Hermitian as in the theoretical derivation). In this case, the ansatz stat is of the form \n",
+    "$$| \\psi^{\\text{ADAPT}}(\\vec{\\theta}) \\rangle = \\Pi_{k=1}^{K} e^{-i\\theta_k A_k}|\\psi_{\\text{ref}}\\rangle~~,$$\n",
+    "leading to the relation\n",
+    "$$\\frac{\\partial E^{(k+1)}}{\\partial \\theta_j}\\bigg |_{\\theta_j=0} = -i{{\\langle \\psi^{(k)}|  [H, O_j] |\\psi^{(k)}\\rangle}}~~.$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6",
+   "metadata": {},
+   "source": [
+    "We begin by uploading software packages and utility functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import reduce\n",
+    "from operator import add, mul\n",
+    "from typing import Final, List, Tuple\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import scipy\n",
+    "\n",
+    "from classiq import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "### Utility functions\n",
+    "We employ utility functions form the [ADAPT-QAOA notebook](https://github.com/Classiq/classiq-library/blob/main/applications/optimization/adapt_qaoa/adapt_qaoa.ipynb), used to efficiently compute the commutation of Pauli strings with the `SparsePauilOp` data structure. These are used in the computation of $\\langle \\psi^{(k)} | [H, O_j] | \\psi^{(k)}\\rangle$.\n",
+    "\n",
+    "The functions perform the following tasks:\n",
+    "- `sorted_pauli_term` sorts Pauli terms according to the qubit's index.\n",
+    "- `commutator` receives two `SparsePauilOp`s and returns their commutator as a `SparsePauilOp`.\n",
+    "- `normalize_pauli_term` removes redundant Pauli identity operators, allowing for comparison and addition of two `SparsePauilOp`s.\n",
+    "- `collect_pauli_terms` adds up the coefficients of identical Pauli strings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# multiplication table of two Pauli matrices\n",
+    "# weight (imaginary), pauli_c = pauli_a * pauli_b\n",
+    "pauli_mult_table: list[list[Tuple[int, int]]] = [\n",
+    "    [(+0, Pauli.I), (+0, Pauli.X), (+0, Pauli.Y), (+0, Pauli.Z)],\n",
+    "    [(+0, Pauli.X), (+0, Pauli.I), (+1, Pauli.Z), (-1, Pauli.Y)],\n",
+    "    [(+0, Pauli.Y), (-1, Pauli.Z), (+0, Pauli.I), (+1, Pauli.X)],\n",
+    "    [(+0, Pauli.Z), (+1, Pauli.Y), (-1, Pauli.X), (+0, Pauli.I)],\n",
+    "]\n",
+    "\n",
+    "\n",
+    "def sorted_pauli_term(term: SparsePauliTerm) -> SparsePauliTerm:\n",
+    "    \"\"\"\n",
+    "    Sort Pauli terms according to the qubit's index, e.g.,\n",
+    "    Pauli.X(2)*Pauli.Z(7)*Pauli.X(4) ==> Pauli.X(2)*Pauli.X(4)*Pauli.Z(7)\n",
+    "    \"\"\"\n",
+    "    sorted_paulis = sorted(term.paulis, key=lambda p: p.index)\n",
+    "    return SparsePauliTerm(sorted_paulis, term.coefficient)\n",
+    "\n",
+    "\n",
+    "def commutator(ha: SparsePauliOp, hb: SparsePauliOp) -> SparsePauliOp:\n",
+    "    \"\"\"\n",
+    "    Compute the commutator [ha, hb] = ha*hb - hb*ha, where ha and hb are SparsePauliOp objects.\n",
+    "    Returns a SparsePauliOp representing the commutator.\n",
+    "    \"\"\"\n",
+    "    n = max(ha.num_qubits, hb.num_qubits)\n",
+    "    commutation = SparsePauliOp([], n)\n",
+    "\n",
+    "    for sp_term_a in ha.terms:\n",
+    "        for sp_term_b in hb.terms:\n",
+    "            parity = 1\n",
+    "            coefficient = 1.0\n",
+    "            msp = {p.index: p.pauli for p in sp_term_a.paulis}\n",
+    "            for p in sp_term_b.paulis:\n",
+    "                pauli_a = msp.get(p.index, Pauli.I)\n",
+    "                pauli_b = p.pauli\n",
+    "                weight, pauli = pauli_mult_table[pauli_a][pauli_b]\n",
+    "                if weight != 0:\n",
+    "                    parity = -parity\n",
+    "                    coefficient *= weight * 1j\n",
+    "                msp[p.index] = pauli\n",
+    "            # reconstruct pauli_string\n",
+    "            if parity != 1:\n",
+    "                # consider filtering identity terms, making sure the term is not empty\n",
+    "                pauli_term = (reduce(mul, (p(idx) for idx, p in msp.items()))).terms[0]\n",
+    "                pauli_term.coefficient = (\n",
+    "                    sp_term_a.coefficient * sp_term_b.coefficient * coefficient * 2\n",
+    "                )\n",
+    "                commutation.terms.append(pauli_term)\n",
+    "    return commutation\n",
+    "\n",
+    "\n",
+    "def normalize_pauli_term(spt: SparsePauliTerm, num_qubits=-1) -> SparsePauliTerm:\n",
+    "    \"\"\"\n",
+    "    Remove redundant Pauli.I operators from a Pauli string\n",
+    "    making \"normalized\" strings comparable\n",
+    "    if num_qubits is set, an optional Pauli.I is added to ensure the length\n",
+    "    \"\"\"\n",
+    "    if not spt.paulis:\n",
+    "        return spt\n",
+    "\n",
+    "    npt = sorted_pauli_term(spt)\n",
+    "\n",
+    "    paulis = []\n",
+    "    max_index = max_identity_index = -1\n",
+    "    if num_qubits > 0:\n",
+    "        max_identity_index = num_qubits - 1\n",
+    "    for ip in npt.paulis:\n",
+    "        if ip.pauli != Pauli.I:\n",
+    "            paulis.append(ip)\n",
+    "            max_index = max(max_index, int(ip.index))\n",
+    "        else:\n",
+    "            max_identity_index = max(max_identity_index, int(ip.index))\n",
+    "\n",
+    "    if max_identity_index > max_index:\n",
+    "        paulis.append(IndexedPauli(Pauli.I, max_identity_index))\n",
+    "\n",
+    "    npt.paulis = paulis\n",
+    "    return npt\n",
+    "\n",
+    "\n",
+    "def collect_pauli_terms(spo: SparsePauliOp) -> SparsePauliOp:\n",
+    "    \"\"\"\n",
+    "    Collect the coefficient of identical Pauli strings\n",
+    "    for example: 1.5*\"IXZI\"-0.3*\"IXXZ\"+0.4*\"IXZI\", would result, in:\n",
+    "    1.9*\"IXZI\"-0.3*\"IXXZ\".\n",
+    "    The function correctly ignores \"I\" when comparing strings, and sets the correct `num_qubits`\n",
+    "    terms with abs(coefficient)<TOLERANCE are dropped\n",
+    "    \"\"\"\n",
+    "    TOLERANCE: Final[float] = 1e-10\n",
+    "    pauliterms = {}\n",
+    "    for term in spo.terms:\n",
+    "        npt = normalize_pauli_term(term, spo.num_qubits)\n",
+    "        key = tuple((ip.pauli, int(ip.index)) for ip in npt.paulis)\n",
+    "        pauliterms[key] = pauliterms.get(key, 0) + term.coefficient\n",
+    "\n",
+    "    def single_qubit_op(pair: tuple[int, int]) -> SparsePauliOp:\n",
+    "        p_int, idx = pair\n",
+    "        term = SparsePauliTerm([IndexedPauli(Pauli(p_int), idx)], 1.0)\n",
+    "        return SparsePauliOp([term], num_qubits=idx + 1)\n",
+    "\n",
+    "    paulistrings = []\n",
+    "    for key, coeff in pauliterms.items():\n",
+    "        if np.abs(coeff) < TOLERANCE:\n",
+    "            continue\n",
+    "        key_op = reduce(mul, (single_qubit_op(pair) for pair in key))\n",
+    "        paulistrings.append(coeff * key_op)\n",
+    "\n",
+    "    if not paulistrings:\n",
+    "        return SparsePauliOp([], spo.num_qubits)\n",
+    "\n",
+    "    # Sum all strings\n",
+    "    return reduce(add, paulistrings)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
+   "source": [
+    "Next, we define the `grad_energy` function, which receives an operator, `op`, and Hamiltonian, `hamiltonian`, as `SpasePauilOp`s, and evaluates the absolute value of the expectation value of the commutation relation $\\nabla_{\\vec{\\theta}} E_j=i\\langle\\psi^{(k)}|[H,O_j] |\\psi^{(k)}\\rangle~~,$ with respect to an execution session `es` and optimization parameters `params`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def grad_energy(\n",
+    "    op: SparsePauliOp,\n",
+    "    hamiltonian: SparsePauliOp,\n",
+    "    es: ExecutionSession,\n",
+    "    params: list[float],\n",
+    "    isFirstIteration: bool,\n",
+    ") -> float:\n",
+    "    h_op_comm = -1j * commutator(hamiltonian, op)\n",
+    "    if isFirstIteration:\n",
+    "        return es.estimate(h_op_comm).value\n",
+    "    return es.estimate(h_op_comm, {\"params\": params}).value"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12",
+   "metadata": {},
+   "source": [
+    "### Defining the Example System and Operator Pool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hamiltonian\n",
+    "HAMILTONIAN = (\n",
+    "    -0.1 * Pauli.Z(0) * Pauli.Z(1)\n",
+    "    + 0.2 * Pauli.X(0)\n",
+    "    - 0.3 * Pauli.Z(1) * Pauli.Z(2)\n",
+    "    + 0.4 * Pauli.Z(1)\n",
+    "    - 0.1 * Pauli.Y(2) * Pauli.Z(3)\n",
+    "    + 0.2 * Pauli.Y(2)\n",
+    "    - 0.5 * Pauli.X(2) * Pauli.Z(3)\n",
+    "    + 0.2 * Pauli.Z(3)\n",
+    "    - 0.1 * Pauli.Y(1)\n",
+    "    + 0.3 * Pauli.I(0)\n",
+    ")\n",
+    "\n",
+    "NUM_QUBITS = 4\n",
+    "\n",
+    "# operators\n",
+    "single_x_ops = [Pauli.X(i) for i in range(4)]\n",
+    "single_y_ops = [Pauli.Y(i) for i in range(4)]\n",
+    "single_z_ops = [Pauli.Z(i) for i in range(4)]\n",
+    "xx_ops = [Pauli.X(i) * Pauli.X(j) for i in range(4) for j in range(4) if i != j]\n",
+    "yy_ops = [Pauli.Y(i) * Pauli.Y(j) for i in range(4) for j in range(4) if i != j]\n",
+    "zx_ops = [Pauli.Z(i) * Pauli.X(j) for i in range(4) for j in range(4) if i != j]\n",
+    "yx_ops = [Pauli.Y(i) * Pauli.X(j) for i in range(4) for j in range(4) if i != j]\n",
+    "\n",
+    "\n",
+    "# operator pool\n",
+    "op_pool = single_x_ops + single_y_ops + xx_ops + yy_ops + zx_ops + yx_ops\n",
+    "\n",
+    "# Ground state energy\n",
+    "Hamiltonian_matrix = hamiltonian_to_matrix(HAMILTONIAN)\n",
+    "eigvals, eigvecs = np.linalg.eig(Hamiltonian_matrix)\n",
+    "ground_state_energy = np.real(np.min(eigvals))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "14",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ground state energy: -1.189380715792109\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Ground state energy: {ground_state_energy}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15",
+   "metadata": {},
+   "source": [
+    "### Main program\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Before defining the ADAPT-VQE main function, we first define the `adapt_vqe_ansatz` function, which prepares the product state of phases, $|\\psi^{\\text{ADAPT}}(\\vec{\\theta})) \\rangle = \\Pi_{n=1}^{K} e^{-i\\theta_k A_k}|\\psi_{\\text{ref}}\\rangle$, defined by the optimization parameters, `thetas`, and the associated operators of the operator pool, $\\cal O$.\n",
+    "The function builds the state, phase by phase, utilizing a helper function `adapt_layer`. \n",
+    "The reference state is taken to be $$|\\psi_{\\text{ref}}\\rangle=|0^n \\rangle~~,$$ where $n=4$ is the number of qubits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@qfunc\n",
+    "def adapt_layer(idx: int, theta: CReal, qba: QArray):\n",
+    "    suzuki_trotter(op_pool[idx], theta, 1, 1, qba)\n",
+    "\n",
+    "\n",
+    "@qfunc\n",
+    "def adapt_vqe_ansatz(\n",
+    "    thetas: CArray[CReal],\n",
+    "    ansatz_ops: List[int],\n",
+    "    qba: QArray,\n",
+    "):\n",
+    "    n = thetas.len\n",
+    "    for i in range(n):\n",
+    "        adapt_layer(ansatz_ops_indicies[i], thetas[i], qba)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18",
+   "metadata": {},
+   "source": [
+    "In order to obtain accurate evaluations of the observables and obtain deterministic results, we execute the quantum program on a state vector simulator. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "19",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "execution_preferences = ExecutionPreferences(\n",
+    "    backend_preferences=ClassiqBackendPreferences(\n",
+    "        backend_name=ClassiqSimulatorBackendNames.SIMULATOR_STATEVECTOR\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20",
+   "metadata": {},
+   "source": [
+    "Following the algorithm steps, the main ADAPT-VQE performs an iterative calculation, each time adding another phase to the ansatz, thereby increasing the ansatz length, `k`, (starting from $k=1$) until the gradient converges and satisfies $|\\nabla E|/k <$`tol`. If the procedure does not converge, we limit the number of iterations by `MAX_ITERATIONS`.\n",
+    "\n",
+    "Each iteration begins with a preparation of the ansatz state $\\Pi_{k=1}^{K} e^{-i\\theta_k A_k}|\\psi_{\\text{ref}}\\rangle$ for the current $K$. The state preparation is performed by the first `main` quantum function, the quantum circuit is synthesized, and the optimization parameters are optimized by the `es` execution call and saved as a Python list in `params`. The `params` parameters, along with the operators represented by the associated operator indices stored in the `ansatz_ops`, completely define the ansatz state. \n",
+    "\n",
+    "Finally, the elements of the gradient, $\\nabla_{\\vec{\\theta}}E$, are evaluated by the execution call using the `grad_energy` function. A convergence check is made; if the ansatz state converged or the number of iterations exceeds the limit, the iterative procedure is terminated; otherwise, the iteration cycle continues.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1 completed; selected operator index: 6; partial derivative: -1.0;  current energy: 0.5\n",
+      "Iteration 2 completed; selected operator index: 6; partial derivative: -0.9999399950001001;  current energy: 0.21690481532906059\n",
+      "Iteration 3 completed; selected operator index: 39; partial derivative: -0.1987502812343046;  current energy: 0.21690482371265463\n",
+      "Iteration 4 completed; selected operator index: 20; partial derivative: -0.18783601422763072;  current energy: -0.38461421370076104\n",
+      "Iteration 5 completed; selected operator index: 45; partial derivative: -0.1488457198127166;  current energy: -0.584353693801049\n",
+      "Iteration 6 completed; selected operator index: 6; partial derivative: -0.7058905898639278;  current energy: -0.6468182838487597\n",
+      "Iteration 7 completed; selected operator index: 50; partial derivative: -0.7628700586126583;  current energy: -0.7064952091448862\n",
+      "Iteration 8 completed; selected operator index: 6; partial derivative: -1.0591603104849427;  current energy: -0.5143836023499864\n",
+      "Iteration 9 completed; selected operator index: 50; partial derivative: -0.46278789280498533;  current energy: -0.6629077394236031\n",
+      "Iteration 10 completed; selected operator index: 6; partial derivative: -0.5210529087183913;  current energy: -0.707848681231239\n",
+      "Reached maximum number of iterations\n"
+     ]
+    }
+   ],
+   "source": [
+    "# maximum number of iterations\n",
+    "MAX_ITERATIONS = 10\n",
+    "\n",
+    "ansatz_ops_indicies: list[int] = []\n",
+    "\n",
+    "# stores the gradient norms\n",
+    "gradient_norms = []\n",
+    "\n",
+    "# stores the optimized parameters in each iteration\n",
+    "params_history = []\n",
+    "\n",
+    "# ansatz state energy\n",
+    "energies = []\n",
+    "\n",
+    "# circuit depths and widths\n",
+    "circuit_depths = []\n",
+    "circuit_widths = []\n",
+    "\n",
+    "# gradient norm tolerance for stopping criterion\n",
+    "tol: Final[float] = 0.001\n",
+    "\n",
+    "isFirstIteration = True\n",
+    "K = 0\n",
+    "\n",
+    "\n",
+    "for i in range(MAX_ITERATIONS):  # loop until gradient norm exceeds tolerance\n",
+    "    # (break-ing out of the loop) or the maximum number of iterations is reached\n",
+    "    # number of layers\n",
+    "\n",
+    "    ## compute gradients of operator pool elements\n",
+    "    @qfunc\n",
+    "    def main(\n",
+    "        params: CArray[CReal, K],\n",
+    "        v: Output[QArray[QBit, NUM_QUBITS]],  # type: ignore\n",
+    "    ):\n",
+    "        allocate(v)\n",
+    "        # build the ansatz state only from the second iteration, otherwise return the reference state\n",
+    "        if i > 0:\n",
+    "            adapt_vqe_ansatz(params, ansatz_ops_indicies, v)\n",
+    "\n",
+    "    if i == 0:\n",
+    "        params = 0\n",
+    "\n",
+    "    qprog_grads = synthesize(main)\n",
+    "\n",
+    "    with ExecutionSession(qprog_grads, execution_preferences) as es:\n",
+    "        gradients = np.array(\n",
+    "            [\n",
+    "                grad_energy(mp, HAMILTONIAN, es, params, isFirstIteration)\n",
+    "                for mp in op_pool\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "    isFirstIteration = False\n",
+    "\n",
+    "    # evaluate the scaled gradient norm\n",
+    "    scaled_gradient_norm = np.linalg.norm(gradients) / len(gradients)\n",
+    "    gradient_norms.append(scaled_gradient_norm)\n",
+    "    g_idx = np.argmin(gradients)\n",
+    "    ansatz_ops_indicies.append(g_idx)\n",
+    "\n",
+    "    @qfunc\n",
+    "    def main(params: CArray[CReal, K], v: Output[QArray[QBit, NUM_QUBITS]]):\n",
+    "        allocate(v)\n",
+    "        adapt_vqe_ansatz(params, ansatz_ops_indicies, v)\n",
+    "\n",
+    "    qprog = synthesize(main)\n",
+    "\n",
+    "    circuit_widths.append(qprog.data.width)\n",
+    "    circuit_depths.append(qprog.transpiled_circuit.depth)\n",
+    "\n",
+    "    K = len(ansatz_ops_indicies)\n",
+    "    # initial optimization parameters for the VQE re-optimization\n",
+    "    initial_params = np.linspace(0, 1, K).tolist()\n",
+    "    with ExecutionSession(qprog, execution_preferences) as es:\n",
+    "        optimization_results = es.minimize(\n",
+    "            cost_function=HAMILTONIAN,  # Hamiltonian problem\n",
+    "            initial_params={\"params\": initial_params},\n",
+    "            max_iteration=100,\n",
+    "        )\n",
+    "    params = optimization_results[-1][1][\"params\"]\n",
+    "    params_history.append(params)\n",
+    "\n",
+    "    energy = optimization_results[-1][0]\n",
+    "    energies.append(energy)\n",
+    "\n",
+    "    print(\n",
+    "        f\"Iteration {i+1} completed; selected operator index: {g_idx}; partial derivative: {np.real(gradients[g_idx])};  current energy: {energy}\"\n",
+    "    )\n",
+    "\n",
+    "    # convergence check\n",
+    "    positive_gradient = np.all(gradients >= 0)\n",
+    "    if scaled_gradient_norm < tol:\n",
+    "        print(f\"Gradient converged\")\n",
+    "        break\n",
+    "    elif i == MAX_ITERATIONS - 1:\n",
+    "        print(f\"Reached maximum number of iterations\")\n",
+    "        break\n",
+    "    elif positive_gradient:\n",
+    "        print(f\"Optimization reached a minima\")\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22",
+   "metadata": {},
+   "source": [
+    "## Results and Discussion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23",
+   "metadata": {},
+   "source": [
+    "Optimized ansatz summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "24",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimized parameters: [ 0.5848  0.4323  1.5439 -0.0094  0.8553  0.5134  1.7361  0.6801  0.7741\n",
+      "  0.9886]\n",
+      "Optimized energy: -0.707848681231239\n",
+      "Error: 40.5%\n"
+     ]
+    }
+   ],
+   "source": [
+    "min_energy_idx = np.argmin(np.array(energies))\n",
+    "optimal_energy_adapt_vqe = energies[min_energy_idx]\n",
+    "optimized_parameters_adapt_vqe = params_history[min_energy_idx]\n",
+    "optimized_op_idxs = ansatz_ops_indicies[: (min_energy_idx + 1)]\n",
+    "print(f\"Optimized parameters: {np.round(optimized_parameters_adapt_vqe,4)}\")\n",
+    "print(f\"Optimized energy: {energies[min_energy_idx]}\")\n",
+    "error_adapt_vqe = abs(\n",
+    "    100 * (optimal_energy_adapt_vqe - ground_state_energy) / ground_state_energy\n",
+    ")\n",
+    "print(f\"Error: {np.round(error_adapt_vqe,1)}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25",
+   "metadata": {},
+   "source": [
+    "### Energy graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "26",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(energies, label=\"ansatz state\")\n",
+    "plt.plot(np.array(len(energies) * [ground_state_energy]), label=\"ground state energy\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Energy\")\n",
+    "plt.title(\"Ansatz State Energy\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "27",
+   "metadata": {},
+   "source": [
+    "### Convergence graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(gradient_norms, label=\"gradient norm\")\n",
+    "plt.plot(np.array(len(gradient_norms) * [tol]), label=\"tolerance\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Gradient norm\")\n",
+    "plt.title(\"Gradient norm convergence\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29",
+   "metadata": {},
+   "source": [
+    "### Circuit Information"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30",
+   "metadata": {},
+   "source": [
+    "The circuit width and depth are:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "31",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "circuit width: 4\n",
+      "circuit depth: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "# circuit width\n",
+    "print(f\"circuit width: {circuit_widths[min_energy_idx]}\")\n",
+    "# circuit depth\n",
+    "print(f\"circuit depth: {circuit_widths[min_energy_idx]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32",
+   "metadata": {},
+   "source": [
+    "### Summary ADAPT-VQE Ansatz\n",
+    "For the chosen operator pool and classical optimization algorithm, the optimal ansatz state has $10$ parameters converged to a result $E_{\\text{min}}= -0.707848681231239 $ The ansatz operators, indexed by their associated index in the operator pool: $[6,6,39,20,45,6,50,6,50,6]$.\n",
+    "\n",
+    "The optimization parameters are: $$ \\vec{\\theta} = [0.5848  0.4323  1.5439 -0.0094  0.8553  0.5134  1.7361  0.6801  0.7741\n",
+    "  0.9886]^T~~,$$ \n",
+    "\n",
+    "The ansatz state can be constructed with a quantum circuit with a circuit width of $4$ and circuit depth of $4$.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33",
+   "metadata": {},
+   "source": [
+    "## Modified ADAPT-VQE Ansatz\n",
+    "\n",
+    "We provide a modified version of the algorithm, where the algorithm starts with a pre-optimization with respect to a chosen operator.\n",
+    "The algorithm showed improved results for the considered Hamiltonian and operator pool."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "34",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration 1 completed; selected operator index: 2; partial derivative: -0.5999999962884589;  current energy: 0.3000000018557699\n",
+      "Iteration 2 completed; selected operator index: 4; partial derivative: -0.3999999999998979;  current energy: 0.17573593351317066\n",
+      "Iteration 3 completed; selected operator index: 50; partial derivative: -0.6325932167777434;  current energy: -0.14787085528494587\n",
+      "Iteration 4 completed; selected operator index: 42; partial derivative: -0.19999999893498477;  current energy: -0.3580880911310245\n",
+      "Iteration 5 completed; selected operator index: 45; partial derivative: -0.19352465309641967;  current energy: -1.1671907029792876\n",
+      "Iteration 6 completed; selected operator index: 39; partial derivative: -0.4118947318009357;  current energy: -1.091179784345635\n",
+      "Iteration 7 completed; selected operator index: 21; partial derivative: -0.17398470514855552;  current energy: -1.1804771751890988\n",
+      "Iteration 8 completed; selected operator index: 51; partial derivative: -0.36752952620020923;  current energy: -0.9960267166185478\n",
+      "Iteration 9 completed; selected operator index: 4; partial derivative: -0.2149596926385491;  current energy: -1.1377253083959993\n",
+      "Iteration 10 completed; selected operator index: 4; partial derivative: 0.0101716932596762; current energy: -0.993454636616868\n",
+      "Reacheck maximum number of iterations\n"
+     ]
+    }
+   ],
+   "source": [
+    "# maximum number of iterations\n",
+    "MAX_ITERATIONS = 10\n",
+    "\n",
+    "ansatz_ops_indicies: list[int] = []\n",
+    "# start with default parameter\n",
+    "ansatz_ops_indicies.append(10)\n",
+    "# stores the gradient norms\n",
+    "gradient_norms = []\n",
+    "\n",
+    "# stores the minimal gradient element in each step\n",
+    "picked_derivatives = []\n",
+    "\n",
+    "# ansatz state energy\n",
+    "energies = []\n",
+    "\n",
+    "# parameter history\n",
+    "params_history = []\n",
+    "\n",
+    "# circuit depths and widths\n",
+    "circuit_depths = []\n",
+    "circuit_widths = []\n",
+    "\n",
+    "# gradient norm tolerance for stopping criterion\n",
+    "tol: Final[float] = 0.001\n",
+    "\n",
+    "# in this variation of the algorithm, there is no need for a special treatment of the first iteration\n",
+    "isFirstIteration = False\n",
+    "for i in range(\n",
+    "    MAX_ITERATIONS\n",
+    "):  # loop until gradient norm exceeds tolerance (break-ing out of the loop)\n",
+    "\n",
+    "    # number of layers (initially=1)\n",
+    "    K = len(ansatz_ops_indicies)\n",
+    "\n",
+    "    # trace and history for analysis and plotting\n",
+    "    @qfunc\n",
+    "    def main(params: CArray[CReal, K], v: Output[QArray[QBit, NUM_QUBITS]]):\n",
+    "        allocate(v)\n",
+    "        adapt_vqe_ansatz(params, ansatz_ops_indicies, v)\n",
+    "\n",
+    "    qprog = synthesize(main)\n",
+    "    circuit_widths.append(qprog.data.width)\n",
+    "    circuit_depths.append(qprog.transpiled_circuit.depth)\n",
+    "\n",
+    "    # initial optimization parameters for the VQE re-optimization\n",
+    "\n",
+    "    initial_params = np.linspace(0, 1, K).tolist()\n",
+    "    with ExecutionSession(qprog, execution_preferences) as es:\n",
+    "        optimization_results = es.minimize(\n",
+    "            cost_function=HAMILTONIAN,  # Hamiltonian problem\n",
+    "            initial_params={\"params\": initial_params},\n",
+    "            max_iteration=100,\n",
+    "        )\n",
+    "\n",
+    "    params = optimization_results[-1][1][\"params\"]\n",
+    "    params_history.append(params)\n",
+    "    energy = optimization_results[-1][0]\n",
+    "    energies.append(energy)\n",
+    "\n",
+    "    ## Compute gradients of operator pool elements\n",
+    "    @qfunc\n",
+    "    def main(\n",
+    "        params: CArray[CReal, K],\n",
+    "        v: Output[QArray[QBit, NUM_QUBITS]],  # type: ignore\n",
+    "    ):\n",
+    "        allocate(v)\n",
+    "        adapt_vqe_ansatz(params, ansatz_ops_indicies, v)\n",
+    "\n",
+    "    qprog_grads = synthesize(main)\n",
+    "\n",
+    "    with ExecutionSession(qprog_grads, execution_preferences) as es:\n",
+    "        gradients = np.array(\n",
+    "            [\n",
+    "                grad_energy(mp, HAMILTONIAN, es, params, isFirstIteration)\n",
+    "                for mp in op_pool\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "    # evaluate the scaled gradient norm\n",
+    "    scaled_gradient_norm = np.linalg.norm(gradients) / len(gradients)\n",
+    "    gradient_norms.append(scaled_gradient_norm)\n",
+    "\n",
+    "    # convergence check\n",
+    "    if scaled_gradient_norm < tol:\n",
+    "        print(f\"Gradient converged\")\n",
+    "        break\n",
+    "    elif i == MAX_ITERATIONS - 1:\n",
+    "        print(\n",
+    "            f\"Iteration {i+1} completed; selected operator index: {g_idx}; partial derivative: {np.real(gradients[g_idx])}; current energy: {energy}\"\n",
+    "        )\n",
+    "        print(f\"Reacheck maximum number of iterations\")\n",
+    "        break\n",
+    "\n",
+    "    positive_gradient = np.all(gradients >= 0)\n",
+    "    if positive_gradient:\n",
+    "        print(f\"Optimization reached a minima\")\n",
+    "        break\n",
+    "\n",
+    "    g_idx = np.argmin(gradients)\n",
+    "    picked_derivatives.append(gradients[g_idx])\n",
+    "    print(\n",
+    "        f\"Iteration {i+1} completed; selected operator index: {g_idx}; partial derivative: {np.real(gradients[g_idx])};  current energy: {energy}\"\n",
+    "    )\n",
+    "\n",
+    "    ansatz_ops_indicies.append(g_idx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35",
+   "metadata": {},
+   "source": [
+    "## Results and Discussion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36",
+   "metadata": {},
+   "source": [
+    "Ansatz state summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "37",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Optimized parameters: [ 1.5757  1.8084  0.7077  0.5244 -0.1062 -0.1099  1.5939]\n",
+      "Optimized energy: -1.1804771751890988\n",
+      "Error: 0.7485862587809506%\n"
+     ]
+    }
+   ],
+   "source": [
+    "min_energy_idx = np.argmin(np.array(energies))\n",
+    "optimal_energy_modified_adapt_vqe = energies[min_energy_idx]\n",
+    "optimized_parameters_modified_adapt_vqe = params_history[min_energy_idx]\n",
+    "optimized_op_idxs = ansatz_ops_indicies[: (min_energy_idx + 1)]\n",
+    "print(f\"Optimized parameters: {np.round(optimized_parameters_modified_adapt_vqe,4)}\")\n",
+    "print(f\"Optimized energy: {optimal_energy_modified_adapt_vqe}\")\n",
+    "error_modified_adapt_vqe = abs(\n",
+    "    100\n",
+    "    * (optimal_energy_modified_adapt_vqe - ground_state_energy)\n",
+    "    / ground_state_energy\n",
+    ")\n",
+    "print(f\"Error: {error_modified_adapt_vqe}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "38",
+   "metadata": {},
+   "source": [
+    "### Energy graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "39",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(energies, label=\"ansatz state\")\n",
+    "plt.plot(np.array(len(energies) * [ground_state_energy]), label=\"ground state energy\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Energy\")\n",
+    "plt.title(\"Ansatz State Energy\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40",
+   "metadata": {},
+   "source": [
+    "### Convergence graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "41",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(gradient_norms, label=\"gradient norm\")\n",
+    "plt.plot(np.array(len(gradient_norms) * [tol]), label=\"tolerance\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Gradient norm\")\n",
+    "plt.title(\"Gradient norm convergence\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42",
+   "metadata": {},
+   "source": [
+    "### Circuit Information"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43",
+   "metadata": {},
+   "source": [
+    "The circuit width and depth are:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "44",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "circuit width: 4\n",
+      "circuit depth: 19\n"
+     ]
+    }
+   ],
+   "source": [
+    "# circuit width\n",
+    "print(f\"circuit width: {circuit_widths[min_energy_idx]}\")\n",
+    "# circuit depth\n",
+    "print(f\"circuit depth: {circuit_depths[min_energy_idx]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45",
+   "metadata": {},
+   "source": [
+    "### Summary Modified ADAPT-VQE Ansatz\n",
+    "For the chosen operator pool and classical optimization algorithm, the optimal ansatz state has $7$ parameters converged to a result $E_{\\text{min}}=-1.1804771$ The ansatz operators, indexed by their associated index in the operator pool:\n",
+    "$[2,4,50,42,45,39,21]$.\n",
+    "\n",
+    "The optimization parameters are: $$ \\vec{\\theta} = [1.5757  1.8084  0.7077  0.5244 -0.1062 -0.1099  1.5939]^T~~,$$ \n",
+    "\n",
+    "The ansatz state can be constructed with a quantum circuit with a circuit width of $4$ and circuit depth of $19$.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46",
+   "metadata": {},
+   "source": [
+    "## Comparison to the VQE algorithm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47",
+   "metadata": {},
+   "source": [
+    "We now validate the results of the ADAPT-VQE by comparing them to the outcome of the standard VQE algorithm with ten optimization parameters ($K=10$), and picking the operator pool as the first ten even indices (the choice is arbitrary and independent of the Hamiltonian). We fix the ansatz state by considering a product form of phases, $$|\\psi_{\\text{VQE}}\\rangle = \\Pi_{k=1}^{K} e^{-i \\theta_k O_k}|0^n\\rangle~~,$$ where $n=4$, for the presented test case. The operators $\\{O_k\\}$ are determined by their operator pool indices in `vqe_ansatz_ops_indicies` and the associated parameters $\\{\\theta_k\\}$ are optimized by applying the VQE algorithm.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "48",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VQE minimal energy: -0.9681640625\n",
+      "VQE optimized thetas: [1.536, -0.564, 1.271, 0.144, 1.94, 1.511, -0.215, -0.062, -0.391, 0.855]\n",
+      "error: -18.59931394169126%\n"
+     ]
+    }
+   ],
+   "source": [
+    "K = 10\n",
+    "modular_range = [i * 2 % len(op_pool) for i in range(K)]\n",
+    "modular_range = [0] + modular_range\n",
+    "vqe_ansatz_ops_indicies = modular_range\n",
+    "\n",
+    "\n",
+    "@qfunc\n",
+    "def main(params: CArray[CReal, K], v: Output[QArray[QBit, NUM_QUBITS]]):\n",
+    "    allocate(v)\n",
+    "    n = params.len\n",
+    "    adapt_vqe_ansatz(params, vqe_ansatz_ops_indicies, v)\n",
+    "\n",
+    "\n",
+    "qprog_vqe = synthesize(main)\n",
+    "write_qmod(main, name=\"vqe\", decimal_precision=15, symbolic_only=False)\n",
+    "\n",
+    "\n",
+    "with ExecutionSession(qprog_vqe) as es:\n",
+    "    vqe_optimization_results = es.minimize(\n",
+    "        cost_function=HAMILTONIAN,  # Hamiltonian problem\n",
+    "        initial_params={\"params\": [0] * K},\n",
+    "        max_iteration=100,\n",
+    "    )\n",
+    "\n",
+    "vqe_minimal_energy = vqe_optimization_results[-1][0]\n",
+    "print(f\"VQE minimal energy: {vqe_minimal_energy}\")\n",
+    "\n",
+    "# optimized thetas (rounded)\n",
+    "vqe_optimized_thetas = [vqe_optimization_results[-1][1][\"params\"]][0]\n",
+    "vqe_rounded_thetas = [\n",
+    "    round(vqe_optimized_thetas[i], 3) for i in range(len(vqe_optimized_thetas))\n",
+    "]\n",
+    "print(f\"VQE optimized thetas: {vqe_rounded_thetas}\")\n",
+    "print(\n",
+    "    f\"error: {abs(100*(vqe_minimal_energy-ground_state_energy)/ground_state_energy)}%\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "49",
+   "metadata": {},
+   "source": [
+    "### Circuit Information"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "50",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "circuit width: 4\n",
+      "circuit depth: 26\n"
+     ]
+    }
+   ],
+   "source": [
+    "# circuit width\n",
+    "print(f\"circuit width: {qprog_vqe.data.width}\")\n",
+    "# circuit depth\n",
+    "print(f\"circuit depth: {qprog_vqe.transpiled_circuit.depth}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "51",
+   "metadata": {},
+   "source": [
+    "### Summary VQE Ansatz\n",
+    "The VQE ansatz is characterized by:\n",
+    "\n",
+    "Optimized optimization parameters:  $$\\vec{\\theta} = [1.536, -0.564, 1.271, 0.144, 1.94, 1.511, -0.215, -0.062, -0.391, 0.855]^T$$\n",
+    "\n",
+    "The ansatz operators are originally set (an arbitrary choice):  $[0,2,4,6,8,10,12,14,16,18]$.\n",
+    "\n",
+    "and minimal energy $\\langle\\psi^{\\text{VQE}}|H |\\psi^{\\text{VQE}}\\rangle$: $-0.96816$.\n",
+    "\n",
+    "The ansatz state can be constructed with a quantum circuit with a circuit width of $4$ and circuit depth of $26$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52",
+   "metadata": {},
+   "source": [
+    "## Analysis and Summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53",
+   "metadata": {},
+   "source": [
+    "By comparing the results obtained with ADAPT-VQE, modified ADAPT-VQE and standard VQE, and exact diagonalization, we observe that for an equal number of variational parameters, modified ADAPT-VQE converges to an ansatz that yields a more accurate estimate of the ground-state energy, \n",
+    "$E_{\\text{g.s}}=  -1.189380715792109$. Specifically, modified ADAPT-VQE achieves an energy within approximately \n",
+    "$~0.7$% of the exact value. In contrast, the original ADAPT-VQE achieves a minimal energy which is $40$% above the true ground state energy. The VQE ansatz—whose operator structure is chosen independently of the Hamiltonian—converges to an optimal energy that remains $18.6$% above the true ground-state energy.\n",
+    "\n",
+    "The result highlights the potential of an ADAPT-VQE type ansatz, which is constructed iteratively based on the energy gradient, that is directly determined by the Hamiltonian under consideration.  As a consequence, only operators that most effectively lower the energy are included in the ansatz, leading to faster and more accurate convergence. The ADAPT-VQE achieves a better accuracy, with a smaller circuit depth ($4$ and $19$ compared to $26$ for the VQE). This contrasts with a general, Hamiltonian-independent ansatz, which lacks such targeted optimization and therefore exhibits inferior convergence performance and tends to require larger circuit depths to achieve the same accuracy.\n",
+    "Importantly, the large difference between the two variations of ADAPT-VQE proposed showcases that the algorithm doesn't guarantee better results. A clever choice of the operator pool and the initial state can potentially greatly improve the algorithm's performance."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54",
+   "metadata": {},
+   "source": [
+    "## References"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55",
+   "metadata": {},
+   "source": [
+    "<a id='ADAPT-VQE'>[1]</a>: [Grimsley, H. R., Economou, S. E., Barnes, E., & Mayhall, N. J. (2019). An adaptive variational algorithm for exact molecular simulations on a quantum computer. Nature communications, 10(1), 3007.](https://arxiv.org/abs/1812.11173)\n",
+    "\n",
+    "<a id='VQE'>[2]</a>: [Tilly, J., Chen, H., Cao, S., Picozzi, D., Setia, K., Li, Y., ... & Tennyson, J. (2022). The variational quantum eigensolver: a review of methods and best practices. Physics Reports, 986, 1-128.](https://arxiv.org/abs/2111.05176)"
+   ]
+  }
+ ],
+ "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": 9
+}
diff --git a/algorithms/adapt_vqe/adapt_vqe.metadata.json b/algorithms/adapt_vqe/adapt_vqe.metadata.json
new file mode 100644
index 000000000..802ecc1f4
--- /dev/null
+++ b/algorithms/adapt_vqe/adapt_vqe.metadata.json
@@ -0,0 +1,7 @@
+{
+  "friendly_name": "adapt_vqe",
+  "description": "Demonstration of adaptive VQE algorithm",
+  "qmod_type": ["algorithms"],
+  "problem_domain_tags": ["optimization"],
+  "level": ["advanced"]
+}
diff --git a/algorithms/adapt_vqe/adapt_vqe.qmod b/algorithms/adapt_vqe/adapt_vqe.qmod
new file mode 100644
index 000000000..0ba251ca5
--- /dev/null
+++ b/algorithms/adapt_vqe/adapt_vqe.qmod
@@ -0,0 +1,22 @@
+qfunc adapt_layer_expanded___0(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=1, index=0}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=1
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_vqe_ansatz_expanded___0(thetas: real[1], qba: qbit[4]) {
+  adapt_layer_expanded___0(thetas[0], qba);
+}
+
+qfunc main(params: real[1], output v: qbit[4]) {
+  allocate(4, v);
+  adapt_vqe_ansatz_expanded___0(params, v);
+}
diff --git a/algorithms/adapt_vqe/adapt_vqe.synthesis_options.json b/algorithms/adapt_vqe/adapt_vqe.synthesis_options.json
new file mode 100644
index 000000000..8f17d0968
--- /dev/null
+++ b/algorithms/adapt_vqe/adapt_vqe.synthesis_options.json
@@ -0,0 +1,44 @@
+{
+  "constraints": {
+    "max_gate_count": {},
+    "optimization_parameter": "no_opt"
+  },
+  "preferences": {
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "sdg",
+        "s",
+        "ry",
+        "r",
+        "u2",
+        "cx",
+        "y",
+        "p",
+        "id",
+        "cz",
+        "sx",
+        "h",
+        "u1",
+        "t",
+        "z",
+        "cy",
+        "tdg",
+        "u",
+        "x",
+        "rz",
+        "sxdg",
+        "rx"
+      ],
+      "is_symmetric_connectivity": true
+    },
+    "debug_mode": true,
+    "machine_precision": 8,
+    "optimization_level": 1,
+    "output_format": ["qasm"],
+    "pretty_qasm": true,
+    "random_seed": 4279230856,
+    "synthesize_all_separately": false,
+    "timeout_seconds": 300,
+    "transpilation_option": "auto optimize"
+  }
+}
diff --git a/algorithms/adapt_vqe/vqe.qmod b/algorithms/adapt_vqe/vqe.qmod
new file mode 100644
index 000000000..c2e36928b
--- /dev/null
+++ b/algorithms/adapt_vqe/vqe.qmod
@@ -0,0 +1,150 @@
+qfunc adapt_layer_expanded___0(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=1, index=0},
+          IndexedPauli {pauli=1, index=3}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=4
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___1(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=1, index=2}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___2(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=2, index=0}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=1
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___3(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=2, index=2},
+          IndexedPauli {pauli=1, index=0}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___4(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=3, index=3},
+          IndexedPauli {pauli=1, index=1}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=4
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___5(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=2, index=0},
+          IndexedPauli {pauli=1, index=2}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___6(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=3, index=2},
+          IndexedPauli {pauli=1, index=1}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___7(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=2, index=0},
+          IndexedPauli {pauli=2, index=2}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_layer_expanded___8(theta: real, qba: qbit[4]) {
+  suzuki_trotter(SparsePauliOp {
+    terms=[
+      SparsePauliTerm {
+        paulis=[
+          IndexedPauli {pauli=2, index=2},
+          IndexedPauli {pauli=1, index=1}
+        ],
+        coefficient=1.0
+      }
+    ],
+    num_qubits=3
+  }, theta, 1, 1, qba);
+}
+
+qfunc adapt_vqe_ansatz_expanded___0(thetas: real[10], qba: qbit[4]) {
+  adapt_layer_expanded___0(thetas[0], qba);
+  adapt_layer_expanded___1(thetas[1], qba);
+  adapt_layer_expanded___2(thetas[2], qba);
+  adapt_layer_expanded___3(thetas[3], qba);
+  adapt_layer_expanded___4(thetas[4], qba);
+  adapt_layer_expanded___5(thetas[5], qba);
+  adapt_layer_expanded___6(thetas[6], qba);
+  adapt_layer_expanded___7(thetas[7], qba);
+  adapt_layer_expanded___8(thetas[8], qba);
+  adapt_layer_expanded___2(thetas[9], qba);
+}
+
+qfunc main(params: real[10], output v: qbit[4]) {
+  allocate(4, v);
+  adapt_vqe_ansatz_expanded___0(params, v);
+}
diff --git a/algorithms/adapt_vqe/vqe.synthesis_options.json b/algorithms/adapt_vqe/vqe.synthesis_options.json
new file mode 100644
index 000000000..ee5f1f5ff
--- /dev/null
+++ b/algorithms/adapt_vqe/vqe.synthesis_options.json
@@ -0,0 +1,44 @@
+{
+  "constraints": {
+    "max_gate_count": {},
+    "optimization_parameter": "no_opt"
+  },
+  "preferences": {
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "sx",
+        "x",
+        "u",
+        "u2",
+        "rx",
+        "sdg",
+        "r",
+        "id",
+        "cz",
+        "h",
+        "ry",
+        "cx",
+        "p",
+        "tdg",
+        "cy",
+        "u1",
+        "sxdg",
+        "t",
+        "s",
+        "y",
+        "z",
+        "rz"
+      ],
+      "is_symmetric_connectivity": true
+    },
+    "debug_mode": true,
+    "machine_precision": 8,
+    "optimization_level": 1,
+    "output_format": ["qasm"],
+    "pretty_qasm": true,
+    "random_seed": 2960807501,
+    "synthesize_all_separately": false,
+    "timeout_seconds": 300,
+    "transpilation_option": "auto optimize"
+  }
+}
diff --git a/algorithms/qaoa/knapsack/qaoa_knapsack.ipynb b/algorithms/qaoa/knapsack/qaoa_knapsack.ipynb
index fd09135ad..41523191c 100644
--- a/algorithms/qaoa/knapsack/qaoa_knapsack.ipynb
+++ b/algorithms/qaoa/knapsack/qaoa_knapsack.ipynb
@@ -454,7 +454,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.7"
   }
  },
  "nbformat": 4,
diff --git a/tests/notebooks/test_adapt_vqe.py b/tests/notebooks/test_adapt_vqe.py
new file mode 100644
index 000000000..723ce499b
--- /dev/null
+++ b/tests/notebooks/test_adapt_vqe.py
@@ -0,0 +1,19 @@
+from tests.utils_for_testbook import (
+    validate_quantum_program_size,
+    validate_quantum_model,
+    wrap_testbook,
+)
+from testbook.client import TestbookNotebookClient
+
+
+@wrap_testbook("adapt_vqe", timeout_seconds=1800)
+def test_notebook(tb: TestbookNotebookClient) -> None:
+    # test quantum programs
+    validate_quantum_program_size(
+        tb.ref_pydantic("qprog"),
+        expected_width=10,  # actual width=4
+        expected_depth=30,  # actual depth=12
+    )
+
+    # test notebook content
+    pass  # Todo
diff --git a/tests/notebooks/test_basic_test.py b/tests/notebooks/test_basic_test.py
new file mode 100644
index 000000000..58a457895
--- /dev/null
+++ b/tests/notebooks/test_basic_test.py
@@ -0,0 +1,22 @@
+from tests.utils_for_testbook import (
+    validate_quantum_program_size,
+    validate_quantum_model,
+    wrap_testbook,
+)
+from testbook.client import TestbookNotebookClient
+
+
+@wrap_testbook("basic_test", timeout_seconds=60)
+def test_notebook(tb: TestbookNotebookClient) -> None:
+    # test models
+    validate_quantum_model(tb.ref("qmod"))
+    # test quantum programs
+    validate_quantum_program_size(
+        tb.ref_pydantic("qprog"),
+        expected_width=None,
+        expected_depth=None,
+        expected_cx_count=None,
+    )
+
+    # test notebook content
+    pass  # Todo
diff --git a/tests/resources/timeouts.yaml b/tests/resources/timeouts.yaml
index d28779829..4ebb37be0 100644
--- a/tests/resources/timeouts.yaml
+++ b/tests/resources/timeouts.yaml
@@ -18,6 +18,7 @@ U.qmod: 10
 WS_iQuHack_2025_final.ipynb: 200
 X.qmod: 10
 adapt_qaoa.ipynb: 1799
+adapt_vqe.ipynb: 1799
 adapt_qaoa.qmod: 1799
 add_bell_states.qmod: 10
 advection_equation_2nd_place_submission.ipynb: 500