diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
index 35c9acbe74..b206113814 100644
--- a/docs/CMakeLists.txt
+++ b/docs/CMakeLists.txt
@@ -130,18 +130,6 @@ if (CUDAQ_ENABLE_PYTHON)
     endif()
   endfunction()
 
-  add_pycudaq_test(Intro intro.py)
-  add_pycudaq_test(BernsteinVazirani bernstein_vazirani.py)
-  add_pycudaq_test(QAOA qaoa_maxcut.py)
-  add_pycudaq_test(VQE simple_vqe.py)
-  add_pycudaq_test(VQEAdvanced advanced_vqe.py)
-
-  add_pycudaq_test(AmplitudeDampingNoise noise_amplitude_damping.py)
-  add_pycudaq_test(BitFlipNoise noise_bit_flip.py)
-  add_pycudaq_test(DepolarizingNoise noise_depolarization.py)
-  add_pycudaq_test(PhaseFlipNoise noise_phase_flip.py)
-  add_pycudaq_test(KrausNoise noise_kraus_operator.py)
-  
   if (CUTENSORNET_ROOT AND CUDA_FOUND) 
     # This example uses tensornet backend.
     add_pycudaq_test(SampleAsyncRemote using/cudaq/platform/sample_async_remote.py SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/sphinx/snippets/python)
diff --git a/docs/sphinx/examples/building_kernels.ipynb b/docs/sphinx/examples/building_kernels.ipynb
new file mode 100644
index 0000000000..366b9f626f
--- /dev/null
+++ b/docs/sphinx/examples/building_kernels.ipynb
@@ -0,0 +1,420 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "13858fc6-edc7-49cb-8b56-152ebec2f729",
+   "metadata": {},
+   "source": [
+    "# Building Kernels\n",
+    "\n",
+    "This section will cover the most basic CUDA-Q construct, a quantum kernel. Topics include, building kernels, initializing states, and applying gate operations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bb9f7912-cb38-463c-b604-4657848b6f68",
+   "metadata": {},
+   "source": [
+    "### Defining Kernels\n",
+    "\n",
+    "Kernels are the building blocks of quantum algorithms in CUDA-Q. A kernel is specified by using the following syntax. `cudaq.qubit` builds a register consisting of a single qubit, while `cudaq.qvector` builds a register of $N$ qubits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0c312467-3ba7-43fb-b820-d1ee2ced7fc3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "d9af7484-a69b-4239-b8b9-1abb47ee9421",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    A = cudaq.qubit()\n",
+    "    B = cudaq.qvector(3)\n",
+    "    C = cudaq.qvector(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83459bfa-b0b8-4d6b-bb31-2e708da5a30e",
+   "metadata": {},
+   "source": [
+    "Inputs to kernels are defined by specifying a parameter in the kernel definition along with the appropriate type. The kernel below takes an integer to define a register of N qubits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "58af9585-a2c7-4059-983b-670962bdf65c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N = 2\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(N: int):\n",
+    "    register = cudaq.qvector(N)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7866f4c5-4b8c-408b-8980-8ebca60f28b8",
+   "metadata": {},
+   "source": [
+    "### Initializing states\n",
+    "\n",
+    "It is often helpful to define an initial state for a kernel. There are a few ways to do this in CUDA-Q. Note, method 5 is particularly useful for cases where the state of one kernel is passed into a second kernel to prepare its initial state.\n",
+    "\n",
+    "1. Passing complex vectors as parameters\n",
+    "2. Capturing complex vectors\n",
+    "3. Precision-agnostic API\n",
+    "4. Define as CUDA-Q amplitudes\n",
+    "5. Pass in a state from another kernel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "57b5d6c5-b0b7-449d-ac0c-7166e2127c00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Passing complex vectors as parameters\n",
+    "c = [.707 +0j, 0-.707j]\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(vec: list[complex]):\n",
+    "    q = cudaq.qubit(vec)\n",
+    "\n",
+    "\n",
+    "# Capturing complex vectors\n",
+    "c = [0.70710678 + 0j, 0., 0., 0.70710678]\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    q = cudaq.qvector(c)\n",
+    "\n",
+    "\n",
+    "# Precision-Agnostic API\n",
+    "import numpy as np\n",
+    "\n",
+    "c = np.array([0.70710678 + 0j, 0., 0., 0.70710678], dtype=cudaq.complex())\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    q = cudaq.qvector(c)\n",
+    "\n",
+    "# Define as CUDA-Q amplitudes\n",
+    "c = cudaq.amplitudes([0.70710678 + 0j, 0., 0., 0.70710678])\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    q = cudaq.qvector(c)\n",
+    "\n",
+    "# Pass in a state from another kernel\n",
+    "c = [0.70710678 + 0j, 0., 0., 0.70710678]\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel_initial():\n",
+    "    q = cudaq.qvector(c)\n",
+    "\n",
+    "state_to_pass = cudaq.get_state(kernel_initial)\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(state: cudaq.State):\n",
+    "    q = cudaq.qvector(state)\n",
+    "\n",
+    "kernel(state_to_pass)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d5f68d7-80cf-4e2d-861c-7f945e17b6de",
+   "metadata": {},
+   "source": [
+    "### Applying Gates\n",
+    "\n",
+    "\n",
+    "After a kernel is constructed, gates can be applied to start building out a quantum circuit. All the predefined gates in CUDA-Q can be found [here](https://nvidia.github.io/cuda-quantum/latest/api/default_ops.html#unitary-operations-on-qubits).\n",
+    "\n",
+    "\n",
+    "Gates can be applied to all qubits in a register:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "8b93d86d-f6a1-4fb8-9efb-c7039ff4b383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    register = cudaq.qvector(10)\n",
+    "    h(register)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "490cb6c7-d9a2-4861-bd6d-8fddd764039c",
+   "metadata": {},
+   "source": [
+    "Or, to individual qubits in a register:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "5491190b-fdaa-4203-9143-fbeb1519b074",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    register = cudaq.qvector(10)\n",
+    "    h(register[0])  # first qubit\n",
+    "    h(register[-1])  # last qubit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22c0e379-80fc-43b0-bee0-41d1c6492585",
+   "metadata": {},
+   "source": [
+    "### Controlled Operations\n",
+    "\n",
+    "Controlled operations are available for any gate and can be used by adding `.ctrl` to the end of any gate, followed by specification of the control qubit and the target qubit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "68b48107-e326-4a8a-986b-eb2df6207538",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    register = cudaq.qvector(10)\n",
+    "    x.ctrl(register[0], register[1])  # CNOT gate applied with qubit 0 as control"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b88044d5-f0d2-429a-824e-6e11617d5e75",
+   "metadata": {},
+   "source": [
+    "### Multi-Controlled Operations\n",
+    "\n",
+    "It is valid for more than one qubit to be used for multi-controlled gates. The control qubits are specified as a list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "03843595-5b4b-4684-ad41-974f7c84470a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    register = cudaq.qvector(10)\n",
+    "    x.ctrl([register[0], register[1]], register[2])  # X applied to qubit two controlled by qubit 0 and 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66044f3f",
+   "metadata": {},
+   "source": [
+    "You can also call a controlled kernel within a kernel: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "032e4bb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{ 101:1000 }\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "@cudaq.kernel\n",
+    "def x_kernel(qubit: cudaq.qubit):\n",
+    "    x(qubit)\n",
+    "    \n",
+    "# A kernel that will call `x_kernel` as a controlled operation.\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    \n",
+    "    control_vector = cudaq.qvector(2)\n",
+    "    target = cudaq.qubit()\n",
+    "    \n",
+    "    x(control_vector)\n",
+    "    x(target)\n",
+    "    x(control_vector[1])\n",
+    "    cudaq.control(x_kernel, control_vector, target)\n",
+    "\n",
+    "# The above is equivalent to: \n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    qvector = cudaq.qvector(3)\n",
+    "    x(qvector)\n",
+    "    x(qvector[1])\n",
+    "    x.ctrl([qvector[0], qvector[1]], qvector[2])\n",
+    "    mz(qvector)\n",
+    "\n",
+    "\n",
+    "results = cudaq.sample(kernel)\n",
+    "print(results)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47d6a1de-f659-4c58-b2ed-91d1682dad18",
+   "metadata": {},
+   "source": [
+    "### Adjoint Operations\n",
+    "\n",
+    "The adjoint of a gate can be applied by appending the gate with the `adj` designation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "74db71e1-4046-454e-a434-2bd27fda2336",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    register = cudaq.qvector(10)\n",
+    "    t.adj(register[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e61ba842-c969-4ad0-95ee-0916ec753b4f",
+   "metadata": {},
+   "source": [
+    "### Custom Operations\n",
+    "\n",
+    "Custom gate operations can be specified using `cudaq.register_operation`. A one-dimensional Numpy array specifies the unitary matrix to be applied. The entries of the array read from top to bottom through the rows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "d51340c1-d211-4ddc-aaf4-ba59a91ba9cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "cudaq.register_operation(\"custom_x\", np.array([0, 1, 1, 0]))\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    qubits = cudaq.qvector(2)\n",
+    "    h(qubits[0])\n",
+    "    custom_x(qubits[0])\n",
+    "    custom_x.ctrl(qubits[0], qubits[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef38ddbb-433c-49d6-a124-8da3ef034c04",
+   "metadata": {},
+   "source": [
+    "### Building Kernels with Kernels\n",
+    "\n",
+    "For many complex applications, it is helpful for a kernel to call another kernel to perform a specific subroutine. The example blow shows how `kernel_A` can be caled within `kernel_B` to perform CNOT operations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "7d298eaf-08a4-4905-89d2-f52b79dc1484",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel_A(qubit_0: cudaq.qubit, qubit_1: cudaq.qubit):\n",
+    "    x.ctrl(qubit_0, qubit_1)\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel_B():\n",
+    "    reg = cudaq.qvector(10)\n",
+    "    for i in range(5):\n",
+    "        kernel_A(reg[i], reg[i + 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7b3cb6b-74ca-49e2-9ea5-c9f69b0316ed",
+   "metadata": {},
+   "source": [
+    "### Parameterized Kernels\n",
+    "\n",
+    "It is often useful to define parameterized circuit kernels which can be used for applications like VQE."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "d05544d4-fb57-49d7-84ff-d9dd090f49fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel(thetas: list[float]):\n",
+    "    qubits = cudaq.qvector(2)\n",
+    "    rx(thetas[0], qubits[0])\n",
+    "    ry(thetas[1], qubits[1])\n",
+    "\n",
+    "thetas = [.024, .543]\n",
+    "\n",
+    "kernel(thetas)"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/executing_kernels.ipynb b/docs/sphinx/examples/executing_kernels.ipynb
new file mode 100644
index 0000000000..86e36a948a
--- /dev/null
+++ b/docs/sphinx/examples/executing_kernels.ipynb
@@ -0,0 +1,293 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Executing Quantum Circuits \n",
+    "\n",
+    "In CUDA-Q, there are 3 ways in which one can execute quantum kernels: \n",
+    "\n",
+    "1. `sample`: yields measurement counts \n",
+    "2. `observe`: yields expectation values \n",
+    "3. `get_state`: yields the quantum statevector of the computation \n",
+    "\n",
+    "## Sample\n",
+    "\n",
+    "Quantum states collapse upon measurement and hence need to be sampled many times to gather statistics. The CUDA-Q `sample` call enables this: \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "     ╭───╮     \n",
+      "q0 : ┤ h ├──●──\n",
+      "     ╰───╯╭─┴─╮\n",
+      "q1 : ─────┤ x ├\n",
+      "          ╰───╯\n",
+      "\n",
+      "{ 11:499 00:501 }\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np \n",
+    "\n",
+    "qubit_count = 2\n",
+    "\n",
+    "# Define the simulation target.\n",
+    "cudaq.set_target(\"qpp-cpu\")\n",
+    "\n",
+    "# Define a quantum kernel function.\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(qubit_count: int):\n",
+    "    qvector = cudaq.qvector(qubit_count)\n",
+    "\n",
+    "    # 2-qubit GHZ state.\n",
+    "    h(qvector[0])\n",
+    "    for i in range(1, qubit_count):\n",
+    "        x.ctrl(qvector[0], qvector[i])\n",
+    "\n",
+    "    # If we dont specify measurements, all qubits are measured in\n",
+    "    # the Z-basis by default or we can manually specify it also \n",
+    "    # mz(qvector)\n",
+    "\n",
+    "\n",
+    "print(cudaq.draw(kernel, qubit_count))\n",
+    "\n",
+    "result = cudaq.sample(kernel, qubit_count, shots_count=1000)\n",
+    "\n",
+    "print(result)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that there is a subtle difference between how `sample` is executed with the target device set to a simulator or with the target device set to a QPU. In simulation mode, the quantum state is built once and then sampled $s$ times where $s$ equals the `shots_count`. In hardware execution mode, the quantum state collapses upon measurement and hence needs to be rebuilt over and over again.\n",
+    "\n",
+    "There are a number of helpful tools that can be found in the API [here](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.SampleResult) to process the `Sample_Result` object produced by `sample`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Observe\n",
+    "\n",
+    "The `observe` function allows us to calculate expectation values. We must supply a spin operator in the form of a Hamiltonian, $H$,  from which we would like to calculate $\\bra{\\psi}H\\ket{\\psi}$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<H> = 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cudaq import spin\n",
+    "\n",
+    "# Define a Hamiltonian in terms of Pauli Spin operators.\n",
+    "hamiltonian = spin.z(0) + spin.y(1) + spin.x(0) * spin.z(0)\n",
+    "\n",
+    "# Compute the expectation value given the state prepared by the kernel.\n",
+    "result = cudaq.observe(kernel, hamiltonian, qubit_count).expectation()\n",
+    "\n",
+    "print('<H> =', result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Get state\n",
+    "\n",
+    "The `get_state` function gives us access to the quantum statevector of the computation. Remember, that this is only feasible in simulation mode. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.70710678+0.j 0.        +0.j 0.        +0.j 0.70710678+0.j]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute the statevector of the kernel\n",
+    "result = cudaq.get_state(kernel, qubit_count)\n",
+    "\n",
+    "print(np.array(result))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The statevector generated by the `get_state` command follows Big-endian convention for associating numbers with their binary representations, which places the least significant bit on the left.  That is, for the example of a 2-bit system, we have the following translation between integers and bits:\n",
+    "$$\\begin{matrix} \\text{Integer} & \\text{Binary representation}\\\\\n",
+    "& \\text{least signinificant bit on left}\\\\\n",
+    "0 =\\textcolor{red}{0}*2^0+\\textcolor{blue}{0}*2^1 & \\textcolor{red}{0}\\textcolor{blue}{0} \\\\\n",
+    "1 = \\textcolor{red}{1}*2^0 + \\textcolor{blue}{0} *2^1 & \\textcolor{red}{1}\\textcolor{blue}{0}\\\\\n",
+    "2 = \\textcolor{red}{0}*2^0 + \\textcolor{blue}{1}*2^1 & \\textcolor{red}{0}\\textcolor{blue}{1} \\\\\n",
+    "3 = \\textcolor{red}{1}*2^0 + \\textcolor{blue}{1}*2^1 & \\textcolor{red}{1}\\textcolor{blue}{1} \\end{matrix}\n",
+    "$$\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Parallelization Techniques\n",
+    "\n",
+    "The most intensive task in the computation is the execution of the quantum kernel hence each execution function: `sample`, `observe` and `get_state` can be parallelized given access to multiple quantum processing units (multi-QPU). \n",
+    "\n",
+    "Since multi-QPU platforms are not yet feasible, we emulate each QPU with a GPU.\n",
+    "\n",
+    "\n",
+    "### Observe Async\n",
+    "\n",
+    "Asynchronous programming is a technique that enables your program to start a potentially long-running task and still be able to be responsive to other events while that task runs, rather than having to wait until that task has finished. Once that task has finished, your program is presented with the result. \n",
+    "\n",
+    "`observe` can be a time intensive task. We can parallelize the execution of `observe` via the arguments it accepts. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0\n",
+      "0.9999999403953552\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Set the simulation target to a multi-QPU platform \n",
+    "# cudaq.set_target(\"nvidia\", option = 'mqpu')\n",
+    "\n",
+    "# Measuring the expectation value of 2 different hamiltonians in parallel\n",
+    "hamiltonian_1 = spin.x(0) + spin.y(1) + spin.z(0)*spin.y(1)\n",
+    "hamiltonian_2 = spin.z(1) + spin.y(0) + spin.x(1)*spin.x(0)\n",
+    "\n",
+    "# Asynchronous execution on multiple qpus via nvidia gpus.\n",
+    "result_1 = cudaq.observe_async(kernel, hamiltonian_1, qubit_count, qpu_id=0)\n",
+    "result_2 = cudaq.observe_async(kernel, hamiltonian_2, qubit_count, qpu_id=1)\n",
+    "\n",
+    "# Retrieve results \n",
+    "print(result_1.get().expectation())\n",
+    "print(result_2.get().expectation())"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Above we parallelized the `observe` call over the `hamiltonian` parameter however we can parallelize over any of the argument it accepts by just iterating obver the `qpu_id`."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sample Async\n",
+    "\n",
+    "Similar to `observe_async` above, `sample` also supports asynchronous execution for the [arguments it accepts](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.sample_async:~:text=cudaq.sample_async(kernel%3A%20object%2C%20%5C*args%2C%20shots_count%3A%20int%20%3D%201000%2C%20qpu_id%3A%20int%20%3D%200)%E2%86%92%20cudaq.mlir._mlir_libs._quakeDialects.cudaq_runtime.AsyncSampleResult). One can parallelize over various kernels, variational parameters or even distribute shots counts over multiple QPUs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Get State Async\n",
+    "\n",
+    "Similar to `sample_async` above, `get_state` also supports asynchronous execution for the [arguments it accepts](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.sample_async:~:text=cudaq.get_state(arg0%3A%20object%2C%20%5C*args)%E2%86%92%20cudaq.mlir._mlir_libs._quakeDialects.cudaq_runtime.State)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CUDA-Q Version latest (https://github.com/NVIDIA/cuda-quantum 176f1e7df8a58c2dc3d6b1b47bf7f63b4b8d3b63)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(cudaq.__version__)\n"
+   ]
+  }
+ ],
+ "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.12"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/sphinx/examples/python/tutorials/images/Bloch_sphere.png b/docs/sphinx/examples/images/Bloch_sphere.png
similarity index 100%
rename from docs/sphinx/examples/python/tutorials/images/Bloch_sphere.png
rename to docs/sphinx/examples/images/Bloch_sphere.png
diff --git a/docs/sphinx/examples/images/backends.png b/docs/sphinx/examples/images/backends.png
new file mode 100644
index 0000000000..9d9ed491d5
Binary files /dev/null and b/docs/sphinx/examples/images/backends.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/circuit_pdf.png b/docs/sphinx/examples/images/circuit_pdf.png
similarity index 100%
rename from docs/sphinx/examples/python/tutorials/images/circuit_pdf.png
rename to docs/sphinx/examples/images/circuit_pdf.png
diff --git a/docs/sphinx/examples/images/gate-fuse.png b/docs/sphinx/examples/images/gate-fuse.png
new file mode 100644
index 0000000000..a8154b7551
Binary files /dev/null and b/docs/sphinx/examples/images/gate-fuse.png differ
diff --git a/docs/sphinx/examples/images/gatefusion.png b/docs/sphinx/examples/images/gatefusion.png
new file mode 100644
index 0000000000..353219ab04
Binary files /dev/null and b/docs/sphinx/examples/images/gatefusion.png differ
diff --git a/docs/sphinx/examples/images/gates.png b/docs/sphinx/examples/images/gates.png
new file mode 100644
index 0000000000..afb47af7e1
Binary files /dev/null and b/docs/sphinx/examples/images/gates.png differ
diff --git a/docs/sphinx/examples/images/krylovcircuit.png b/docs/sphinx/examples/images/krylovcircuit.png
new file mode 100644
index 0000000000..e8ee649a0d
Binary files /dev/null and b/docs/sphinx/examples/images/krylovcircuit.png differ
diff --git a/docs/sphinx/examples/images/mqpumgpu.png b/docs/sphinx/examples/images/mqpumgpu.png
new file mode 100644
index 0000000000..77af6ed86e
Binary files /dev/null and b/docs/sphinx/examples/images/mqpumgpu.png differ
diff --git a/docs/sphinx/examples/measuring_kernels.ipynb b/docs/sphinx/examples/measuring_kernels.ipynb
new file mode 100644
index 0000000000..6a4c4eab5b
--- /dev/null
+++ b/docs/sphinx/examples/measuring_kernels.ipynb
@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "13858fc6-edc7-49cb-8b56-152ebec2f729",
+   "metadata": {},
+   "source": [
+    "# Measurements\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ec9af8fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cudaq"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa410efc-fcb1-43e1-ab99-25a7fcbab868",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Kernel measurement can be specified in the Z, X, or Y basis using `mz`, `mx`, and `my`. If a measurement is specified with no argument, the entire kernel is measured in that basis. Measurement occurs in the Z basis by default."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7f45a62e-48cb-4705-8081-e59782c91b5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    qubits = cudaq.qvector(2)\n",
+    "    mz()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39efaac5-5400-4df6-ac5d-80637d9d3082",
+   "metadata": {},
+   "source": [
+    "Specific qubits or registers can be measured rather than the entire kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "16a14177-fa79-4eb3-8fc8-f3e937bc21b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    qubits_a = cudaq.qvector(2)\n",
+    "    qubit_b = cudaq.qubit()\n",
+    "    mz(qubits_a)\n",
+    "    mx(qubit_b)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb5dd767-5db7-4847-b04e-ae5695066800",
+   "metadata": {},
+   "source": [
+    "### Midcircuit Measurement and Conditional Logic\n",
+    "\n",
+    "In certain cases, it it is helpful for some operations in a quantum kernel to depend on measurement results following previous operations. This is accomplished in the following example by performing a Hadamard on qubit 0, then measuring qubit 0 and savig the result as `b0`. Then, an if statement performs a Hadamard on qubit 1 only if `b0` is 1. Measuring this qubit 1 verifies this process as a 1 is the result 25% of the time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "44001a51-3733-472c-8bc1-ee694e957708",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel():\n",
+    "    q = cudaq.qvector(2)\n",
+    "    h(q[0])\n",
+    "    b0 = mz(q[0])\n",
+    "    if b0:\n",
+    "        h(q[1])\n",
+    "        mz(q[1])"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/tutorials/noisy_simulations.ipynb b/docs/sphinx/examples/noisy_simulations.ipynb
similarity index 88%
rename from docs/sphinx/examples/python/tutorials/noisy_simulations.ipynb
rename to docs/sphinx/examples/noisy_simulations.ipynb
index 40b0834663..b09fd9ca4c 100644
--- a/docs/sphinx/examples/python/tutorials/noisy_simulations.ipynb
+++ b/docs/sphinx/examples/noisy_simulations.ipynb
@@ -32,7 +32,16 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "import cudaq\n",
     "from cudaq import spin\n",
@@ -104,7 +113,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{ 11:850 10:88 01:56 00:6 }\n"
+      "{ 11:844 10:88 01:65 00:3 }\n"
      ]
     }
    ],
@@ -116,20 +125,28 @@
     "error_probability = 0.1\n",
     "depolarization_channel = cudaq.DepolarizationChannel(error_probability)\n",
     "\n",
+    "# Other built in noise models \n",
+    "bit_flip = cudaq.BitFlipChannel(error_probability) \n",
+    "phase_flip = cudaq.PhaseFlipChannel(error_probability)\n",
+    "amplitude_damping = cudaq.AmplitudeDampingChannel(error_probability)\n",
+    "\n",
     "# We can also define our own, custom noise channels through\n",
     "# Kraus operators. Here we will define two operators representing\n",
     "# bit flip errors.\n",
     "\n",
     "# Define the Kraus Error Operator as a complex ndarray.\n",
-    "kraus_0 = np.sqrt(1 - error_probability) * np.array([[1.0, 0.0], [0.0, 1.0]],\n",
+    "kraus_0 = np.sqrt(1 - error_probability) * np.array([[1.0, 0.0], \n",
+    "                                                     [0.0, 1.0]],\n",
     "                                                    dtype=np.complex128)\n",
-    "kraus_1 = np.sqrt(error_probability) * np.array([[0.0, 1.0], [1.0, 0.0]],\n",
+    "\n",
+    "kraus_1 = np.sqrt(error_probability) * np.array([[0.0, 1.0], \n",
+    "                                                 [1.0, 0.0]],\n",
     "                                                dtype=np.complex128)\n",
     "\n",
     "# Add the Kraus Operator to create a quantum channel.\n",
     "bitflip_channel = cudaq.KrausChannel([kraus_0, kraus_1])\n",
     "\n",
-    "# Add the two channels to our Noise Model.\n",
+    "# Add noise channels to our noise model.\n",
     "noise_model = cudaq.NoiseModel()\n",
     "\n",
     "# Apply the depolarization channel to any X-gate on the 0th qubit.\n",
@@ -192,7 +209,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.15 (default, Sep 23 2021, 15:41:43) [GCC]"
+   "version": "3.10.12"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/docs/sphinx/examples/operators.ipynb b/docs/sphinx/examples/operators.ipynb
new file mode 100644
index 0000000000..801b2357d2
--- /dev/null
+++ b/docs/sphinx/examples/operators.ipynb
@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9a37411d-09c5-42f4-9d62-132715cead3e",
+   "metadata": {},
+   "source": [
+    "# Operators\n",
+    "\n",
+    "Operators are important constructs for many quantum applications.  This section covers how to define and use spin operators as well as additional tools for defining more sophisticated operators."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3695762-03b5-46d6-9aac-853d1ebca9d1",
+   "metadata": {},
+   "source": [
+    "### Constructing Spin Operators\n",
+    "\n",
+    "The `spin_op`  type provides an abstraction for a general tensor product of Pauli spin operators, and their sums.\n",
+    "\n",
+    "Spin operators are constructed using the `spin.z()`, `spin.y()`, `spin.x()`, and `spin.i()` functions, corresponding to the $Z$, $Y$, $X$, and $I$ Pauli operators. For example,  `spin.z(0)` corresponds to a Pauli $Z$ operation acting on qubit 0.  The example below demonstrates how to construct the following operator $2XYX - 3ZZY$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "29ca747b-ee90-4a83-a41b-6480e0c7b6c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "from cudaq import spin\n",
+    "\n",
+    "operator = 2 * spin.x(0) * spin.y(1) * spin.x(2) - 3 * spin.z(0) * spin.z( 1) * spin.y(2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "222ea088-ea18-46cf-872d-5e76d25e5e93",
+   "metadata": {},
+   "source": [
+    "There are a number of convenient methods for combining, comparing, iterating through, and extracting information from spin operators and can be referenced [here](https://nvidia.github.io/cuda-quantum/latest/api/languages/python_api.html#cudaq.SpinOperator) in the API."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "970e6f09-f0db-4aa3-b611-c33e8436aa55",
+   "metadata": {},
+   "source": [
+    "### Pauli Words and Exponentiating Pauli Words\n",
+    "\n",
+    "The `pauli_word` type specifies a string of Pauli operations (e.g. ‘XYXZ’) and is convenient for applying operations based on exponentiated Pauli words.  The code below demonstrates how a list of Pauli words, along with their coefficients, are provided as kernel inputs and converted into operators by the `exp_pauli` function.\n",
+    "\n",
+    "The cell below applies the following operation: $e^{i(0.432XZY +0.324IXX)}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3fe49bcb-0fe1-48e3-aee2-bff882f03fe6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "words = ['XYZ', 'IXX']\n",
+    "coefficients = [0.432, 0.324]\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(coefficients: list[float], words: list[cudaq.pauli_word]):\n",
+    "    q = cudaq.qvector(3)\n",
+    "\n",
+    "    for i in range(len(coefficients)):\n",
+    "        exp_pauli(coefficients[i], q, words[i])"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/optimizers_gradients.ipynb b/docs/sphinx/examples/optimizers_gradients.ipynb
new file mode 100644
index 0000000000..1c2a93e5e8
--- /dev/null
+++ b/docs/sphinx/examples/optimizers_gradients.ipynb
@@ -0,0 +1,265 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e466cb3d-c036-45f7-af9f-b18b9aa22e8a",
+   "metadata": {},
+   "source": [
+    "# Optimizers and Gradients\n",
+    "\n",
+    "Many quantum algorithms require the optimization of quantum circuit parameters with respect to an expectation value.  CUDA-Q has a number of tools available for optimization techniques.  This example will demonstrate how to optimize the variational parameters of a circuit using:\n",
+    "\n",
+    "1. Built in CUDA-Q optimizers and gradients\n",
+    "2. A Third-Party Optimizer\n",
+    "3. A Parallel parameter shift gradient.\n",
+    "\n",
+    "First, the kernel and Hamiltonian and specified below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a77a963a-6f5c-4751-93c8-b3ccbb5921f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "from cudaq import spin\n",
+    "import numpy as np\n",
+    "\n",
+    "hamiltonian = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(\n",
+    "    0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(angles: list[float]):\n",
+    "\n",
+    "    qubits = cudaq.qvector(2)\n",
+    "    x(qubits[0])\n",
+    "    ry(angles[0], qubits[1])\n",
+    "    x.ctrl(qubits[1], qubits[0])  \n",
+    "\n",
+    "initial_params = np.random.normal(0, np.pi, 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c3de68e-754a-4412-8063-78ee9646b4b0",
+   "metadata": {},
+   "source": [
+    "### Built in CUDA-Q Optimizers and Gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eea5d9f2-ade2-4411-88a7-b8c5505c29c3",
+   "metadata": {},
+   "source": [
+    "The optimizer and gradient are specified first from a built in CUDA-Q optimizer and gradient technique. An objective function is defined next which uses a lambda expression to evaluate the cost (a CUDA-Q `observe` expectation value). The gradient is calculated using the `compute` method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "87387c0a-86cf-4dfb-9130-b1c3054e43d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer = cudaq.optimizers.Adam()\n",
+    "gradient = cudaq.gradients.CentralDifference()\n",
+    "\n",
+    "\n",
+    "def objective_function(parameter_vector: list[float],\n",
+    "                       hamiltonian=hamiltonian,\n",
+    "                       gradient_strategy=gradient,\n",
+    "                       kernel=kernel) -> tuple[float, list[float]]:\n",
+    "\n",
+    "        get_result = lambda parameter_vector: cudaq.observe(kernel, hamiltonian, parameter_vector).expectation()\n",
+    "\n",
+    "        cost = get_result(parameter_vector)\n",
+    "    \n",
+    "        gradient_vector = gradient_strategy.compute(parameter_vector, get_result, cost)\n",
+    "\n",
+    "        return cost, gradient_vector"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b98f7129-d360-4e9c-9ea5-d4173ecb5ef1",
+   "metadata": {},
+   "source": [
+    "Finally, the optimizer is called to return the optimal cost and parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "713d7619-7b62-42b7-bb46-601ed9883e6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "energy, parameter = optimizer.optimize(dimensions=1,function=objective_function)\n",
+    "\n",
+    "print(f\"\\nminimized <H> = {round(energy,16)}\")\n",
+    "print(f\"optimal theta 0 = {round(parameter[0],16)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a36a46fc-b04b-43e3-ac10-3b2ee59c3418",
+   "metadata": {},
+   "source": [
+    "### Third-Party Optimizers\n",
+    "\n",
+    "The same procedure can be accomplised using any third-party such as SciPy. In this case, a simple cost fucntion is defined and provided as an input for the standard SciPy `minimize` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0541fa5c-3c4e-44e7-bd13-52d3b07af50e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.optimize import minimize\n",
+    "\n",
+    "def cost(theta):\n",
+    "\n",
+    "    exp_val = cudaq.observe(kernel, hamiltonian, theta).expectation()\n",
+    "\n",
+    "    return exp_val\n",
+    "\n",
+    "result = minimize(cost, initial_params ,method='COBYLA', options={'maxiter': 40})\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d73755a8-2c45-41c8-8d9b-d88a0b411869",
+   "metadata": {},
+   "source": [
+    "### Parallel Parameter Shift Gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b01d93b-0953-4139-8a90-44414327f726",
+   "metadata": {},
+   "source": [
+    "CUDA-Q's `mqpu` backend allows for parallel computation of parameter shift gradients using multiple simulated QPUs. Gradients computed this way can be used in any of the previously discussed optimization procedures.  Below is an example demonstrating how parallel gradient evaluation can be used for a VQE procedure. \n",
+    "\n",
+    "The parameter shift procedure computes two expectations values for each parameter shifted forwards and backwards. These are used to estimate the gradient contribution for that parameter.\n",
+    "\n",
+    "The following code defines a function that takes a kernel, a Hamiltonian (spin operator), and the circuit parameters and produces a parameter shift gradient with shift `epsilon`. The first step of the function builds `xplus` and `xminus` , arrays consisting of the shifted parameters. \n",
+    "\n",
+    "Next, a for loop iterates over all of the parameters and uses the `cudaq.observe_async` to compute the expectation value.  This command also takes `qpu_id` as an in out which specifies the GPU that will be used to simulate the ith QPU.  In the example below, four GPUs (simulated QPUs) are available so the gradient is batched over four devices. \n",
+    "\n",
+    "The results are saved in the `g_plus` and `g_minus` lists, the elements of which are accessed with commands like  `g_plus[1].expectation()` to compute the finite differences and construct the final gradient. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7508c92a-ff80-4a92-9396-691825b1cabb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import  numpy as np\n",
+    "# cudaq.set_target('nvidia', option = 'mqpu')\n",
+    "\n",
+    "num_qpus = 4\n",
+    "epsilon =np.pi/4\n",
+    "\n",
+    "\n",
+    "def batched_gradient_function(kernel, parameters, hamiltonian, epsilon): \n",
+    "\n",
+    "    #Prepare an array of parameters corresponding to the plus and minus shifts\n",
+    "    x = np.tile(parameters, (len(parameters),1))\n",
+    "    xplus = x + (np.eye(x.shape[0]) * epsilon)\n",
+    "    xminus = x - (np.eye(x.shape[0]) * epsilon)\n",
+    "\n",
+    "    g_plus = []\n",
+    "    g_minus = []\n",
+    "    gradient = []\n",
+    "\n",
+    "    qpu_counter = 0 # Iterate over the number of GPU resources available\n",
+    "    \n",
+    "    \n",
+    "    for i in range(x.shape[0]): \n",
+    "\n",
+    "        g_plus.append(cudaq.observe_async(kernel,hamiltonian, xplus[i], qpu_id = qpu_counter%num_qpus))\n",
+    "        qpu_counter += 1 \n",
+    "\n",
+    "        g_minus.append(cudaq.observe_async(kernel, hamiltonian, xminus[i], qpu_id = qpu_counter%num_qpus))\n",
+    "        qpu_counter += 1 \n",
+    "        \n",
+    "    #use the expectation values to compute the gradient    \n",
+    "    gradient = [(g_plus[i].get().expectation() - g_minus[i].get().expectation()) / (2*epsilon) for i in range(len(g_minus))]\n",
+    "\n",
+    "    return gradient\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a317073-0e29-40d1-bf09-d168e7227f14",
+   "metadata": {},
+   "source": [
+    "This function can be used in a VQE procedure as presented below. First, the gradient is computed using the initial parameters, then the standard VQE construction is used, but the `batched_gradient_function` is used to evaluate the gradient at each step. This objective function will return the cost and gradient at each step and can be used with any SciPy optimizer that uses a gradient."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6313f4ed-a620-4982-b587-42e19267ef84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gradient = batched_gradient_function(kernel, initial_params, hamiltonian, epsilon)\n",
+    "\n",
+    "\n",
+    "def objective_function(parameter_vector,\n",
+    "                       hamiltonian=hamiltonian,\n",
+    "                       gradient=gradient,\n",
+    "                       kernel=kernel):\n",
+    "\n",
+    "    cost=cudaq.observe(kernel,hamiltonian,parameter_vector).expectation()\n",
+    "   \n",
+    " \n",
+    "    gradient_vector = batched_gradient_function(kernel, initial_params, hamiltonian, epsilon)\n",
+    "\n",
+    "    return cost, gradient_vector\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edd702a6-213d-469e-861b-9beee6207284",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result_vqe=minimize(objective_function,initial_params, method='L-BFGS-B', jac=True, tol=1e-8, options={'maxiter': 5})\n",
+    "print(result)"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/performance_optimizations.ipynb b/docs/sphinx/examples/performance_optimizations.ipynb
new file mode 100644
index 0000000000..0e90c2201d
--- /dev/null
+++ b/docs/sphinx/examples/performance_optimizations.ipynb
@@ -0,0 +1,60 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bf94a9f4-6be0-4eda-b441-ecc85f89e0c7",
+   "metadata": {},
+   "source": [
+    "# Optimizing Performance\n",
+    "\n",
+    "Performance is a key focus for the CUDA-Q design.  This section highlights some features that advanced users can take advantage of to increase performance in certain situations."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dcc9c85-780b-495e-aebe-8cd9c0012792",
+   "metadata": {},
+   "source": [
+    "### Gate Fusion\n",
+    "\n",
+    "Gate fusion is an optimization technique where consecutive gates are combined into a single gate operation to improve the efficiency of the simulation (See figure below).  By targeting the `nvidia-mgpu` backend and setting the `CUDAQ_MGPU_FUSE` environment variable, you can select the degree of fusion that takes place. A full command line example would look like `CUDAQ_MGPU_FUSE=4 python c2h2VQE.py --target nvidia --target-option fp64,mgpu`\n",
+    "\n",
+    "<img src=\"./images/gate-fuse.png\" style=\"width:400px;\">\n",
+    "\n",
+    "The importance of gate fusion is system dependent, but can have a large influence on the performance of the simulation.  See the example below for a 24 qubit VQE experiment where changing the fusion level resulted in significant performance boosts.\n",
+    "\n",
+    "<img src=\"./images/gatefusion.png\" style=\"width:300px;\">\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe248ebe-f96d-49e1-a0d6-be9405facf28",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/advanced_vqe.py b/docs/sphinx/examples/python/advanced_vqe.py
deleted file mode 100644
index c76fc7beb7..0000000000
--- a/docs/sphinx/examples/python/advanced_vqe.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import cudaq
-from cudaq import spin
-
-from typing import List, Tuple
-
-# We will be optimizing over a custom objective function that takes a vector
-# of parameters as input and returns either the cost as a single float,
-# or a tuple of (cost, gradient_vector) depending on the optimizer used.
-
-# In this example, we will use the spin Hamiltonian and ansatz from `simple_vqe.py`
-# and find the `angles` that minimize the expectation value of the system.
-hamiltonian = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(
-    0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)
-
-
-@cudaq.kernel
-def kernel(angles: List[float]):
-    qvector = cudaq.qvector(2)
-    x(qvector[0])
-    ry(angles[0], qvector[1])
-    x.ctrl(qvector[1], qvector[0])
-
-
-# Define the optimizer that we'd like to use.
-optimizer = cudaq.optimizers.Adam()
-
-# Since we'll be using a gradient-based optimizer, we can leverage the
-# CUDA-Q gradient helper class to automatically compute the gradient
-# vector for us. The use of this class for gradient calculations is
-# purely optional and can be replaced with your own custom gradient
-# routine.
-gradient = cudaq.gradients.CentralDifference()
-
-
-def objective_function(parameter_vector: List[float],
-                       hamiltonian=hamiltonian,
-                       gradient_strategy=gradient,
-                       kernel=kernel) -> Tuple[float, List[float]]:
-    """
-    Note: the objective function may also take extra arguments, provided they
-    are passed into the function as default arguments in python.
-    """
-
-    # Call `cudaq.observe` on the spin operator and ansatz at the
-    # optimizer provided parameters. This will allow us to easily
-    # extract the expectation value of the entire system in the
-    # z-basis.
-
-    # We define the call to `cudaq.observe` here as a lambda to
-    # allow it to be passed into the gradient strategy as a
-    # function. If you were using a gradient-free optimizer,
-    # you could purely define `cost = cudaq.observe().expectation()`.
-    get_result = lambda parameter_vector: cudaq.observe(
-        kernel, hamiltonian, parameter_vector).expectation()
-    # `cudaq.observe` returns a `cudaq.ObserveResult` that holds the
-    # counts dictionary and the `expectation`.
-    cost = get_result(parameter_vector)
-    print(f"<H> = {cost}")
-    # Compute the gradient vector using `cudaq.gradients.STRATEGY.compute()`.
-    gradient_vector = gradient_strategy.compute(parameter_vector, get_result,
-                                                cost)
-
-    # Return the (cost, gradient_vector) tuple.
-    return cost, gradient_vector
-
-
-cudaq.set_random_seed(13)  # make repeatable
-energy, parameter = optimizer.optimize(dimensions=1,
-                                       function=objective_function)
-
-print(f"\nminimized <H> = {round(energy,16)}")
-print(f"optimal theta = {round(parameter[0],16)}")
diff --git a/docs/sphinx/examples/python/bernstein_vazirani.py b/docs/sphinx/examples/python/bernstein_vazirani.py
deleted file mode 100644
index fe82ef4dac..0000000000
--- a/docs/sphinx/examples/python/bernstein_vazirani.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import cudaq
-import random
-
-from typing import List
-
-
-def random_bits(length: int):
-    bitset = []
-    for _ in range(length):
-        bitset.append(random.randint(0, 1))
-    return bitset
-
-
-# If you have a NVIDIA GPU you can use this example to see
-# that the GPU-accelerated backends can easily handle a
-# larger number of qubits compared the CPU-only backend.
-
-# Depending on the available memory on your GPU, you can
-# set the number of qubits to around 30 qubits, and un-comment
-# the `cudaq.set_target(nvidia)` line.
-
-# Note: Without setting the target to the `nvidia` backend,
-# there will be a noticeable decrease in simulation performance.
-# This is because the CPU-only backend has difficulty handling
-# 30+ qubit simulations.
-
-qubit_count = 5  # set to around 30 qubits for `nvidia` target
-# ```
-# cudaq.set_target("nvidia")
-# ```
-
-# Generate a random, hidden bitstring for the oracle
-# to encode. Note: we define the bitstring here so
-# as to be able to return it for verification.
-hidden_bits = random_bits(qubit_count)
-
-
-@cudaq.kernel
-def oracle(register: cudaq.qview, auxillary_qubit: cudaq.qubit,
-           hidden_bits: List[int]):
-    for index, bit in enumerate(hidden_bits):
-        if bit == 1:
-            # apply a `cx` gate with the current qubit as
-            # the control and the auxillary qubit as the target.
-            x.ctrl(register[index], auxillary_qubit)
-
-
-@cudaq.kernel
-def bernstein_vazirani(hidden_bits: List[int]):
-    # Allocate the specified number of qubits - this
-    # corresponds to the length of the hidden bitstring.
-    qubits = cudaq.qvector(len(hidden_bits))
-    # Allocate an extra auxillary qubit.
-    auxillary_qubit = cudaq.qubit()
-
-    # Prepare the auxillary qubit.
-    h(auxillary_qubit)
-    z(auxillary_qubit)
-
-    # Place the rest of the register in a superposition state.
-    h(qubits)
-
-    # Query the oracle.
-    oracle(qubits, auxillary_qubit, hidden_bits)
-
-    # Apply another set of Hadamards to the register.
-    h(qubits)
-
-    # Apply measurement gates to just the `qubits`
-    # (excludes the auxillary qubit).
-    mz(qubits)
-
-
-print(cudaq.draw(bernstein_vazirani, hidden_bits))
-result = cudaq.sample(bernstein_vazirani, hidden_bits)
-
-print(f"encoded bitstring = {hidden_bits}")
-print(f"measured state = {result.most_probable()}")
-print(
-    f"Were we successful? {''.join([str(i) for i in hidden_bits]) == result.most_probable()}"
-)
diff --git a/docs/sphinx/examples/python/cuquantum_backends.py b/docs/sphinx/examples/python/cuquantum_backends.py
deleted file mode 100644
index ee678ea1a1..0000000000
--- a/docs/sphinx/examples/python/cuquantum_backends.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# This example is meant to demonstrate the cuQuantum
-# GPU-accelerated backends and their ability to easily handle
-# a larger number of qubits compared the CPU-only backend.
-#
-# This will take a noticeably longer time to execute on
-# CPU-only backends.
-
-import cudaq
-
-qubit_count = 5
-# We can set a larger `qubit_count` if running on a GPU backend.
-# qubit_count = 28
-
-
-@cudaq.kernel
-def kernel(qubit_count: int):
-    qvector = cudaq.qvector(qubit_count)
-    h(qvector)
-    for qubit in range(qubit_count - 1):
-        x.ctrl(qvector[qubit], qvector[qubit + 1])
-    mz(qvector)
-
-
-result = cudaq.sample(kernel, qubit_count, shots_count=100)
-
-if (not cudaq.mpi.is_initialized()) or (cudaq.mpi.rank() == 0):
-    print(result)
diff --git a/docs/sphinx/examples/python/expectation_values.py b/docs/sphinx/examples/python/expectation_values.py
deleted file mode 100644
index 69ca023b54..0000000000
--- a/docs/sphinx/examples/python/expectation_values.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# The example here shows a simple use case for the `cudaq::observe``
-# function in computing expected values of provided spin operators.
-
-import cudaq
-from cudaq import spin
-
-
-@cudaq.kernel
-def kernel(theta: float):
-    qvector = cudaq.qvector(2)
-    x(qvector[0])
-    ry(theta, qvector[1])
-    x.ctrl(qvector[1], qvector[0])
-
-
-spin_operator = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(
-    0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)
-
-# Pre-computed angle that minimizes the energy expectation of the `spin_operator`.
-angle = 0.59
-
-energy = cudaq.observe(kernel, spin_operator, angle).expectation()
-print(f"Energy is {energy}")
diff --git a/docs/sphinx/examples/python/intro.py b/docs/sphinx/examples/python/intro.py
deleted file mode 100644
index 68b4b901ab..0000000000
--- a/docs/sphinx/examples/python/intro.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import cudaq
-
-
-# We begin by defining the `Kernel` that we will construct our
-# program with.
-@cudaq.kernel
-def kernel():
-    '''
-    This is our first CUDA-Q kernel.
-    '''
-    # Next, we can allocate a single qubit to the kernel via `qubit()`.
-    qubit = cudaq.qubit()
-
-    # Now we can begin adding instructions to apply to this qubit!
-    # Here we'll just add every non-parameterized
-    # single qubit gate that is supported by CUDA-Q.
-    h(qubit)
-    x(qubit)
-    y(qubit)
-    z(qubit)
-    t(qubit)
-    s(qubit)
-
-    # Next, we add a measurement to the kernel so that we can sample
-    # the measurement results on our simulator!
-    mz(qubit)
-
-
-# Finally, we can execute this kernel on the state vector simulator
-# by calling `cudaq.sample`. This will execute the provided kernel
-# `shots_count` number of times and return the sampled distribution
-# as a `cudaq.SampleResult` dictionary.
-result = cudaq.sample(kernel)
-
-# Now let's take a look at the `SampleResult` we've gotten back!
-print(result)
diff --git a/docs/sphinx/examples/python/multi_controlled_operations.py b/docs/sphinx/examples/python/multi_controlled_operations.py
deleted file mode 100644
index 053ab2a08a..0000000000
--- a/docs/sphinx/examples/python/multi_controlled_operations.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import cudaq
-
-# Here we demonstrate how one might apply multi-controlled
-# operations on a general CUDA-Q kernel.
-
-
-# [Begin OptionA]
-# A kernel that performs an X-gate on a provided qubit.
-@cudaq.kernel
-def x_kernel(qubit: cudaq.qubit):
-    x(qubit)
-
-
-# A kernel that will call `x_kernel` as a controlled operation.
-@cudaq.kernel
-def kernel():
-    control_vector = cudaq.qvector(2)
-    target = cudaq.qubit()
-    x(control_vector)
-    x(target)
-    x(control_vector[1])
-    cudaq.control(x_kernel, control_vector, target)
-
-
-results = cudaq.sample(kernel)
-print(results)
-# [End OptionA]
-
-
-# [Begin OptionB]
-@cudaq.kernel
-def kernel():
-    qvector = cudaq.qvector(3)
-    x(qvector)
-    x(qvector[1])
-    x.ctrl([qvector[0], qvector[1]], qvector[2])
-    mz(qvector)
-
-
-results = cudaq.sample(kernel)
-print(results)
-# [End OptionB]
diff --git a/docs/sphinx/examples/python/noise_amplitude_damping.py b/docs/sphinx/examples/python/noise_amplitude_damping.py
deleted file mode 100644
index f86d7f68ce..0000000000
--- a/docs/sphinx/examples/python/noise_amplitude_damping.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import cudaq
-
-# Set the target to our density matrix simulator.
-cudaq.set_target('density-matrix-cpu')
-
-# CUDA-Q supports several different models of noise. In this case,
-# we will examine the modeling of energy dissipation within our system
-# via environmental interactions. The result of this "amplitude damping"
-# is to return the qubit to the |0> state with a user-specified probability.
-
-# We will begin by defining an empty noise model that we will add
-# our damping channel to.
-noise = cudaq.NoiseModel()
-
-# We define an amplitude damping channel setting to `1.0` the
-# probability of the qubit
-# decaying to the ground state.
-amplitude_damping = cudaq.AmplitudeDampingChannel(1.0)
-
-# We will apply this channel to any Hadamard gate on the qubit.
-# In other words, after each Hadamard on the qubit, there will be a
-# probability of `1.0` that the qubit decays back to the ground state.
-noise.add_channel('h', [0], amplitude_damping)
-
-
-# Now we define our simple kernel function and allocate a qubit.
-@cudaq.kernel
-def kernel():
-    qubit = cudaq.qubit()
-    # Then we apply a Hadamard gate to the qubit.
-    # This will bring it to `1/sqrt(2) (|0> + |1>)`, where it will remain
-    # with a probability of `1 - p = 0.0`.
-    h(qubit)
-    # Measure.
-    mz(qubit)
-
-
-# Now we're ready to run the noisy simulation of our kernel.
-# Note: We must pass the noise model to sample via keyword.
-noisy_result = cudaq.sample(kernel, noise_model=noise)
-print(noisy_result)
-
-# Our results should show all measurements in the |0> state, indicating
-# that the noise has successfully impacted the system.
-
-# To confirm this, we can run the simulation again without noise.
-# The qubit will now have a 50/50 mix of measurements between
-# |0> and |1>.
-noiseless_result = cudaq.sample(kernel)
-print(noiseless_result)
diff --git a/docs/sphinx/examples/python/noise_bit_flip.py b/docs/sphinx/examples/python/noise_bit_flip.py
deleted file mode 100644
index 556e80f5b1..0000000000
--- a/docs/sphinx/examples/python/noise_bit_flip.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import cudaq
-
-# Set the target to our density matrix simulator.
-cudaq.set_target('density-matrix-cpu')
-
-# CUDA-Q supports several different models of noise. In this case,
-# we will examine the modeling of decoherence of the qubit state. This
-# will occur from "bit flip" errors, wherein the qubit has a user-specified
-# probability of undergoing an X-180 rotation.
-
-# We will begin by defining an empty noise model that we will add
-# these decoherence channels to.
-noise = cudaq.NoiseModel()
-
-# We define a bit-flip channel setting to `1.0` probability of the
-# qubit flipping 180 degrees about the X axis.
-bit_flip = cudaq.BitFlipChannel(1.0)
-# We will apply this channel to any X gate on the qubit, giving each X-gate
-# a probability of `1.0` of undergoing an extra X-gate.
-noise.add_channel('x', [0], bit_flip)
-
-
-# Now we define our simple kernel function and allocate a register
-# of qubits to it.
-@cudaq.kernel
-def kernel():
-    qubit = cudaq.qubit()
-    # Apply an X-gate to the qubit.
-    # It will remain in the |1> state with a probability of `1 - p = 0.0`.
-    x(qubit)
-    # Measure.
-    mz(qubit)
-
-
-# Now we're ready to run the noisy simulation of our kernel.
-# Note: We must pass the noise model to sample via keyword.
-noisy_result = cudaq.sample(kernel, noise_model=noise)
-print(noisy_result)
-
-# Our results should show all measurements in the |0> state, indicating
-# that the noise has successfully impacted the system.
-
-# To confirm this, we can run the simulation again without noise.
-# We should now see the qubit in the |1> state.
-noiseless_result = cudaq.sample(kernel)
-print(noiseless_result)
diff --git a/docs/sphinx/examples/python/noise_depolarization.py b/docs/sphinx/examples/python/noise_depolarization.py
deleted file mode 100644
index 6a9466abfe..0000000000
--- a/docs/sphinx/examples/python/noise_depolarization.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import cudaq
-
-# Set the target to our density matrix simulator.
-cudaq.set_target('density-matrix-cpu')
-
-# CUDA-Q supports several different models of noise. In this
-# case, we will examine the modeling of depolarization noise. This
-# depolarization will result in the qubit state decaying into a mix
-# of the basis states, |0> and |1>, with a user provided probability.
-
-# We will begin by defining an empty noise model that we will add
-# our depolarization channel to.
-noise = cudaq.NoiseModel()
-
-# We define a depolarization channel setting the probability
-# of the qubit state being scrambled to `1.0`.
-depolarization = cudaq.DepolarizationChannel(1.0)
-
-# We will apply the channel to any Y-gate on qubit 0. In other words,
-# for each Y-gate on our qubit, the qubit will have a `1.0`
-# probability of decaying into a mixed state.
-noise.add_channel('y', [0], depolarization)
-
-
-# Now we define our simple kernel function and allocate
-# a qubit to it.
-@cudaq.kernel
-def kernel():
-    qubit = cudaq.qubit()
-    # First we apply a Y-gate to the qubit.
-    # This will bring it to the |1> state, where it will remain
-    # with a probability of `1 - p = 0.0`.
-    y(qubit)
-    mz(qubit)
-
-
-# Without noise, the qubit should still be in the |1> state.
-counts = cudaq.sample(kernel)
-counts.dump()
-
-# With noise, the measurements should be a roughly 50/50
-# mix between the |0> and |1> states.
-noisy_counts = cudaq.sample(kernel, noise_model=noise)
-noisy_counts.dump()
diff --git a/docs/sphinx/examples/python/noise_kraus_operator.py b/docs/sphinx/examples/python/noise_kraus_operator.py
deleted file mode 100644
index af4b64e9b8..0000000000
--- a/docs/sphinx/examples/python/noise_kraus_operator.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import cudaq
-import numpy as np
-
-# Set the target to our density matrix simulator.
-cudaq.set_target('density-matrix-cpu')
-
-# CUDA-Q supports custom noise models through the definition of
-# `KrausChannel`'s. In this case, we will define a set of `KrausOperator`'s
-# that  affect the same noise as the `AmplitudeDampingChannel`. This
-# channel will model the energy dissipation within our system via
-# environmental interactions. With a variable probability, it will
-# return the qubit to the |0> state.
-
-# We will begin by defining an empty noise model that we will add
-# our Kraus Channel to.
-noise = cudaq.NoiseModel()
-
-
-# We will define our Kraus Operators within functions, as to
-# allow for easy control over the noise probability.
-def kraus_operators(probability):
-    """See Nielsen, Chuang Chapter 8.3.5 for definition source."""
-    kraus_0 = np.array([[1, 0], [0, np.sqrt(1 - probability)]],
-                       dtype=np.complex128)
-    kraus_1 = np.array([[0, np.sqrt(probability)], [0, 0]], dtype=np.complex128)
-    return [kraus_0, kraus_1]
-
-
-# We manually define an amplitude damping channel setting to `1.0`
-# the probability of the qubit decaying to the ground state.
-amplitude_damping = cudaq.KrausChannel(kraus_operators(1.0))
-
-# We will apply this channel to any Hadamard gate on the qubit.
-# In other words, after each Hadamard on the qubit, there will be a
-# probability of `1.0` that the qubit decays back to ground.
-noise.add_channel('h', [0], amplitude_damping)
-
-
-@cudaq.kernel
-def kernel():
-    qubit = cudaq.qubit()
-    # Then we apply a Hadamard gate to the qubit.
-    # This will bring it to `1/sqrt(2) (|0> + |1>)`, where it will remain
-    # with a probability of `1 - p = 0.0`.
-    h(qubit)
-    # Measure.
-    mz(qubit)
-
-
-# Now we're ready to run the noisy simulation of our kernel.
-# Note: We must pass the noise model to sample via keyword.
-noisy_result = cudaq.sample(kernel, noise_model=noise)
-print(noisy_result)
-
-# Our results should show all measurements in the |0> state, indicating
-# that the noise has successfully impacted the system.
-
-# To confirm this, we can run the simulation again without noise.
-# The qubit will now have a 50/50 mix of measurements between
-# |0> and |1>.
-noiseless_result = cudaq.sample(kernel)
-print(noiseless_result)
diff --git a/docs/sphinx/examples/python/noise_phase_flip.py b/docs/sphinx/examples/python/noise_phase_flip.py
deleted file mode 100644
index bac1de3be2..0000000000
--- a/docs/sphinx/examples/python/noise_phase_flip.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import cudaq
-
-# Set the target to our density matrix simulator.
-cudaq.set_target('density-matrix-cpu')
-
-# CUDA-Q supports several different models of noise. In this
-# case, we will examine the modeling of decoherence of the qubit phase.
-# This will occur from "phase flip" errors, wherein the qubit has a
-# user-specified probability of undergoing a Z-180 rotation.
-
-# We will begin by defining an empty noise model that we will add
-# our phase flip channel to.
-noise = cudaq.NoiseModel()
-
-# We define a phase-flip channel setting to `1.0` the probability of the qubit
-# undergoing a phase rotation of 180 degrees (π).
-phase_flip = cudaq.PhaseFlipChannel(1.0)
-# We will apply this channel to any Z gate on the qubit.
-# In other words, after each Z gate on qubit 0, there will be a
-# probability of `1.0` that the qubit undergoes an extra
-# Z rotation.
-noise.add_channel('z', [0], phase_flip)
-
-
-@cudaq.kernel
-def kernel():
-    # Single qubit initialized to the |0> state.
-    qubit = cudaq.qubit()
-    # Place qubit in superposition state.
-    h(qubit)
-    # Rotate the phase around Z by 180 degrees (π).
-    z(qubit)
-    # Apply another Hadamard and measure.
-    h(qubit)
-    mz(qubit)
-
-
-# Without noise, we'd expect the qubit to end in the |1>
-# state due to the phase rotation between the two Hadamard
-# gates.
-noiseless_result = cudaq.sample(kernel)
-print(noiseless_result)
-
-# With noise, our Z-gate will effectively cancel out due
-# to the presence of a phase flip error on the gate with a
-# probability of `1.0`. This will put us back in the |0> state.
-noisy_result = cudaq.sample(kernel, noise_model=noise)
-print(noisy_result)
diff --git a/docs/sphinx/examples/python/qaoa_maxcut.py b/docs/sphinx/examples/python/qaoa_maxcut.py
deleted file mode 100644
index f48fe816f4..0000000000
--- a/docs/sphinx/examples/python/qaoa_maxcut.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import cudaq
-from cudaq import spin
-
-from typing import List
-
-import numpy as np
-
-# Here we build up a kernel for QAOA with `p` layers, with each layer
-# containing the alternating set of unitaries corresponding to the problem
-# and the mixer Hamiltonians. The algorithm leverages the VQE algorithm
-# to compute the Max-Cut of a rectangular graph illustrated below.
-
-#       v0  0---------------------0 v1
-#           |                     |
-#           |                     |
-#           |                     |
-#           |                     |
-#       v3  0---------------------0 v2
-# The Max-Cut for this problem is 0101 or 1010.
-
-# The problem Hamiltonian
-hamiltonian = 0.5 * spin.z(0) * spin.z(1) + 0.5 * spin.z(1) * spin.z(2) \
-       + 0.5 * spin.z(0) * spin.z(3) + 0.5 * spin.z(2) * spin.z(3)
-
-# Problem parameters.
-qubit_count: int = 4
-layer_count: int = 2
-parameter_count: int = 2 * layer_count
-
-
-@cudaq.kernel
-def kernel_qaoa(qubit_count: int, layer_count: int, thetas: List[float]):
-    """QAOA ansatz for Max-Cut"""
-    qvector = cudaq.qvector(qubit_count)
-
-    # Create superposition
-    h(qvector)
-
-    # Loop over the layers
-    for layer in range(layer_count):
-        # Loop over the qubits
-        # Problem unitary
-        for qubit in range(qubit_count):
-            x.ctrl(qvector[qubit], qvector[(qubit + 1) % qubit_count])
-            rz(2.0 * thetas[layer], qvector[(qubit + 1) % qubit_count])
-            x.ctrl(qvector[qubit], qvector[(qubit + 1) % qubit_count])
-
-        # Mixer unitary
-        for qubit in range(qubit_count):
-            rx(2.0 * thetas[layer + layer_count], qvector[qubit])
-
-
-# Specify the optimizer and its initial parameters. Make it repeatable.
-cudaq.set_random_seed(13)
-optimizer = cudaq.optimizers.COBYLA()
-np.random.seed(13)
-optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0,
-                                                 parameter_count)
-print("Initial parameters = ", optimizer.initial_parameters)
-
-
-# Define the objective, return `<state(params) | H | state(params)>`
-def objective(parameters):
-    return cudaq.observe(kernel_qaoa, hamiltonian, qubit_count, layer_count,
-                         parameters).expectation()
-
-
-# Optimize!
-optimal_expectation, optimal_parameters = optimizer.optimize(
-    dimensions=parameter_count, function=objective)
-
-# Print the optimized value and its parameters
-print("Optimal value = ", optimal_expectation)
-print("Optimal parameters = ", optimal_parameters)
-
-# Sample the circuit using the optimized parameters
-counts = cudaq.sample(kernel_qaoa, qubit_count, layer_count, optimal_parameters)
-print(counts)
diff --git a/docs/sphinx/examples/python/simple_vqe.py b/docs/sphinx/examples/python/simple_vqe.py
deleted file mode 100644
index f4675a9a97..0000000000
--- a/docs/sphinx/examples/python/simple_vqe.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import cudaq
-from cudaq import spin
-
-from typing import List
-
-# We begin by defining the spin Hamiltonian for the system that we are working
-# with. This is achieved through the use of `cudaq.SpinOperator`'s, which allow
-# for the convenient creation of complex Hamiltonians out of Pauli spin operators.
-hamiltonian = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(
-    0) * spin.y(1) + .21829 * spin.z(0) - 6.125 * spin.z(1)
-
-
-# Next, using the `cudaq.Kernel`, we define the variational quantum circuit
-# that we'd like to use as an ansatz.
-# Create a kernel that takes a list of floats as a function argument.
-@cudaq.kernel
-def kernel(angles: List[float]):
-    # Allocate 2 qubits.
-    qubits = cudaq.qvector(2)
-    x(qubits[0])
-    # Apply an `ry` gate that is parameterized by the first value
-    # of our `angles`.
-    ry(angles[0], qubits[1])
-    x.ctrl(qubits[1], qubits[0])
-    # Note: the kernel must not contain measurement instructions.
-
-
-# The last thing we need is to pick an optimizer from the suite of `cudaq.optimizers`.
-# We can optionally tune this optimizer through its initial parameters, iterations,
-# optimization bounds, etc. before passing it to `cudaq.vqe`.
-optimizer = cudaq.optimizers.COBYLA()
-# optimizer.max_iterations = ...
-# optimizer...
-
-# Finally, we pass all of that into `cudaq.vqe`, and it will automatically run our
-# optimization loop, returning a tuple of the minimized eigenvalue of our `spin_operator`
-# and the list of optimal variational parameters.
-
-energy, parameter = cudaq.vqe(
-    kernel=kernel,
-    spin_operator=hamiltonian,
-    optimizer=optimizer,
-    # list of parameters has length of 1:
-    parameter_count=1)
-
-print(f"\nminimized <H> = {round(energy,16)}")
-print(f"optimal theta = {round(parameter[0],16)}")
diff --git a/docs/sphinx/examples/python/trotter_kernel_mode.py b/docs/sphinx/examples/python/trotter_kernel_mode.py
deleted file mode 100644
index e2e286fbb0..0000000000
--- a/docs/sphinx/examples/python/trotter_kernel_mode.py
+++ /dev/null
@@ -1,128 +0,0 @@
-# ============================================================================ #
-# Copyright (c) 2022 - 2024 NVIDIA Corporation & Affiliates.                   #
-# All rights reserved.                                                         #
-#                                                                              #
-# This source code and the accompanying materials are made available under     #
-# the terms of the Apache License 2.0 which accompanies this distribution.     #
-# ============================================================================ #
-
-import cudaq
-import time
-import numpy as np
-from typing import List
-
-# Compute magnetization using Suzuki-Trotter approximation.
-# This example demonstrates usage of quantum states in kernel mode.
-#
-# Details
-# https://pubs.aip.org/aip/jmp/article-abstract/32/2/400/229229/General-theory-of-fractal-path-integrals-with
-#
-# Hamiltonian used
-# https://en.m.wikipedia.org/wiki/Quantum_Heisenberg_model
-
-# If you have a NVIDIA GPU you can use this example to see
-# that the GPU-accelerated backends can easily handle a
-# larger number of qubits compared the CPU-only backend.
-
-# Depending on the available memory on your GPU, you can
-# set the number of qubits to around 30 qubits, and un-comment
-# the `cudaq.set_target(nvidia)` line.
-
-# Note: Without setting the target to the `nvidia` backend,
-# there will be a noticeable decrease in simulation performance.
-# This is because the CPU-only backend has difficulty handling
-# 30+ qubit simulations.
-
-spins = 11  # set to around 25 qubits for `nvidia` target
-steps = 10  # set to around 100 for `nvidia` target
-# ```
-# cudaq.set_target("nvidia")
-# ```
-
-
-# Alternating up/down spins
-@cudaq.kernel
-def getInitState(numSpins: int):
-    q = cudaq.qvector(numSpins)
-    for qId in range(0, numSpins, 2):
-        x(q[qId])
-
-
-# This performs a single-step Trotter on top of an initial state, e.g.,
-# result state of the previous Trotter step.
-@cudaq.kernel
-def trotter(state: cudaq.State, coefficients: List[complex],
-            words: List[cudaq.pauli_word], dt: float):
-    q = cudaq.qvector(state)
-    for i in range(len(coefficients)):
-        exp_pauli(coefficients[i].real * dt, q, words[i])
-
-
-def run_steps(steps: int, spins: int):
-    g = 1.0
-    Jx = 1.0
-    Jy = 1.0
-    Jz = g
-    dt = 0.05
-    n_steps = steps
-    n_spins = spins
-    omega = 2 * np.pi
-
-    def heisenbergModelHam(t: float) -> cudaq.SpinOperator:
-        tdOp = cudaq.SpinOperator(num_qubits=n_spins)
-        for i in range(0, n_spins - 1):
-            tdOp += (Jx * cudaq.spin.x(i) * cudaq.spin.x(i + 1))
-            tdOp += (Jy * cudaq.spin.y(i) * cudaq.spin.y(i + 1))
-            tdOp += (Jz * cudaq.spin.z(i) * cudaq.spin.z(i + 1))
-        for i in range(0, n_spins):
-            tdOp += (np.cos(omega * t) * cudaq.spin.x(i))
-        return tdOp
-
-    # Collect coefficients from a spin operator so we can pass them to a kernel
-    def termCoefficients(op: cudaq.SpinOperator) -> List[complex]:
-        result = []
-        ham.for_each_term(lambda term: result.append(term.get_coefficient()))
-        return result
-
-    # Collect Pauli words from a spin operator so we can pass them to a kernel
-    def termWords(op: cudaq.SpinOperator) -> List[str]:
-        result = []
-        ham.for_each_term(lambda term: result.append(term.to_string(False)))
-        return result
-
-    # Observe the average magnetization of all spins (<Z>)
-    average_magnetization = cudaq.SpinOperator(num_qubits=n_spins)
-    for i in range(0, n_spins):
-        average_magnetization += ((1.0 / n_spins) * cudaq.spin.z(i))
-    average_magnetization -= 1.0
-
-    # Run loop
-    state = cudaq.get_state(getInitState, n_spins)
-
-    results = []
-    times = []
-    for i in range(0, n_steps):
-        start_time = time.time()
-        ham = heisenbergModelHam(i * dt)
-        coefficients = termCoefficients(ham)
-        words = termWords(ham)
-        magnetization_exp_val = cudaq.observe(trotter, average_magnetization,
-                                              state, coefficients, words, dt)
-        result = magnetization_exp_val.expectation()
-        results.append(result)
-        state = cudaq.get_state(trotter, state, coefficients, words, dt)
-        stepTime = time.time() - start_time
-        times.append(stepTime)
-        print(f"Step {i}: time [s]: {stepTime}, result: {result}")
-
-    print("")
-    # Print all the times and results (useful for plotting).
-    print(f"Step times: {times}")
-    print(f"Results: {results}")
-
-    print("")
-
-
-start_time = time.time()
-run_steps(steps, spins)
-print(f"Total time: {time.time() - start_time}s")
diff --git a/docs/sphinx/examples/python/tutorials/H2-MRQKS.ipynb b/docs/sphinx/examples/python/tutorials/H2-MRQKS.ipynb
deleted file mode 100644
index f919d08673..0000000000
--- a/docs/sphinx/examples/python/tutorials/H2-MRQKS.ipynb
+++ /dev/null
@@ -1,458 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Multi-Reference Quantum Krylov Algorithm (H2 Example)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Package installs\n",
-    "!pip install pyscf==2.6.2\n",
-    "!pip install openfermionpyscf==0.5\n",
-    "!pip install openfermion==1.6.1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import cudaq\n",
-    "import numpy as np\n",
-    "import scipy\n",
-    "\n",
-    "# Single-node, single gpu\n",
-    "cudaq.set_target(\"nvidia\")\n",
-    "multi_gpu = False\n",
-    "\n",
-    "# Single-node, multi-GPU\n",
-    "#cudaq.set_target(\"nvidia\", option='mqpu,fp64')\n",
-    "#multi_gpu = True\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ground state energy (classical simulation)=  (-1.1371757102406843+0j) , index=  3\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Define H2 molecule\n",
-    "geometry = [('H', (0.0, 0.0, 0.0)), ('H', (0.0, 0.0, 0.7474))]\n",
-    "\n",
-    "hamiltonian, data = cudaq.chemistry.create_molecular_hamiltonian(\n",
-    "    geometry, 'sto-3g', 1, 0)\n",
-    "\n",
-    "electron_count = data.n_electrons\n",
-    "qubits_num = 2 * data.n_orbitals\n",
-    "\n",
-    "spin_ham_matrix = hamiltonian.to_matrix()\n",
-    "e, c = np.linalg.eig(spin_ham_matrix)\n",
-    "\n",
-    "# Find the ground state energy and the corresponding eigenvector\n",
-    "print('Ground state energy (classical simulation)= ', np.min(e), ', index= ',\n",
-    "      np.argmin(e))\n",
-    "min_indices = np.argmin(e)\n",
-    "\n",
-    "# Eigen vector can be used to initialize the qubits\n",
-    "vec = c[:, min_indices]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Collect coefficients from a spin operator so we can pass them to a kernel\n",
-    "def termCoefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
-    "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
-    "    return result\n",
-    "\n",
-    "\n",
-    "# Collect Pauli words from a spin operator so we can pass them to a kernel\n",
-    "def termWords(ham: cudaq.SpinOperator) -> list[str]:\n",
-    "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
-    "    return result\n",
-    "\n",
-    "\n",
-    "coefficient = termCoefficients(hamiltonian)\n",
-    "pauli_string = termWords(hamiltonian)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@cudaq.kernel\n",
-    "def U_psi(qubits: cudaq.qview, dt: float, coefficients: list[complex],\n",
-    "          words: list[cudaq.pauli_word]):\n",
-    "    # Compute U_m = exp(-i m dt H)\n",
-    "    for i in range(len(coefficients)):\n",
-    "        exp_pauli(dt * coefficients[i].real, qubits, words[i])\n",
-    "\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def U_phi(qubits: cudaq.qview, dt: float, coefficients: list[complex],\n",
-    "          words: list[cudaq.pauli_word]):\n",
-    "    # Compute U_n = exp(-i n dt H)\n",
-    "    for i in range(len(coefficients)):\n",
-    "        exp_pauli(dt * coefficients[i].real, qubits, words[i])\n",
-    "\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def apply_pauli(qubits: cudaq.qview, word: list[int]):\n",
-    "\n",
-    "    # Add H (Hamiltonian operator)\n",
-    "    for i in range(len(word)):\n",
-    "        if word[i] == 1:\n",
-    "            x(qubits[i])\n",
-    "        if word[i] == 2:\n",
-    "            y(qubits[i])\n",
-    "        if word[i] == 3:\n",
-    "            z(qubits[i])\n",
-    "\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def qfd_kernel(dt_alpha: float, dt_beta: float, coefficients: list[complex],\n",
-    "               words: list[cudaq.pauli_word], word_list: list[int],\n",
-    "               vec: list[complex]):\n",
-    "\n",
-    "    ancilla = cudaq.qubit()\n",
-    "    qreg = cudaq.qvector(vec)\n",
-    "\n",
-    "    h(ancilla)\n",
-    "\n",
-    "    x(ancilla)\n",
-    "    cudaq.control(U_psi, ancilla, qreg, dt_alpha, coefficients, words)\n",
-    "    x(ancilla)\n",
-    "\n",
-    "    cudaq.control(apply_pauli, ancilla, qreg, word_list)\n",
-    "    cudaq.control(U_phi, ancilla, qreg, dt_beta, coefficients, words)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def pauli_str(pauli_word, qubits_num):\n",
-    "\n",
-    "    my_list = []\n",
-    "    for i in range(qubits_num):\n",
-    "        if str(pauli_word[i]) == 'I':\n",
-    "            my_list.append(0)\n",
-    "        if str(pauli_word[i]) == 'X':\n",
-    "            my_list.append(1)\n",
-    "        if str(pauli_word[i]) == 'Y':\n",
-    "            my_list.append(2)\n",
-    "        if str(pauli_word[i]) == 'Z':\n",
-    "            my_list.append(3)\n",
-    "    return my_list"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define the spin-op x for real component and y for the imaginary component.\n",
-    "\n",
-    "x_0 = cudaq.spin.x(0)\n",
-    "y_0 = cudaq.spin.y(0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#Define parameters for the quantum Krylov space\n",
-    "\n",
-    "dt = 0.5\n",
-    "\n",
-    "# Dimension of the Krylov space\n",
-    "m_qfd = 4"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compute the basis overlap matrix\n",
-    "\n",
-    "\n",
-    "## Single GPU:\n",
-    "if not multi_gpu:\n",
-    "\n",
-    "    # Add identity operator to compute overlap of basis\n",
-    "\n",
-    "    observe_op = 1.0\n",
-    "    for m in range(qubits_num):\n",
-    "        observe_op *= cudaq.spin.i(m)\n",
-    "\n",
-    "    identity_word = observe_op.to_string(False)\n",
-    "\n",
-    "    pauli_list = pauli_str(identity_word, qubits_num)\n",
-    "    #print(pauli_list)\n",
-    "\n",
-    "    wf_overlap = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
-    "\n",
-    "    for m in range(m_qfd):\n",
-    "        dt_m = dt * m\n",
-    "        for n in range(m, m_qfd):\n",
-    "            dt_n = dt * n\n",
-    "            results = cudaq.observe(qfd_kernel, [x_0, y_0], dt_m, dt_n,\n",
-    "                                    coefficient, pauli_string, pauli_list, vec)\n",
-    "            temp = [result.expectation() for result in results]\n",
-    "            wf_overlap[m, n] = temp[0] + temp[1] * 1j\n",
-    "            if n != m:\n",
-    "                wf_overlap[n, m] = np.conj(wf_overlap[m, n])\n",
-    "\n",
-    "else:\n",
-    "\n",
-    "    ## Multi-GPU\n",
-    "\n",
-    "    # Compute the basis overlap matrix\n",
-    "\n",
-    "    # Add identity operator to compute overlap of basis\n",
-    "\n",
-    "    observe_op = 1.0\n",
-    "    for m in range(qubits_num):\n",
-    "        observe_op *= cudaq.spin.i(m)\n",
-    "\n",
-    "    identity_word = observe_op.to_string(False)\n",
-    "\n",
-    "    pauli_list = pauli_str(identity_word, qubits_num)\n",
-    "    #print(pauli_list)\n",
-    "\n",
-    "    wf_overlap = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
-    "\n",
-    "    collect_overlap_real = []\n",
-    "    collect_overlap_img = []\n",
-    "\n",
-    "    count=0\n",
-    "    for m in range(m_qfd):\n",
-    "        dt_m = dt * m\n",
-    "        for n in range(m, m_qfd):\n",
-    "            dt_n = dt * n\n",
-    "            \n",
-    "            count_id=count%2\n",
-    "            #print(count_id)\n",
-    "            collect_overlap_real.append(cudaq.observe_async(qfd_kernel, x_0, dt_m, dt_n,\n",
-    "                                    coefficient, pauli_string, pauli_list, vec, qpu_id=count_id))\n",
-    "            \n",
-    "            collect_overlap_img.append(cudaq.observe_async(qfd_kernel, y_0, dt_m, dt_n,\n",
-    "                                    coefficient, pauli_string, pauli_list, vec, qpu_id=count_id+2))\n",
-    "            count += 1\n",
-    "\n",
-    "    tot_dim = 0\n",
-    "\n",
-    "    for n in range(m_qfd):\n",
-    "        for m in range(n,m_qfd):\n",
-    "            observe_result = collect_overlap_real[tot_dim].get()\n",
-    "            real_val = observe_result.expectation()  \n",
-    "        \n",
-    "            observe_result=collect_overlap_img[tot_dim].get()\n",
-    "            img_val=observe_result.expectation() \n",
-    "        \n",
-    "            wf_overlap[m, n] = real_val + img_val * 1j\n",
-    "            if n != m:\n",
-    "                wf_overlap[n, m] = np.conj(wf_overlap[m, n])\n",
-    "            \n",
-    "            tot_dim += 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compute the matrix Hamiltonian\n",
-    "\n",
-    "\n",
-    "## Single GPU:\n",
-    "if not multi_gpu:\n",
-    "    ham_matrx = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
-    "\n",
-    "    for m in range(m_qfd):\n",
-    "        dt_m = dt * m\n",
-    "        for n in range(m, m_qfd):\n",
-    "            dt_n = dt * n\n",
-    "\n",
-    "            tot_e = np.zeros(2)\n",
-    "            for coef, word in zip(coefficient, pauli_string):\n",
-    "                #print(coef,word)\n",
-    "\n",
-    "                pauli_list = pauli_str(word, qubits_num)\n",
-    "                #print(pauli_list)\n",
-    "\n",
-    "                results = cudaq.observe(qfd_kernel, [x_0, y_0], dt_m, dt_n,\n",
-    "                                        coefficient, pauli_string, pauli_list, vec)\n",
-    "\n",
-    "                temp = [result.expectation() for result in results]\n",
-    "                #print(temp)\n",
-    "                temp[0] = coef.real * temp[0]\n",
-    "                temp[1] = coef.imag * temp[1]\n",
-    "\n",
-    "                tot_e[0] += temp[0]\n",
-    "                tot_e[1] += temp[1]\n",
-    "\n",
-    "            ham_matrx[m, n] = tot_e[0] + tot_e[1] * 1j\n",
-    "            if n != m:\n",
-    "                ham_matrx[n, m] = np.conj(ham_matrx[m, n])\n",
-    "else:\n",
-    "    ## Multi-GPU\n",
-    "\n",
-    "    ham_matrx = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
-    "\n",
-    "\n",
-    "    for m in range(m_qfd):\n",
-    "        dt_m = dt * m\n",
-    "        for n in range(m, m_qfd):\n",
-    "            dt_n = dt * n\n",
-    "\n",
-    "            ham_matrix_real = []\n",
-    "            ham_matrix_imag = []\n",
-    "            \n",
-    "            count=0\n",
-    "            tot_e = np.zeros(2)\n",
-    "            for coef, word in zip(coefficient, pauli_string):\n",
-    "                count_id=count%2\n",
-    "                #print(coef,word)\n",
-    "\n",
-    "                pauli_list = pauli_str(word, qubits_num)\n",
-    "                #print(pauli_list)\n",
-    "\n",
-    "                ham_matrix_real.append(cudaq.observe_async(qfd_kernel, x_0, dt_m, dt_n,\n",
-    "                                        coefficient, pauli_string, pauli_list, vec, qpu_id=count_id))\n",
-    "                ham_matrix_imag.append(cudaq.observe_async(qfd_kernel, y_0, dt_m, dt_n,\n",
-    "                                        coefficient, pauli_string, pauli_list, vec, qpu_id=count_id+2))\n",
-    "\n",
-    "                count += 1\n",
-    "            \n",
-    "            i = 0\n",
-    "            for coef in coefficient:\n",
-    "                \n",
-    "                observe_result = ham_matrix_real[i].get()\n",
-    "                real_val = observe_result.expectation()  \n",
-    "        \n",
-    "                observe_result=ham_matrix_imag[i].get()\n",
-    "                img_val=observe_result.expectation() \n",
-    "                \n",
-    "                tot_e[0] += real_val * coef.real \n",
-    "                tot_e[1] += img_val * coef.imag\n",
-    "                \n",
-    "                i+=1\n",
-    "            \n",
-    "            ham_matrx[m, n] = tot_e[0] + tot_e[1] * 1j\n",
-    "            if n != m:\n",
-    "                ham_matrx[n, m] = np.conj(ham_matrx[m, n])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Diagonalize the matrix\n",
-    "\n",
-    "\n",
-    "def eig(H, s):\n",
-    "    #Solver for generalized eigenvalue problem\n",
-    "\n",
-    "    # HC = SCE\n",
-    "\n",
-    "    THRESHOLD = 1e-20\n",
-    "    s_diag, u = scipy.linalg.eig(s)\n",
-    "    s_prime = []\n",
-    "    for sii in s_diag:\n",
-    "        if np.imag(sii) > 1e-7:\n",
-    "            raise ValueError(\n",
-    "                \"S may not be hermitian, large imag. eval component.\")\n",
-    "        if np.real(sii) > THRESHOLD:\n",
-    "            s_prime.append(np.real(sii))\n",
-    "\n",
-    "    X_prime = np.zeros((len(s_diag), len(s_prime)), dtype=complex)\n",
-    "\n",
-    "    for i in range(len(s_diag)):\n",
-    "        for j in range(len(s_prime)):\n",
-    "            X_prime[i][j] = u[i][j] / np.sqrt(s_prime[j])\n",
-    "\n",
-    "    H_prime = (((X_prime.conjugate()).transpose()).dot(H)).dot(X_prime)\n",
-    "    e_prime, C_prime = scipy.linalg.eig(H_prime)\n",
-    "    C = X_prime.dot(C_prime)\n",
-    "\n",
-    "    return e_prime, C"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Energy from QFD:\n",
-      "(-1.1367554712424826+3.373828079812224e-20j)\n"
-     ]
-    }
-   ],
-   "source": [
-    "eigen_value, eigen_vect = eig(ham_matrx[0:m_qfd, 0:m_qfd], wf_overlap[0:m_qfd,\n",
-    "                                                                      0:m_qfd])\n",
-    "print('Energy from QFD:')\n",
-    "print(np.min(eigen_value))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/sphinx/examples/python/tutorials/afqmc.ipynb b/docs/sphinx/examples/python/tutorials/afqmc.ipynb
index 76d62e3014..6f150dca1d 100644
--- a/docs/sphinx/examples/python/tutorials/afqmc.ipynb
+++ b/docs/sphinx/examples/python/tutorials/afqmc.ipynb
@@ -19,21 +19,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\u001b[0m\u001b[33m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
    "source": [
     "# Package installs\n",
-    "!pip install pyscf==2.6.2\n",
-    "!pip install openfermion==1.6.1\n",
-    "!pip install ipie==0.7.1"
+    "!pip install pyscf==2.6.2 openfermion==1.6.1 ipie==0.7.1 -q"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "# Relevant imports\n",
     "\n",
@@ -59,7 +75,7 @@
     "\n",
     "# Ipie has recently added GPU support however this remains a bit tricky to use as it requires manual installation of several packages.\n",
     "# Once this is streamlined, we can set the GPU option to True in the tutorial.\n",
-    "config.update_option(\"use_gpu\", False)\n"
+    "config.update_option(\"use_gpu\", False)"
    ]
   },
   {
@@ -90,7 +106,7 @@
     "basis = \"cc-pVTZ\"\n",
     "spin = 0\n",
     "num_active_orbitals = 9\n",
-    "num_active_electrons = 12\n"
+    "num_active_electrons = 12"
    ]
   },
   {
@@ -101,7 +117,7 @@
     {
      "data": {
       "text/plain": [
-       "-224.34048064812262"
+       "-224.34048064812222"
       ]
      },
      "execution_count": 4,
@@ -120,7 +136,7 @@
     "hartee_fock.chkfile = \"afqmc_src/output.chk\"\n",
     "\n",
     "# Run Hartree-Fock.\n",
-    "hartee_fock.kernel()\n"
+    "hartee_fock.kernel()"
    ]
   },
   {
@@ -149,7 +165,6 @@
     "casci = mcscf.CASCI(hartee_fock, num_active_orbitals, num_active_electrons)\n",
     "casci.fix_spin_(ss=(molecule.spin / 2 * (molecule.spin / 2 + 1)))\n",
     "\n",
-    "\n",
     "# Executes the kernel to compute the hamiltonian in the active space.\n",
     "casci.kernel()\n",
     "\n",
@@ -165,7 +180,7 @@
     "# Compute the hamiltonian and convert it to a CUDA-Q operator.\n",
     "mol_ham = generate_hamiltonian(h1, tbi, energy_core.item())\n",
     "jw_hamiltonian = jordan_wigner(mol_ham)\n",
-    "hamiltonian, constant_term = get_cudaq_hamiltonian(jw_hamiltonian)\n"
+    "hamiltonian, constant_term = get_cudaq_hamiltonian(jw_hamiltonian)"
    ]
   },
   {
@@ -196,26 +211,25 @@
       "# Num Params: 16\n",
       "# Qubits: 18\n",
       "# N_layers: 1\n",
-      "# Energy after the VQE: -224.3901690611431\n"
+      "# Energy after the VQE: -224.3881035525103\n"
      ]
     }
    ],
    "source": [
     "# Define some options for the VQE.\n",
     "options = {\n",
-    " 'n_vqe_layers': 1,\n",
-    " 'maxiter': 100,\n",
-    " 'energy_core': constant_term,\n",
-    " 'return_final_state_vec': True\n",
+    "    'n_vqe_layers': 1,\n",
+    "    'maxiter': 100,\n",
+    "    'energy_core': constant_term,\n",
+    "    'return_final_state_vec': True\n",
     "}\n",
     "\n",
     "n_qubits = 2 * num_active_orbitals\n",
     "\n",
     "vqe = VQE(n_qubits=n_qubits,\n",
-    " num_active_electrons=num_active_electrons,\n",
-    " spin=spin,\n",
-    " options=options\n",
-    ")\n",
+    "          num_active_electrons=num_active_electrons,\n",
+    "          spin=spin,\n",
+    "          options=options)\n",
     "\n",
     "results = vqe.execute(hamiltonian)\n",
     "\n",
@@ -226,7 +240,7 @@
     "final_state_vector = results[\"state_vec\"]\n",
     "\n",
     "# Energies during the optimization loop.\n",
-    "vqe_energies = results[\"callback_energies\"]\n"
+    "vqe_energies = results[\"callback_energies\"]"
    ]
   },
   {
@@ -328,25 +342,20 @@
     "\n",
     "# Generate the input Hamiltonian for ipie from the checkpoint file from pyscf.\n",
     "ipie_hamiltonian = gen_ipie_input_from_pyscf_chk(hartee_fock.chkfile,\n",
-    "            mcscf=True,\n",
-    "            chol_cut=1e-5)\n",
-    "\n",
+    "                                                 mcscf=True,\n",
+    "                                                 chol_cut=1e-5)\n",
     "\n",
     "h1e, cholesky_vectors, e0 = ipie_hamiltonian\n",
     "\n",
-    "\n",
     "num_basis = cholesky_vectors.shape[1]\n",
     "num_chol = cholesky_vectors.shape[0]\n",
     "\n",
-    "\n",
     "system = Generic(nelec=molecule.nelec)\n",
     "\n",
-    "\n",
     "afqmc_hamiltonian = HamGeneric(\n",
-    " np.array([h1e, h1e]),\n",
-    " cholesky_vectors.transpose((1, 2, 0)).reshape((num_basis * num_basis, num_chol)),\n",
-    " e0\n",
-    ")\n"
+    "    np.array([h1e, h1e]),\n",
+    "    cholesky_vectors.transpose((1, 2, 0)).reshape(\n",
+    "        (num_basis * num_basis, num_chol)), e0)"
    ]
   },
   {
@@ -364,22 +373,18 @@
    "source": [
     "# Build the trial wavefunction from the state vector computed via VQE.\n",
     "wavefunction = get_coeff_wf(final_state_vector,\n",
-    " n_active_elec=num_active_electrons,\n",
-    " spin=spin\n",
-    ")\n",
-    "\n",
+    "                            n_active_elec=num_active_electrons,\n",
+    "                            spin=spin)\n",
     "\n",
     "trial = ParticleHole(wavefunction,\n",
-    " molecule.nelec,\n",
-    " num_basis,\n",
-    " num_dets_for_props=len(wavefunction[0]),\n",
-    " verbose=False\n",
-    ")\n",
-    "\n",
+    "                     molecule.nelec,\n",
+    "                     num_basis,\n",
+    "                     num_dets_for_props=len(wavefunction[0]),\n",
+    "                     verbose=False)\n",
     "\n",
     "trial.compute_trial_energy = True\n",
     "trial.build()\n",
-    "trial.half_rotate(afqmc_hamiltonian)\n"
+    "trial.half_rotate(afqmc_hamiltonian)"
    ]
   },
   {
@@ -408,43 +413,40 @@
      "text": [
       "# random seed is 96264512\n",
       "            Block                   Weight            WeightFactor            HybridEnergy                  ENumer                  EDenom                  ETotal                  E1Body                  E2Body\n",
-      "                0   1.0000000000000000e+02  1.0000000000000000e+02  0.0000000000000000e+00 -2.2440857214519274e+04  1.0000000000000000e+02 -2.2440857214519275e+02 -3.7639365236571126e+02  1.5198508022051851e+02\n",
-      "                1   4.2236163323978462e+02  1.4108003803708052e+03 -1.1705550836048852e+02 -2.2476129978632798e+04  9.9999999999999986e+01 -2.2476129978632804e+02 -3.7647651634374250e+02  1.5171521655741444e+02\n",
-      "                2   1.0031021642240592e+02  3.8270298551287897e+02 -1.1736348706942081e+02 -2.2491539833590265e+04  1.0000000000000001e+02 -2.2491539833590261e+02 -3.7652287235836400e+02  1.5160747402246139e+02\n",
-      "                3   9.9896411716010476e+01  1.0006803820092617e+02 -1.1729991834244650e+02 -2.2498086858011950e+04  1.0000000000000001e+02 -2.2498086858011945e+02 -3.7661217900078998e+02  1.5163131042067059e+02\n",
-      "                4   1.0008819642734720e+02  1.0003952238189274e+02 -1.1741988525943451e+02 -2.2497768126542338e+04  1.0000000000000001e+02 -2.2497768126542334e+02 -3.7677859321228260e+02  1.5180091194685932e+02\n",
-      "                5   9.9996395539611001e+01  1.0010162124437146e+02 -1.1745900551679516e+02 -2.2504859704025963e+04  1.0000000000000003e+02 -2.2504859704025955e+02 -3.7665382466690920e+02  1.5160522762664974e+02\n",
-      "                6   1.0011117020963695e+02  1.0017267435124782e+02 -1.1762740654751367e+02 -2.2514761055266557e+04  1.0000000000000000e+02 -2.2514761055266558e+02 -3.7663824192346226e+02  1.5149063137079673e+02\n",
-      "                7   9.9926957189505018e+01  9.9904869631265882e+01 -1.1757145502349162e+02 -2.2517665690169804e+04  1.0000000000000000e+02 -2.2517665690169804e+02 -3.7662872023157632e+02  1.5145206332987829e+02\n",
-      "                8   9.9902183781120897e+01  9.9910184942535295e+01 -1.1753639400107765e+02 -2.2518490004346189e+04  9.9999999999999986e+01 -2.2518490004346194e+02 -3.7677944704924283e+02  1.5159454700578092e+02\n",
-      "                9   1.0011182782239581e+02  1.0010647250586344e+02 -1.1771801521929217e+02 -2.2513893408438777e+04  1.0000000000000001e+02 -2.2513893408438773e+02 -3.7679469177919265e+02  1.5165575769480495e+02\n",
-      "               10   9.9639946364053955e+01  9.9242085331654422e+01 -1.1742082647888712e+02 -2.2519016506034994e+04  1.0000000000000003e+02 -2.2519016506034987e+02 -3.7690149012513956e+02  1.5171132506478972e+02\n"
+      "                0   1.0000000000000000e+02  1.0000000000000000e+02  0.0000000000000000e+00 -2.2437583763935545e+04  1.0000000000000000e+02 -2.2437583763935547e+02 -3.7639365190228011e+02  1.5201781426292453e+02\n",
+      "                1   4.2276634193515412e+02  1.4127560668989827e+03 -1.1711742028818304e+02 -2.2473358126540003e+04  9.9999999999999986e+01 -2.2473358126540006e+02 -3.7646854013277283e+02  1.5173495886737268e+02\n",
+      "                2   1.0031922288872407e+02  3.8320523739865604e+02 -1.1743088014788954e+02 -2.2489226882493567e+04  1.0000000000000001e+02 -2.2489226882493563e+02 -3.7650504938463922e+02  1.5161278055970348e+02\n",
+      "                3   9.9900990681040355e+01  1.0008400623205630e+02 -1.1736864885170948e+02 -2.2495677577437204e+04  9.9999999999999972e+01 -2.2495677577437212e+02 -3.7659644834889821e+02  1.5163967257452603e+02\n",
+      "                4   1.0009188692360159e+02  1.0005173726372723e+02 -1.1748969527283802e+02 -2.2495531836556856e+04  1.0000000000000001e+02 -2.2495531836556853e+02 -3.7675907314082951e+02  1.5180375477526098e+02\n",
+      "                5   9.9997269300807844e+01  1.0010618465796188e+02 -1.1752703012577417e+02 -2.2502732667629320e+04  1.0000000000000001e+02 -2.2502732667629317e+02 -3.7663343013337044e+02  1.5160610345707727e+02\n",
+      "                6   1.0012131352337956e+02  1.0019003056579172e+02 -1.1770170647504112e+02 -2.2513369839216481e+04  1.0000000000000000e+02 -2.2513369839216480e+02 -3.7660812717909516e+02  1.5147442878693036e+02\n",
+      "                7   9.9936984461419740e+01  9.9929966800671224e+01 -1.1765353928750643e+02 -2.2516138533920657e+04  1.0000000000000000e+02 -2.2516138533920659e+02 -3.7660292355465600e+02  1.5144153821544941e+02\n",
+      "                8   9.9902337463172714e+01  9.9910800755312891e+01 -1.1761532255317621e+02 -2.2518524275281430e+04  9.9999999999999986e+01 -2.2518524275281433e+02 -3.7674246483479845e+02  1.5155722208198404e+02\n",
+      "                9   1.0012943675389775e+02  1.0013880643723378e+02 -1.1780913595074867e+02 -2.2512465963277762e+04  1.0000000000000000e+02 -2.2512465963277762e+02 -3.7677999264623367e+02  1.5165533301345607e+02\n",
+      "               10   9.9628730363609819e+01  9.9223106824565718e+01 -1.1749814144939067e+02 -2.2517668156221851e+04  1.0000000000000000e+02 -2.2517668156221850e+02 -3.7688306341863290e+02  1.5170638185641434e+02\n"
      ]
     }
    ],
    "source": [
     "# Setup the AFQMC parameters.\n",
     "afqmc_msd = AFQMC.build(molecule.nelec,\n",
-    " afqmc_hamiltonian,\n",
-    " trial,\n",
-    " num_walkers=100,\n",
-    " num_steps_per_block=25,\n",
-    " num_blocks=10,\n",
-    " timestep=0.005,\n",
-    " stabilize_freq=5,\n",
-    " seed=96264512,\n",
-    " pop_control_freq=5,\n",
-    " verbose=False\n",
-    ")\n",
-    "\n",
+    "                        afqmc_hamiltonian,\n",
+    "                        trial,\n",
+    "                        num_walkers=100,\n",
+    "                        num_steps_per_block=25,\n",
+    "                        num_blocks=10,\n",
+    "                        timestep=0.005,\n",
+    "                        stabilize_freq=5,\n",
+    "                        seed=96264512,\n",
+    "                        pop_control_freq=5,\n",
+    "                        verbose=False)\n",
     "\n",
     "# Run the AFQMC.\n",
-    "afqmc_msd.run(estimator_filename = 'afqmc_src/estimates.0.h5')\n",
+    "afqmc_msd.run(estimator_filename='afqmc_src/estimates.0.h5')\n",
     "afqmc_msd.finalise(verbose=False)\n",
     "\n",
-    "\n",
     "# Extract the energies.\n",
-    "qmc_data = extract_observable(afqmc_msd.estimators.filename, \"energy\")\n"
+    "qmc_data = extract_observable(afqmc_msd.estimators.filename, \"energy\")"
    ]
   },
   {
@@ -455,7 +457,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7ab848ece110>"
+       "<matplotlib.legend.Legend at 0x7fea847f35e0>"
       ]
      },
      "execution_count": 10,
@@ -464,7 +466,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -486,7 +488,7 @@
     "\n",
     "plt.xlabel(\"Optimization steps\")\n",
     "plt.ylabel(\"Energy [Ha]\")\n",
-    "plt.legend()\n"
+    "plt.legend()"
    ]
   },
   {
@@ -498,7 +500,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CUDA-Q Version proto-0.8.0 (https://github.com/NVIDIA/cuda-quantum 57e1893b9a5b57ef1a1c2662bcf4527f87b9ef89)\n"
+      "CUDA-Q Version latest (https://github.com/NVIDIA/cuda-quantum 176f1e7df8a58c2dc3d6b1b47bf7f63b4b8d3b63)\n"
      ]
     }
    ],
diff --git a/docs/sphinx/examples/python/tutorials/afqmc_src/estimates.0.h5 b/docs/sphinx/examples/python/tutorials/afqmc_src/estimates.0.h5
new file mode 100644
index 0000000000..4775df7bf9
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/afqmc_src/estimates.0.h5 differ
diff --git a/docs/sphinx/examples/python/tutorials/afqmc_src/output.chk b/docs/sphinx/examples/python/tutorials/afqmc_src/output.chk
new file mode 100644
index 0000000000..9cca188393
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/afqmc_src/output.chk differ
diff --git a/docs/sphinx/examples/python/tutorials/bernstein_vazirani.ipynb b/docs/sphinx/examples/python/tutorials/bernstein_vazirani.ipynb
new file mode 100644
index 0000000000..38c6d26893
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/bernstein_vazirani.ipynb
@@ -0,0 +1,257 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "29b3f948-cc6a-4776-ad75-1dc259e0c298",
+   "metadata": {},
+   "source": [
+    "# The Bernstein-Vazirani Algorithm\n",
+    "\n",
+    "The Bernstein-Vazirani (BV) algorithm demonstrates an exponential speedup over classical methods for the particular task: \n",
+    "\n",
+    "Suppose we have an oracle that implements the function $f: \\{0,1\\}^n \\longrightarrow \\{0,1\\}$. \n",
+    "\n",
+    "$f(x)$ is promised to be the dot product between $x$ and a secret $n$-bit binary string $s$:\n",
+    "\n",
+    "$f(x) = x \\cdot s (mod \\space 2) =  (x_1s_1 + x_2s_2 + ... + x_ns_n) (mod \\space 2)$.\n",
+    "\n",
+    "Our goal is to find the secret string $s$.\n",
+    "\n",
+    "### Classical case\n",
+    "\n",
+    "For the case of $n=3$ consider $s=101$, which is a secret string and hence we dont have access to it. \n",
+    "\n",
+    "We have access to the function: $f(x) = x\\cdot s (mod \\space 2) = (x_1s_1 + x_2s_2 + x_3s_3) (mod \\space 2)$\n",
+    "\n",
+    "Let us strategically query the function to determine $s$. \n",
+    "\n",
+    "$1^{st}$ query: $f(001) = 001 \\cdot s (mod \\space 2) = (0 \\cdot 1 + 0 \\cdot 0 + 1 \\cdot 1)(mod \\space 2) = 1 (mod \\space 2) = 1$\n",
+    "\n",
+    "$2^{nd}$ query: $f(010) = 010 \\cdot s (mod \\space 2) = (0 \\cdot 1 + 1 \\cdot 0 + 0 \\cdot 1)(mod \\space 2) = 0 (mod \\space 2) = 0$\n",
+    "\n",
+    "$3^{rd}$ query: $f(100) = 100 \\cdot s (mod \\space 2) = (1 \\cdot 1 + 0 \\cdot 0 + 0 \\cdot 1)(mod \\space 2) = 1 (mod \\space 2) = 1$\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "Remember that from a user perspective, you only see $f(001) = 1$ since the inner mechanisms of the oracle and the value of $s$ is hidden from you. \n",
+    "\n",
+    "Why did we query $f(001)$ and not $f(011)$?\n",
+    "\n",
+    "For $f(001) = (x_1s_1 + x_2s_2 + x_3s_3) (mod \\space 2) = (0 + 0 + x_3s_3) (mod \\space 2) = (x_3s_3) (mod \\space 2) = 1 \\cdot s_3 (mod \\space 2) = s_3 (mod \\space 2) = 1$\n",
+    "\n",
+    "We have now isolated $s_3$ and know that $s_3 (mod \\space 2) = 1$. $s_3$ can only be 0 or 1 and in this case it has to be $1$ since $0 (mod \\space 2) = 0$. \n",
+    "\n",
+    "For $f(011) = (x_2s_2 + x_3s_3) (mod \\space 2)$, we will be left with $s_2$ and $s_3$ each of which will be more difficult to isolate via a combination of linear equations. Hence why we have to strategically query the function. \n",
+    "\n",
+    "In the classical case, we see that the secret string $s$ can be calculated in 3 queries. More generally speaking, it would take $n$ queries to generate enough information to determine $s$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ebdfe818",
+   "metadata": {},
+   "source": [
+    "### Quantum case\n",
+    "\n",
+    "The BV quantum algorithm can take advantage of superposition and entanglement to encode the problem and produce an answer with a single oracle (black box function) query. The setup is a register of $n$ qubits in the $\\ket{0}$ state and a single auxiliary qubit in the $\\ket{1}$ state. The auxiliary qubit enables the phase kickback. Consider the register of $n$ qubits initialized here:\n",
+    "\n",
+    "$$ \\ket{0} $$\n",
+    "\n",
+    "Application of a Hadamard gate to each qubit results in:\n",
+    "$$ H \\ket{0}  = \\frac{1}{\\sqrt{2^n}}\\sum_x^{n-1} \\ket{x}$$\n",
+    "\n",
+    "Next, the oracle, $U_f$, performs maps $\\ket{x}$ to $(-1)^{f(x)}\\ket{x}$ resulting in:\n",
+    "\n",
+    "$$ U_f \\frac{1}{\\sqrt{2^n}}\\sum_x^{n-1} \\ket{x} = \\frac{1}{\\sqrt{2^n}}\\sum_x^{n-1} (-1)^{f(x)}\\ket{x} =\\frac{1}{\\sqrt{2^n}}\\sum_x^{n-1} (-1)^{a*x}\\ket{x} $$\n",
+    "\n",
+    "Applying Hadamard gates again returns the following state:\n",
+    "$$ H \\frac{1}{\\sqrt{2^n}}\\sum_x^{n-1} (-1)^{a*x}\\ket{x}  =  \\frac{1}{\\sqrt{2^n}}\\sum_{x,y}^{n-1} (-1)^{a*x} (-1)^{y*x} \\ket{y}  = \\frac{1}{\\sqrt{2^n}}\\sum_{y}^{n-1} \\sum_{x}^{n-1} (-1)^{(a \\oplus y)*x}\\ket{y} $$\n",
+    "\n",
+    "In the case of $a \\neq y$, the entire term becomes zero. In the case of $a = y$, the state $\\ket{a}$ is returned with an amplitude of 1.  This means there is a 100% chance of the measurement result being the hidden bitstring $a$ with only one call to the oracle!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0fdbba1e-8eab-42a2-8964-6d7e86db0ad4",
+   "metadata": {},
+   "source": [
+    "### Implementing in CUDA-Q\n",
+    "\n",
+    "The cell below generates a random bitstring of length $n$. If you are running this on your CPU, keep the qubit count small and increase to around 30 if you are running on a GPU with the `nvidia` backend."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "883762a1-d271-4692-adad-d64daa20805d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cudaq\n",
+    "from typing import List\n",
+    "\n",
+    "cudaq.set_target('qpp-cpu')\n",
+    "# cudaq.set_target('nvidia')  # GPU backend which enables scaling to large problem sizes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d72225e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qubit_count = 5  # Set to around 30 qubits if you have GPU access\n",
+    "\n",
+    "secret_string = [1, 1, 0, 1,\n",
+    "                 0]  # Change the secret string to whatever you prefer\n",
+    "\n",
+    "assert qubit_count == len(secret_string)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3df178fe-ccf3-41aa-b5f7-037a1a1d4a69",
+   "metadata": {},
+   "source": [
+    "Next, the oracle kernel is defined. This will be used inside of the primary BV kernel, so it needs to take both the main register and auxiliary qubit as inputs as well as the secret bitstring. The oracle loops through the bits and applies a CNOT on the auxiliary qubit if the register qubit is a 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "91dbde75-486b-4015-9627-9ff404bdb475",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def oracle(register: cudaq.qview, auxiliary_qubit: cudaq.qubit,\n",
+    "           secret_string: List[int]):\n",
+    "\n",
+    "    for index, bit in enumerate(secret_string):\n",
+    "        if bit == 1:\n",
+    "            x.ctrl(register[index], auxiliary_qubit)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "685bb02e-afdc-4b69-afb4-81af9c2fafbd",
+   "metadata": {},
+   "source": [
+    "The code below performs the steps described above for the BV algorithm, calling the oracle kernel as needed. You can see the circuit created below and verify that the procedure guessed the correct bitstring. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d93cb1db-b5c6-45ef-9efc-c426895aac18",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "     ╭───╮          ╭───╮          \n",
+      "q0 : ┤ h ├───────●──┤ h ├──────────\n",
+      "     ├───┤       │  ╰───╯╭───╮     \n",
+      "q1 : ┤ h ├───────┼────●──┤ h ├─────\n",
+      "     ├───┤       │    │  ├───┤     \n",
+      "q2 : ┤ h ├───────┼────┼──┤ h ├─────\n",
+      "     ├───┤       │    │  ╰───╯╭───╮\n",
+      "q3 : ┤ h ├───────┼────┼────●──┤ h ├\n",
+      "     ├───┤       │    │    │  ├───┤\n",
+      "q4 : ┤ h ├───────┼────┼────┼──┤ h ├\n",
+      "     ├───┤╭───╮╭─┴─╮╭─┴─╮╭─┴─╮╰───╯\n",
+      "q5 : ┤ x ├┤ h ├┤ x ├┤ x ├┤ x ├─────\n",
+      "     ╰───╯╰───╯╰───╯╰───╯╰───╯     \n",
+      "\n",
+      "secret bitstring = [1, 1, 0, 1, 0]\n",
+      "measured state = 11010\n",
+      "Were we successful? True\n"
+     ]
+    }
+   ],
+   "source": [
+    "@cudaq.kernel\n",
+    "def bernstein_vazirani(secret_string: List[int]):\n",
+    "\n",
+    "    qubits = cudaq.qvector(len(secret_string))  # register of size n\n",
+    "    auxiliary_qubit = cudaq.qubit()  # auxiliary qubit\n",
+    "\n",
+    "    # Prepare the auxillary qubit.\n",
+    "    x(auxiliary_qubit)\n",
+    "    h(auxiliary_qubit)\n",
+    "\n",
+    "    # Place the rest of the register in a superposition state.\n",
+    "    h(qubits)\n",
+    "\n",
+    "    # Query the oracle.\n",
+    "    oracle(qubits, auxiliary_qubit, secret_string)\n",
+    "\n",
+    "    # Apply another set of Hadamards to the register.\n",
+    "    h(qubits)\n",
+    "\n",
+    "    mz(qubits)  # measures only the main register\n",
+    "\n",
+    "\n",
+    "print(cudaq.draw(bernstein_vazirani, secret_string))\n",
+    "result = cudaq.sample(bernstein_vazirani, secret_string)\n",
+    "\n",
+    "print(f\"secret bitstring = {secret_string}\")\n",
+    "print(f\"measured state = {result.most_probable()}\")\n",
+    "print(\n",
+    "    f\"Were we successful? {''.join([str(i) for i in secret_string]) == result.most_probable()}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "388592de-3b47-45f4-b687-72abed6fdf8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CUDA-Q Version latest (https://github.com/NVIDIA/cuda-quantum 176f1e7df8a58c2dc3d6b1b47bf7f63b4b8d3b63)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(cudaq.__version__)"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/tutorials/cost_minimization.ipynb b/docs/sphinx/examples/python/tutorials/cost_minimization.ipynb
index 9bef09f466..888f287b72 100644
--- a/docs/sphinx/examples/python/tutorials/cost_minimization.ipynb
+++ b/docs/sphinx/examples/python/tutorials/cost_minimization.ipynb
@@ -16,7 +16,16 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "import cudaq\n",
     "from typing import List\n",
@@ -33,12 +42,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "                       \n",
-      "q0 : ──────────────────\n",
-      "                       \n",
-      "q1 : ──────────────────\n",
       "     ╭───────╮╭───────╮\n",
-      "q2 : ┤ rx(0) ├┤ ry(0) ├\n",
+      "q0 : ┤ rx(0) ├┤ ry(0) ├\n",
       "     ╰───────╯╰───────╯\n",
       "\n"
      ]
@@ -129,15 +134,6 @@
     "result = optimizer.optimize(dimensions=2, function=cost)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# %pip install matplotlib"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -159,7 +155,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -206,7 +202,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]"
+   "version": "3.10.12"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/docs/sphinx/examples/python/tutorials/deutschs_algorithm.ipynb b/docs/sphinx/examples/python/tutorials/deutschs_algorithm.ipynb
index ad86630b41..feaacacd9d 100644
--- a/docs/sphinx/examples/python/tutorials/deutschs_algorithm.ipynb
+++ b/docs/sphinx/examples/python/tutorials/deutschs_algorithm.ipynb
@@ -298,7 +298,16 @@
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "# Import the CUDA-Q package and set the target to run on NVIDIA GPUs.\n",
     "\n",
diff --git a/docs/sphinx/examples/python/tutorials/digitized_counterdiabatic_qaoa.ipynb b/docs/sphinx/examples/python/tutorials/digitized_counterdiabatic_qaoa.ipynb
new file mode 100644
index 0000000000..9e785b5313
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/digitized_counterdiabatic_qaoa.ipynb
@@ -0,0 +1,429 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Molecular docking via DC-QAOA\n",
+    "\n",
+    "Drugs often work by binding to an active site of a protein, inhibiting or activating its function for some therapeutic purpose. Finding new candidate drugs is extremely difficult. The study of molecular docking helps guide this search and involves the prediction of how strongly a certain ligand (drug) will bind to its target (usually a protein).  \n",
+    "\n",
+    "One of the primary challenges to molecular docking arises from the many geometric degrees of freedom present in proteins and ligands, making it difficult to predict the optimal orientation and assess if the drug is a good candidate or not. One solution is to formulate the problem as a mathematical optimization problem where the optimal solution corresponds to the most likely ligand-protein configuration. This optimization problem can be solved on a quantum computer using methods like the Quantum Approximate Optimization Algorithm (QAOA). This tutorial demonstrates how this [paper](https://arxiv.org/pdf/2308.04098) used digitized-counteradiabatic (DC) QAOA to study molecular docking.  This tutorial assumes you have an understanding of QAOA, if not, please the CUDA-Q MaxCut tutorial found [here](https://nvidia.github.io/cuda-quantum/latest/examples/python/tutorials/qaoa.html)\n",
+    "\n",
+    "The next section provides more detail on the problem setup followed by CUDA-Q implementations below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setting up the Molecular Docking Problem\n",
+    "\n",
+    "The figure from the [paper](https://arxiv.org/pdf/2308.04098) provides a helpful diagram for understanding the workflow.\n",
+    "\n",
+    "![docking](./images/docking.png)\n",
+    "\n",
+    "\n",
+    "There are 6 key steps:\n",
+    "1.  The experimental protein and ligand structures are determined and used to select pharmacores, or an important chemical group that will govern the chemical interactions,\n",
+    "2. T wo labeled distance graphs (LAGs) of size $N$ and $M$ represent the protein and the ligand, respectively. Each node corresponds to a pharmacore and each edge weight corresponds to the distance between pharmacores.\n",
+    "3.  A $M*N$ node binding interaction graph (BIG) is created from the LAGs. Each node in the BIG graph corresponds to a pair of pharmacores, one from the ligand and the other from the protein. The existence of edges between nodes in the BIG graph are determined from the LAGs and correspond to interactions that can feesibly coexist. Therefore, cliques in the graph correspond to mutually possible interactions. \n",
+    "4. The problem is mapped to a QAOA circuit and corresponding Hamiltonian, and the ground state solution is determined.\n",
+    "5.  The ground state will produce the maximum weighted clique which corresponds to the best (most strongly bound) orientation of the ligand and protein.\n",
+    "6.  The predicted docking structure is interpreted from the QAOA result and is used for further analysis.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### CUDA-Q Implementation\n",
+    "\n",
+    "First, the appropriate libraries are imported and the `nvidia` backend is selected to run on GPUs if available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "from cudaq import spin\n",
+    "import numpy as np\n",
+    "\n",
+    "# cudaq.set_target('nvidia')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The block below defines two of the BIG data sets from the paper. The first is a smaller example, but it can be swapped with the commented out example below at your discretion. The weights are specified for each node based on the nature of the ligand and protein pharmacores represented by the node"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Edges:  [[0, 1], [0, 2], [0, 4], [0, 5], [1, 2], [1, 3], [1, 5], [2, 3], [2, 4], [3, 4], [3, 5], [4, 5]]\n",
+      "Non-Edges:  [[0, 3], [1, 4], [2, 5]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The two graphs input from the paper\n",
+    "\n",
+    "# BIG 1\n",
+    "\n",
+    "nodes = [0, 1, 2, 3, 4, 5]\n",
+    "qubit_num = len(nodes)\n",
+    "edges = [[0, 1], [0, 2], [0, 4], [0, 5], [1, 2], [1, 3], [1, 5], [2, 3], [2, 4],\n",
+    "         [3, 4], [3, 5], [4, 5]]\n",
+    "non_edges = [\n",
+    "    [u, v] for u in nodes for v in nodes if u < v and [u, v] not in edges\n",
+    "]\n",
+    "\n",
+    "print('Edges: ', edges)\n",
+    "print('Non-Edges: ', non_edges)\n",
+    "\n",
+    "weights = [0.6686, 0.6686, 0.6686, 0.1453, 0.1453, 0.1453]\n",
+    "penalty = 6.0\n",
+    "num_layers = 3\n",
+    "\n",
+    "# BIG 2 (More expensive simulation)\n",
+    "#nodes=[0,1,2,3,4,5,6,7]\n",
+    "#qubit_num=len(nodes)\n",
+    "#edges=[[0,1],[0,2],[0,5],[0,6],[0,7],[1,2],[1,4],[1,6],[1,7],[2,4],[2,5],[2,7],[3,4],[3,5],[3,6],\\\n",
+    "#    [4,5],[4,6],[5,6]]\n",
+    "#non_edges=[[u,v] for u in nodes for v in nodes if u<v and [u,v] not in edges]\n",
+    "#print('Edges: ', edges)\n",
+    "#print('Non-edges: ', non_edges)\n",
+    "#weights=[0.6686,0.6686,0.6886,0.1091,0.0770,0.0770,0.0770,0.0770]\n",
+    "#penalty=8.0\n",
+    "#num_layers=8"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, the Hamiltonian is constructed. \n",
+    "\n",
+    "$$H = \\frac{1}{2}\\sum_{i \\in V}w_i(\\sigma^z_i - 1) + \\frac{P}{4} \\sum_{(i,j) \\notin E, i \\neq j} (\\sigma^z_i -1)(\\sigma^z_j - 1) $$\n",
+    "\n",
+    "\n",
+    "The first term concerns the vertices and the weights of the given pharmacores.  The second term is a penalty term that penalizes edges of the graph with no interactions.  The penalty $P$ is set by the user and is defined as 6 in the cell above. The function below returns the Hamiltonina as a CUDA-Q `spin_op` object.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate the Hamiltonian\n",
+    "def ham_clique(penalty, nodes, weights, non_edges) -> cudaq.SpinOperator:\n",
+    "\n",
+    "    spin_ham = 0.0\n",
+    "    for wt, node in zip(weights, nodes):\n",
+    "        #print(wt,node)\n",
+    "        spin_ham += 0.5 * wt * spin.z(node)\n",
+    "        spin_ham -= 0.5 * wt * spin.i(node)\n",
+    "\n",
+    "    for non_edge in non_edges:\n",
+    "        u, v = (non_edge[0], non_edge[1])\n",
+    "        #print(u,v)\n",
+    "        spin_ham += penalty / 4.0 * (spin.z(u) * spin.z(v) - spin.z(u) -\n",
+    "                                     spin.z(v) + spin.i(u) * spin.i(v))\n",
+    "\n",
+    "    return spin_ham"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The code below strips the Hamiltonian into a list of coefficients and corresponding Pauli words which can be passed into a quantum kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.5+0j] IIZIIZ\n",
+      "[1.5+0j] ZIIZII\n",
+      "[-1.1657+0j] IZIIII\n",
+      "[1.5+0j] IZIIZI\n",
+      "[-1.42735+0j] IIIZII\n",
+      "[3.2791499999999996+0j] IIIIII\n",
+      "[-1.1657+0j] IIZIII\n",
+      "[-1.42735+0j] IIIIIZ\n",
+      "[-1.1657+0j] ZIIIII\n",
+      "[-1.42735+0j] IIIIZI\n",
+      "\n",
+      "[(1.5+0j), (1.5+0j), (-1.1657+0j), (1.5+0j), (-1.42735+0j), (3.2791499999999996+0j), (-1.1657+0j), (-1.42735+0j), (-1.1657+0j), (-1.42735+0j)]\n",
+      "['IIZIIZ', 'ZIIZII', 'IZIIII', 'IZIIZI', 'IIIZII', 'IIIIII', 'IIZIII', 'IIIIIZ', 'ZIIIII', 'IIIIZI']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Collect coefficients from a spin operator so we can pass them to a kernel\n",
+    "def term_coefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    return result\n",
+    "\n",
+    "    # Collect Pauli words from a spin operator so we can pass them to a kernel\n",
+    "\n",
+    "\n",
+    "def term_words(ham: cudaq.SpinOperator) -> list[str]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "ham = ham_clique(penalty, nodes, weights, non_edges)\n",
+    "print(ham)\n",
+    "\n",
+    "coef = term_coefficients(ham)\n",
+    "words = term_words(ham)\n",
+    "\n",
+    "print(term_coefficients(ham))\n",
+    "print(term_words(ham))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The kernel below defines a DC-QAOA circuit.  What makes the approach \"DC\" is the inclusion of additional counteradiabatic terms to better drive the optimization to the ground state. These terms are digitized and applied as additional operations following each QAOA layer.  The increase in parameters is hopefully offset by requiring fewer layers. In this example, the DC terms are additional parameterized $Y$ operations applied to each qubit. These can be commented out to run conventional QAOA."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def dc_qaoa(qubit_num:int, num_layers:int, thetas:list[float],\\\n",
+    "    coef:list[complex], words:list[cudaq.pauli_word]):\n",
+    "\n",
+    "    qubits = cudaq.qvector(qubit_num)\n",
+    "\n",
+    "    h(qubits)\n",
+    "\n",
+    "    count = 0\n",
+    "    for p in range(num_layers):\n",
+    "\n",
+    "        for i in range(len(coef)):\n",
+    "            exp_pauli(thetas[count] * coef[i].real, qubits, words[i])\n",
+    "            count += 1\n",
+    "\n",
+    "        for j in range(qubit_num):\n",
+    "            rx(thetas[count], qubits[j])\n",
+    "            count += 1\n",
+    "\n",
+    "        #Comment out this for loop for conventional QAOA\n",
+    "        for k in range(qubit_num):\n",
+    "            ry(thetas[count], qubits[k])\n",
+    "            count += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The classical optimizer for the QAOA procedure can be specified as one of the build in CUDA-Q optimizers, in this case Nelder Mead. The parameter count is defined for DC-QAOA, but can be swapped with the commented line below for conventional QAOA."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total number of parameters:  66\n",
+      "Initial parameters =  [0.21810696323572243, -0.20613464375211488, 0.2546877639814583, 0.3657985647468064, 0.37118004688049144, -0.03656087558321203, 0.08564174998504231, 0.21639801853794682, 0.11122286088634259, 0.1743727097033635, -0.36518146001762486, -0.15829741539542244, -0.3467434780387345, 0.28043500852894776, -0.09986021299050934, 0.14125225086023052, -0.19141728018199775, -0.11970943368650361, -0.3853063093646483, -0.1112643868789806, 0.3527177454825464, -0.22156160012057186, -0.1418496891385843, 0.32811766468303116, -0.367642000671186, -0.34158180583996006, 0.10196745745501312, 0.29359239180502594, -0.3858537615546677, 0.19366130907065582, 0.24570488114056754, -0.3332307385378807, 0.12287973244618389, 0.007274514934614895, -0.015799547372526146, 0.3578070967202224, -0.39268963055535144, -0.19872246354138554, 0.16668715544467982, -0.13777293592446055, -0.17514665212709513, 0.15350249947988204, 0.32872977428061945, -0.20068831419712105, -0.032919322131134854, -0.19399909325771983, -0.09477141125241506, 0.08210460401106645, 0.21392577760158515, -0.3393568044538389, 0.14615087942938465, 0.03790339186006314, -0.2843250892879255, -0.3151384847055956, -0.19983741137121905, -0.27348611567665115, 0.33457528180906904, 0.14145414847455462, -0.20604220093940323, 0.05410235084309195, 0.04447870918600966, -0.3355714098595045, 0.266806440171265, -0.07436189654442632, -0.2789176729721685, -0.2427508182662484]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Specify the optimizer and its initial parameters.\n",
+    "optimizer = cudaq.optimizers.NelderMead()\n",
+    "\n",
+    "#Specify random seeds\n",
+    "np.random.seed(13)\n",
+    "cudaq.set_random_seed(13)\n",
+    "\n",
+    "# if dc_qaoa used\n",
+    "parameter_count = (2 * qubit_num + len(coef)) * num_layers\n",
+    "\n",
+    "# if qaoa used\n",
+    "# parameter_count=(qubit_num+len(coef))*num_layers\n",
+    "\n",
+    "print('Total number of parameters: ', parameter_count)\n",
+    "optimizer.initial_parameters = np.random.uniform(-np.pi / 8, np.pi / 8,\n",
+    "                                                 parameter_count)\n",
+    "print(\"Initial parameters = \", optimizer.initial_parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A cost function is specified which computes the expectation value of the DC-QAOA circuit and the Hamiltonian using the `observe` function. Running the optimization returns the minimized expectation value and the optimal parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "optimal_expectation = -2.0057493966746804\n",
+      "optimal_parameters = [2.0508763934174787, 0.013930789730781493, 0.5793211220774144, 0.878009560684498, 0.5277129177248182, 0.4404810513078178, 0.5755552245467919, 0.14125558672355468, 0.3724262117066903, 0.1318978057007808, -1.1228708513911436, 0.932342804955409, -0.8478237950658537, 0.46345886313018125, -0.5809397306340341, 0.2408342488137229, 0.11216088888484882, -0.009704173265255175, 0.4757346661223584, -0.7281211610985926, 0.06051951319169091, -0.7794512146826196, 0.09249435261907034, 0.09998378319110682, 1.255349350720572, 1.2607038244228248, 0.2060124032311757, 0.13991934581192997, 0.9874814082082164, -0.1591291464755939, 0.30815482837046393, -0.9701804681517978, -0.002609462845755913, 0.43533533568363353, 0.642630110681613, 0.6137063363954748, -0.7204687246344496, 0.08390768435524378, 0.5480630700433249, -0.38905723227347905, -0.6837811162838194, -0.17239016898719284, 0.1649341118754853, -0.46771209183422724, -0.008565327035838663, 1.982230359328883, -0.4232972687799105, 0.22765896988428905, 0.04207923928239914, -0.36758378917672285, -0.01825447063622079, -0.059755059728027485, -0.6849697218162497, 0.2711684382411018, -0.2904257415666667, -0.16359529445017368, -0.09168623367396612, 0.5786087806926155, -0.3476755367718726, 0.1209273564533628, 0.605136043801364, -0.19128215816141694, 0.16756583092588012, 1.0715488214105267, -0.5269641128095075, -0.3029128369198704]\n"
+     ]
+    }
+   ],
+   "source": [
+    "cost_values = []\n",
+    "\n",
+    "\n",
+    "def objective(parameters):\n",
+    "\n",
+    "    cost = cudaq.observe(dc_qaoa, ham, qubit_num, num_layers, parameters, coef,\n",
+    "                         words).expectation()\n",
+    "    cost_values.append(cost)\n",
+    "    return cost\n",
+    "\n",
+    "\n",
+    "# Optimize!\n",
+    "optimal_expectation, optimal_parameters = optimizer.optimize(\n",
+    "    dimensions=parameter_count, function=objective)\n",
+    "\n",
+    "print('optimal_expectation =', optimal_expectation)\n",
+    "print('optimal_parameters =', optimal_parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Sampling the circuit with the optimal parameters allows for the `most_probable` command to reveal the bitsting corresponding to the ideal graph partitioning solution. This indicates what sort of interactions are present in the ideal docking configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{ 110001:16 011100:4 111000:199979 011000:1 }\n",
+      "\n",
+      "The MVWCP is given by the partition:  111000\n"
+     ]
+    }
+   ],
+   "source": [
+    "shots = 200000\n",
+    "\n",
+    "counts = cudaq.sample(dc_qaoa,\n",
+    "                      qubit_num,\n",
+    "                      num_layers,\n",
+    "                      optimal_parameters,\n",
+    "                      coef,\n",
+    "                      words,\n",
+    "                      shots_count=shots)\n",
+    "print(counts)\n",
+    "\n",
+    "print('The MVWCP is given by the partition: ', counts.most_probable())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./images/partition.png\" alt=\"dockin\" width=\"300\" />"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The convergence of the optimization can be plotted below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "x_values = list(range(len(cost_values)))\n",
+    "y_values = cost_values\n",
+    "\n",
+    "plt.plot(x_values, y_values)\n",
+    "\n",
+    "plt.xlabel(\"Epochs\")\n",
+    "plt.ylabel(\"Cost Value\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/sphinx/examples/python/tutorials/Divisive_clustering.ipynb b/docs/sphinx/examples/python/tutorials/divisive_clustering_coresets.ipynb
similarity index 99%
rename from docs/sphinx/examples/python/tutorials/Divisive_clustering.ipynb
rename to docs/sphinx/examples/python/tutorials/divisive_clustering_coresets.ipynb
index bfb75e8bf4..f82d51d099 100644
--- a/docs/sphinx/examples/python/tutorials/Divisive_clustering.ipynb
+++ b/docs/sphinx/examples/python/tutorials/divisive_clustering_coresets.ipynb
@@ -50,11 +50,7 @@
    "outputs": [],
    "source": [
     "# Install the relevant packages.\n",
-    "!pip install mpi4py==3.1.6\n",
-    "!pip install networkx==2.8.8\n",
-    "!pip install pandas==2.2.2\n",
-    "!pip install scikit-learn==1.4.2\n",
-    "!pip install tqdm==4.66.2"
+    "!pip install mpi4py==3.1.6 networkx==2.8.8 pandas==2.2.2 scikit-learn==1.4.2 tqdm==4.66.2 -q"
    ]
   },
   {
@@ -66,7 +62,6 @@
     "import cudaq\n",
     "from cudaq import spin\n",
     "\n",
-    "\n",
     "# Auxillary Imports\n",
     "import os\n",
     "import numpy as np\n",
@@ -148,12 +143,13 @@
     "    coreset_method=\"BFL2\",\n",
     ")\n",
     "\n",
-    "\n",
     "coreset_vectors, coreset_weights = coreset.get_best_coresets()\n",
     "\n",
-    "coreset_df = pd.DataFrame(\n",
-    "    {\"X\": coreset_vectors[:, 0], \"Y\": coreset_vectors[:, 1], \"weights\": coreset_weights}\n",
-    ")\n",
+    "coreset_df = pd.DataFrame({\n",
+    "    \"X\": coreset_vectors[:, 0],\n",
+    "    \"Y\": coreset_vectors[:, 1],\n",
+    "    \"weights\": coreset_weights\n",
+    "})\n",
     "coreset_df[\"Name\"] = [chr(i + 65) for i in coreset_df.index]\n",
     "print(coreset_df)"
    ]
@@ -370,9 +366,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_optimizer(\n",
-    "    optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n",
-    ") -> Tuple[cudaq.optimizers.optimizer, int]:\n",
+    "def get_optimizer(optimizer: cudaq.optimizers.optimizer, max_iterations,\n",
+    "                  **kwargs) -> Tuple[cudaq.optimizers.optimizer, int]:\n",
     "    \"\"\"Returns the optimizer with the given parameters\n",
     "\n",
     "    Args:\n",
@@ -384,7 +379,8 @@
     "        tuple(cudaq.optimizers.optimizer, int): Optimizer and parameter count\n",
     "    \"\"\"\n",
     "    parameter_count = 4 * kwargs[\"circuit_depth\"] * kwargs[\"qubits\"]\n",
-    "    initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n",
+    "    initial_params = np.random.uniform(-np.pi / 8.0, np.pi / 8.0,\n",
+    "                                       parameter_count)\n",
     "    optimizer.initial_parameters = initial_params\n",
     "\n",
     "    optimizer.max_iterations = max_iterations\n",
@@ -419,6 +415,7 @@
    "outputs": [],
    "source": [
     "class DivisiveClusteringVQA(DivisiveClustering):\n",
+    "\n",
     "    def __init__(\n",
     "        self,\n",
     "        **kwargs,\n",
@@ -439,8 +436,8 @@
     "\n",
     "        \"\"\"\n",
     "        coreset_vectors_for_iteration_np, coreset_weights_for_iteration_np = (\n",
-    "            self._get_iteration_coreset_vectors_and_weights(coreset_vectors_df_for_iteration)\n",
-    "        )\n",
+    "            self._get_iteration_coreset_vectors_and_weights(\n",
+    "                coreset_vectors_df_for_iteration))\n",
     "\n",
     "        G = Coreset.coreset_to_graph(\n",
     "            coreset_vectors_for_iteration_np,\n",
@@ -457,9 +454,9 @@
     "\n",
     "        return self._get_best_bitstring(counts, G)\n",
     "\n",
-    "    def get_counts_from_simulation(\n",
-    "        self, G: nx.graph, circuit_depth: int, max_iterations: int, max_shots: int\n",
-    "    ) -> cudaq.SampleResult:\n",
+    "    def get_counts_from_simulation(self, G: nx.graph, circuit_depth: int,\n",
+    "                                   max_iterations: int,\n",
+    "                                   max_shots: int) -> cudaq.SampleResult:\n",
     "        \"\"\"\n",
     "        Runs the VQA simulation\n",
     "\n",
@@ -476,8 +473,10 @@
     "        qubits = len(G.nodes)\n",
     "        Hamiltonian = self.create_Hamiltonian(G)\n",
     "        optimizer, parameter_count = self.optimizer_function(\n",
-    "            self.optimizer, max_iterations, qubits=qubits, circuit_depth=circuit_depth\n",
-    "        )\n",
+    "            self.optimizer,\n",
+    "            max_iterations,\n",
+    "            qubits=qubits,\n",
+    "            circuit_depth=circuit_depth)\n",
     "\n",
     "        kernel = self.create_circuit(qubits, circuit_depth)\n",
     "\n",
@@ -509,12 +508,13 @@
     "            return cost\n",
     "\n",
     "        energy, optimal_parameters = optimizer.optimize(\n",
-    "            dimensions=parameter_count, function=objective_function\n",
-    "        )\n",
+    "            dimensions=parameter_count, function=objective_function)\n",
     "\n",
-    "        counts = cudaq.sample(\n",
-    "            kernel, optimal_parameters, qubits, circuit_depth, shots_count=max_shots\n",
-    "        )\n",
+    "        counts = cudaq.sample(kernel,\n",
+    "                              optimal_parameters,\n",
+    "                              qubits,\n",
+    "                              circuit_depth,\n",
+    "                              shots_count=max_shots)\n",
     "\n",
     "        return counts"
    ]
@@ -565,7 +565,8 @@
     "    coreset_to_graph_metric=\"dist\",\n",
     ")\n",
     "\n",
-    "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)"
+    "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(\n",
+    "    coreset_df)"
    ]
   },
   {
@@ -682,9 +683,10 @@
     }
    ],
    "source": [
-    "dendo.plot_clusters(\n",
-    "    clusters, colors, plot_title=\"Clusters of Coreset using VQE\", show_annotation=True\n",
-    ")"
+    "dendo.plot_clusters(clusters,\n",
+    "                    colors,\n",
+    "                    plot_title=\"Clusters of Coreset using VQE\",\n",
+    "                    show_annotation=True)"
    ]
   },
   {
@@ -715,8 +717,12 @@
     }
    ],
    "source": [
-    "vt = Voironi_Tessalation(coreset_df, clusters, colors, tesslation_by_cluster=False)\n",
-    "vt.plot_voironi(plot_title=\"Voironi Tessalation of Coreset using VQE\", show_annotation=True)"
+    "vt = Voironi_Tessalation(coreset_df,\n",
+    "                         clusters,\n",
+    "                         colors,\n",
+    "                         tesslation_by_cluster=False)\n",
+    "vt.plot_voironi(plot_title=\"Voironi Tessalation of Coreset using VQE\",\n",
+    "                show_annotation=True)"
    ]
   },
   {
@@ -807,9 +813,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "def get_optimizer(\n",
-    "    optimizer: cudaq.optimizers.optimizer, max_iterations, **kwargs\n",
-    ") -> Tuple[cudaq.optimizers.optimizer, int]:\n",
+    "def get_optimizer(optimizer: cudaq.optimizers.optimizer, max_iterations,\n",
+    "                  **kwargs) -> Tuple[cudaq.optimizers.optimizer, int]:\n",
     "    \"\"\"\n",
     "    Returns the optimizer with the given parameters\n",
     "\n",
@@ -823,7 +828,8 @@
     "    \"\"\"\n",
     "\n",
     "    parameter_count = 2 * kwargs[\"circuit_depth\"]\n",
-    "    optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0, parameter_count)\n",
+    "    optimizer.initial_parameters = np.random.uniform(-np.pi / 8.0, np.pi / 8.0,\n",
+    "                                                     parameter_count)\n",
     "    optimizer.max_iterations = max_iterations\n",
     "    return optimizer, parameter_count"
    ]
@@ -863,7 +869,8 @@
     "    coreset_to_graph_metric=\"dist\",\n",
     ")\n",
     "\n",
-    "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(coreset_df)"
+    "hierarchial_clustering_sequence = divisive_clustering.get_divisive_sequence(\n",
+    "    coreset_df)"
    ]
   },
   {
@@ -1050,11 +1057,12 @@
     "try:\n",
     "    gpu_count = int(gpu_count[0])\n",
     "except:\n",
-    "    gpu_count = 0    \n",
+    "    gpu_count = 0\n",
     "if gpu_count >= 4:\n",
     "    !mpirun -np 4 python3 divisive_clustering_src/main_divisive_clustering.py --target nvidia-mgpu --M 34\n",
     "else:\n",
-    "    print(f'Not enough GPUs found on this system ({gpu_count}) to run this step')"
+    "    print(\n",
+    "        f'Not enough GPUs found on this system ({gpu_count}) to run this step')"
    ]
   },
   {
diff --git a/docs/sphinx/examples/python/tutorials/hadamard_test.ipynb b/docs/sphinx/examples/python/tutorials/hadamard_test.ipynb
index 104d99ddb5..ad84517cee 100644
--- a/docs/sphinx/examples/python/tutorials/hadamard_test.ipynb
+++ b/docs/sphinx/examples/python/tutorials/hadamard_test.ipynb
@@ -4,81 +4,132 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Hadamard Test and Application\n",
-    "\n",
-    "Consider the observable $O$ and two generic quantum states $\\ket{\\psi}$ and $\\ket{\\phi}$. We want to calculate the quantity\n",
-    "$$\n",
-    "\\braket{\\psi | O | \\psi}.\n",
-    "$$\n",
-    "where $O$ is a Pauli operator.\n",
-    "\n",
-    "First of all we shall prepare the states $\\ket{\\psi}$ and $\\ket{\\phi}$ using a quantum circuit for each of them. So we  have\n",
-    "$$\n",
-    "\\ket{\\psi} = U_{\\psi}\\ket{0} \\qquad \\ket{\\phi} = U_{\\phi}\\ket{0}\n",
-    "$$\n",
-    "\n",
-    "Let's define an observable we want to use:\n",
-    "$$\n",
-    "O = X_1X_2\n",
-    "$$\n",
-    "\n",
-    "Now we can evaluate the matrix element using the following fact:\n",
-    "$$\n",
-    "\\bra{\\psi}O\\ket{\\phi} = \\bra{0}U_\\psi^\\dagger O U_\\phi\\ket{0}\n",
-    "$$\n",
-    "This is just an expectation value which can be solved with a simple Hadamard test. The probability to measure $0$ or $1$ in the ancilla qubit is\n",
-    "\n",
-    "$$\n",
-    "P(0) = \\frac{1}{2} \\left[ I + \\operatorname{Re} \\bra{\\psi} O \\ket{\\phi} \\right]\n",
-    "$$\n",
-    "\n",
-    "$$\n",
-    "P(1) = \\frac{1}{2} \\left[ I - \\operatorname{Re} \\bra{\\psi} O \\ket{\\phi} \\right]\n",
-    "$$\n",
-    "\n",
-    "The difference between the probability of $0$ and $1$ gives \n",
-    "\n",
-    "$$\n",
-    "\\braket{X} = P(0)-P(1) = \\operatorname{Re} \\braket{\\psi | O | \n",
-    "\\phi}.\n",
-    "$$\n",
-    "\n",
-    "Similarly, the imaginary part can be obtained from Y measurement\n",
-    "$$\n",
-    "\\braket{Y} = \\operatorname{Im} \\braket{\\psi | O | \\phi}.\n",
-    "$$\n",
-    "\n",
-    "Combining these results, the quantity $\\braket{\\psi | O | \\psi}$ is obtained."
+    "# Using the Hadamard Test to Determine Quantum Krylov Subspace Decomposition Matrix Elements\n",
+    "\n",
+    "The Hadamard test, is a quantum algorithm for estimating the expectation values and is  a useful subroutine for a number of quantum applications ranging from estimation of molecular ground state energies to quantum semidefinite programming. This tutorial will briefly introduce the Hadamard test, and demonstrate how it can be implemented in CUDA-Q and then parallelized for a Quantum Krylov Subspace Diagonalization application.\n",
+    "\n",
+    "The Hadamard test is performed using a register with an ancilla qubit in the $\\ket{0}$ state and a prepared quantum state $\\ket{\\psi}$, the following circuit can be used to extract the expectation value from measurement of the ancilla.\n",
+    "\n",
+    "\n",
+    "![Htest](./images/htest.png)\n",
+    "\n",
+    "The key insight is to note that $$P(0) = \\frac{1}{2} \\left[ I + Re \\bra{\\psi} O \\ket{\\phi} \\right]$$ and $$P(1) = \\frac{1}{2} \\left[ I - Re \\bra{\\psi} O \\ket{\\phi} \\right]$$ so their difference is equal to $$P(0)-P(1) = Re \\bra{\\psi} O \\ket{\\phi}$$\n",
+    "\n",
+    "\n",
+    "More details and a short derivation can be found [here](https://en.wikipedia.org/wiki/Hadamard_test)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What if you want to perform the Hadamard test to compute an expectation value like $\\bra{\\psi} O \\ket{\\phi}$, where $\\ket{\\psi}$ and $\\ket{\\phi}$ are different states and $O$ is a Pauli Operator? This is a common subroutine for the QKSD, where matrix elements are determined by computing expectation values between different states.\n",
+    "\n",
+    "Defining $O$ as \n",
+    "$$O = X_1X_2$$\n",
+    "\n",
+    "and given the fact that\n",
+    "$$\\ket{\\psi} = U_{\\psi}\\ket{0} \\qquad \\ket{\\phi} = U_{\\phi}\\ket{0}$$\n",
+    "\n",
+    "We can combine the state preparation steps into the operator resulting in\n",
+    "$$\\bra{\\psi}O\\ket{\\phi} = \\bra{0}U_\\psi^\\dagger O U_\\phi\\ket{0}$$\n",
+    "Which corresponds to the following circuit\n",
+    "![Htest2](./images/htestfactored.png)\n",
+    "\n",
+    "By preparing this circuit, and repeatedly measuring the ancilla qubit, allows for estimation of the expectation value as $$P(0)-P(1) = Re \\bra{\\psi} O \\ket{\\phi}$$\n",
+    "\n",
+    "\n",
+    "The following sections demonstrate how this can be performed in CUDA-Q."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Numerical result as a reference: "
+    "### Numerical result as a reference: "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before performing the Hadamard test, lets determine the exact expectation value by performing the matrix multiplications explicitly. The code below builds two CUDA-Q kernels corresponding to $\\ket{\\psi} = \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}$ and $\\ket{\\phi} = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0\\end{pmatrix}$"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np\n",
+    "from functools import reduce\n",
+    "\n",
+    "cudaq.set_target('nvidia')\n",
+    "\n",
+    "qubit_num = 2\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def psi(num: int):\n",
+    "    q = cudaq.qvector(num)\n",
+    "    h(q[1])\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def phi(n: int):\n",
+    "    q = cudaq.qvector(n)\n",
+    "    x(q[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The state vectors can be accessed using the `get_state` command and printed as numpy arrays"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Psi state:  [0.70710677+0.j 0.        +0.j 0.70710677+0.j 0.        +0.j]\n",
-      "          \n",
-      "q0 : ─────\n",
-      "     ╭───╮\n",
-      "q1 : ┤ h ├\n",
-      "     ╰───╯\n",
-      "\n",
-      "Phi state:  [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
-      "     ╭───╮\n",
-      "q0 : ┤ x ├\n",
-      "     ╰───╯\n",
+      "Psi state:  SV: [(0.707107,0), (0,0), (0.707107,0), (0,0)]\n",
       "\n",
+      "Phi state:  SV: [(0,0), (1,0), (0,0), (0,0)]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "psi_state = cudaq.get_state(psi, qubit_num)\n",
+    "print('Psi state: ', psi_state)\n",
+    "\n",
+    "phi_state = cudaq.get_state(phi, qubit_num)\n",
+    "print('Phi state: ', phi_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The Hamiltonian operator ($O$ in the derivation above) is defined as a CUDA-Q spin operator and converted to a matrix withe the `to_matrix`. The following line of code performs the explicit matrix multiplications to produce the exact expectation value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
       "hamiltonian:  [[0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n",
       " [0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n",
       " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]\n",
@@ -89,201 +140,319 @@
     }
    ],
    "source": [
-    "from functools import reduce\n",
+    "ham = cudaq.spin.x(0) * cudaq.spin.x(1)\n",
+    "ham_matrix = ham.to_matrix()\n",
+    "print('hamiltonian: ', np.array(ham_matrix), '\\n')\n",
     "\n",
-    "import numpy as np\n",
+    "exp_val = reduce(np.dot, (np.array(psi_state).conj().T, ham_matrix, phi_state))\n",
     "\n",
+    "print('Numerical expectation value: ', exp_val)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using `Sample` to perform the Hadamard test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Three CUDA-Q kernels are constructed below corresponding to $\\ket{\\psi}$, $\\ket{\\phi}$, and the Hamiltonian. A fourth kernel constructs the Hadamard test circuit and completes with a measurement of the ancilla qubit in the computational basis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "import cudaq\n",
     "\n",
-    "cudaq.set_target(\"nvidia\")\n",
-    "\n",
-    "num_qubits = 2\n",
+    "cudaq.set_target('nvidia')\n",
     "\n",
     "\n",
     "@cudaq.kernel\n",
-    "def psi(num_qubits: int):\n",
-    "    q = cudaq.qvector(num_qubits)\n",
+    "def U_psi(q: cudaq.qview):\n",
     "    h(q[1])\n",
     "\n",
     "\n",
     "@cudaq.kernel\n",
-    "def phi(num_qubits: int):\n",
-    "    q = cudaq.qvector(num_qubits)\n",
+    "def U_phi(q: cudaq.qview):\n",
     "    x(q[0])\n",
     "\n",
     "\n",
-    "psi_state = cudaq.get_state(psi, num_qubits)\n",
-    "print(\"Psi state: \", np.array(psi_state))\n",
-    "print(cudaq.draw(psi, 2))\n",
+    "@cudaq.kernel\n",
+    "def ham_cir(q: cudaq.qview):\n",
+    "    x(q[0])\n",
+    "    x(q[1])\n",
     "\n",
-    "phi_state = cudaq.get_state(phi, num_qubits)\n",
-    "print(\"Phi state: \", np.array(phi_state))\n",
-    "print(cudaq.draw(phi, 2))\n",
     "\n",
-    "ham = cudaq.spin.x(0) * cudaq.spin.x(1)\n",
-    "ham_matrix = ham.to_matrix()\n",
-    "print(\"hamiltonian: \", np.array(ham_matrix), \"\\n\")\n",
+    "@cudaq.kernel\n",
+    "def kernel(n: int):\n",
+    "    ancilla = cudaq.qubit()\n",
+    "    q = cudaq.qvector(n)\n",
+    "    h(ancilla)\n",
+    "    cudaq.control(U_phi, ancilla, q)\n",
+    "    cudaq.control(ham_cir, ancilla, q)\n",
+    "    cudaq.control(U_psi, ancilla, q)\n",
     "\n",
-    "ev_numerical = np.array(psi_state).conj() @ ham_matrix @ np.array(phi_state).T\n",
+    "    h(ancilla)\n",
     "\n",
-    "print(\"Numerical expectation value: \", ev_numerical)"
+    "    mz(ancilla)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Using ``observe`` algorithmic primitive to compute the expectation value for ancilla qubits."
+    "The CUDA-Q Sample method computes 100000 sample ancilla measurements and uses them to estimate the expectation value. The standard error is provided as well. Try increasing the sample size and note the convergence of the expectation value and the standard error towards the numerical result."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "QC result: 0.705+-0.007i ± 0.002+0.003i\n",
-      "Numerical result (0.7071067690849304+0j)\n"
+      "{ 0:85281 1:14719 }\n",
+      "\n",
+      "Observable QC:  0.70562 + - 0.0015844563982640861\n",
+      "Numerical result 0.7071067690849304\n"
      ]
     }
    ],
    "source": [
+    "shots = 100000\n",
+    "qubit_num = 2\n",
+    "count = cudaq.sample(kernel, qubit_num, shots_count=shots)\n",
+    "print(count)\n",
+    "\n",
+    "mean_val = (count['0'] - count['1']) / shots\n",
+    "error = np.sqrt(2 * count['0'] * count['1'] / shots) / shots\n",
+    "print('Observable QC: ', mean_val, '+ -', error)\n",
+    "print('Numerical result', np.real(exp_val))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Multi-GPU evaluation of QKSD matrix elements using the Hadamard Test\n",
+    "\n",
+    "This example is small, but a more practical application of the Hadamard test such as QKSD will require much larger circuits. The QKSD method works by reducing the exponential $2^N$ Hilbert space into an exponentially smaller subspace using a set of non-orthogonal states which are easy to prepare on a quantum computer. The Hadamard test is used to compute the matrix elements of this smaller subspace which is then diagonalized using a classical method to produce the eigenvalues. [This paper](https://www.osti.gov/servlets/purl/1962060). described the method in more detail and is the source of the figure below.\n",
+    "\n",
+    "![Htest3](./images/QKSD.png)\n",
+    "\n",
+    "This method can be easily parallelized and multiple QPUs, if available could compute the matrix elements asynchronously.  The CUDA-Q `mqpu` backend allows you to simulate a computation across multiple simulated QPUs. The code below demonstrates how.\n",
+    "\n",
+    "First, the Hadamard test circuit is defined, but this time the $\\ket{\\psi}$ and $\\ket{\\phi}$ states contain parameterized rotations so that multiple states can be quickly generated for the sake of example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "\n",
+    "\n",
     "@cudaq.kernel\n",
-    "def u_psi(q: cudaq.qview):\n",
-    "    h(q[1])\n",
+    "def U_psi(q: cudaq.qview, theta: float):\n",
+    "    ry(theta, q[1])\n",
     "\n",
     "\n",
     "@cudaq.kernel\n",
-    "def u_phi(q: cudaq.qview):\n",
-    "    x(q[0])\n",
+    "def U_phi(q: cudaq.qview, theta: float):\n",
+    "    rx(theta, q[0])\n",
     "\n",
     "\n",
     "@cudaq.kernel\n",
-    "def apply_pauli(q: cudaq.qview):\n",
+    "def ham_cir(q: cudaq.qview):\n",
     "    x(q[0])\n",
     "    x(q[1])\n",
     "\n",
     "\n",
     "@cudaq.kernel\n",
-    "def kernel(num_qubits: int):\n",
+    "def kernel(n: int, angle: float, theta: float):\n",
     "    ancilla = cudaq.qubit()\n",
-    "    q = cudaq.qvector(num_qubits)\n",
+    "    q = cudaq.qvector(n)\n",
     "    h(ancilla)\n",
-    "    cudaq.control(u_phi, ancilla, q)\n",
-    "    cudaq.control(apply_pauli, ancilla, q)\n",
-    "    cudaq.control(u_psi, ancilla, q)\n",
+    "    cudaq.control(U_phi, ancilla, q, theta)\n",
+    "    cudaq.control(ham_cir, ancilla, q)\n",
+    "    cudaq.control(U_psi, ancilla, q, angle)\n",
     "\n",
+    "    h(ancilla)\n",
     "\n",
-    "num_qubits = 2\n",
-    "shots = 100000\n",
-    "x_0 = cudaq.spin.x(0)\n",
-    "y_0 = cudaq.spin.y(0)\n",
-    "results = cudaq.observe(kernel, [x_0, y_0], num_qubits, shots_count=shots)\n",
-    "evs = np.array([result.expectation() for result in results])\n",
-    "std_errs = np.sqrt((1 - evs**2) / shots)\n",
-    "\n",
-    "print(f\"QC result: {evs[0]:.3f}+{evs[1]:.3f}i ± {std_errs[0]:.3f}+{std_errs[1]:.3f}i\")\n",
-    "print(\"Numerical result\", ev_numerical)"
+    "    mz(ancilla)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Use multi-GPUs to compute multiple Hadamard test in parallel"
+    "Next, the `nvidia-mqpu` backend is specified and the number of GPUs available is determined."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Number of QPUs: 5\n",
-      "angles=array([[1.56322878, 3.09176639],\n",
-      "       [0.04025496, 5.59986135],\n",
-      "       [1.87024074, 0.93078226],\n",
-      "       [4.44015281, 5.05675948],\n",
-      "       [1.92402471, 2.12981374],\n",
-      "       [0.49704605, 3.6020906 ],\n",
-      "       [4.50280746, 2.78988978],\n",
-      "       [4.006956  , 3.7581442 ],\n",
-      "       [3.00524035, 3.10937881],\n",
-      "       [3.13405202, 1.33235091]])\n",
-      "0-th ev=-0.7042075991630554\n",
-      "1-th ev=-0.006743329111486673\n",
-      "2-th ev=-0.36111390590667725\n",
-      "3-th ev=-0.45839524269104004\n",
-      "4-th ev=-0.7175908088684082\n",
-      "5-th ev=-0.23948131501674652\n",
-      "6-th ev=-0.765204668045044\n",
-      "7-th ev=-0.865047037601471\n",
-      "8-th ev=-0.9975475072860718\n",
-      "9-th ev=-0.6179792881011963\n"
+      "Number of QPUs: 5\n"
      ]
     }
    ],
    "source": [
-    "# Use multi-QPUs\n",
     "cudaq.set_target(\"nvidia-mqpu\")\n",
     "\n",
     "target = cudaq.get_target()\n",
-    "num_qpus = target.num_qpus()\n",
-    "print(\"Number of QPUs:\", num_qpus)\n",
-    "\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def u_psi(q: cudaq.qview, theta: float):\n",
-    "    ry(theta, q[1])\n",
+    "qpu_count = target.num_qpus()\n",
+    "print(\"Number of QPUs:\", qpu_count)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `sample_async` command is then used to distribute the Hadamard test computations across multiple simulated QPUs. The results are saved in a list and accessed below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "shots = 100000\n",
+    "angle = [0.0, 1.5, 3.14, 0.7]\n",
+    "theta = [0.6, 1.2, 2.2, 3.0]\n",
+    "qubit_num = 2\n",
+    "\n",
+    "result = []\n",
+    "for i in range(4):\n",
+    "    count = cudaq.sample_async(kernel,\n",
+    "                               qubit_num,\n",
+    "                               angle[i],\n",
+    "                               theta[i],\n",
+    "                               shots_count=shots,\n",
+    "                               qpu_id=i % qpu_count)\n",
+    "    result.append(count)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The four matrix elements are shown below and now be classically processed to produce the eigenvalues."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "{ 0:49865 1:50135 }\n",
+      "\n",
+      "QKSD Matrix Element:  -0.0027 + - 0.0022360598270171573\n",
+      "1\n",
+      "{ 0:49796 1:50204 }\n",
+      "\n",
+      "QKSD Matrix Element:  -0.00408 + - 0.002236049366181346\n",
+      "2\n",
+      "{ 0:49695 1:50305 }\n",
+      "\n",
+      "QKSD Matrix Element:  -0.0061 + - 0.002236026375068058\n",
+      "3\n",
+      "{ 0:49972 1:50028 }\n",
+      "\n",
+      "QKSD Matrix Element:  -0.00056 + - 0.002236067626884303\n"
+     ]
+    }
+   ],
+   "source": [
+    "mean_val = np.zeros(len(angle))\n",
+    "i = 0\n",
+    "for count in result:\n",
+    "    print(i)\n",
+    "    i_result = count.get()\n",
+    "    print(i_result)\n",
+    "    mean_val[i] = (i_result['0'] - i_result['1']) / shots\n",
+    "    error = np.sqrt(2 * i_result['0'] * i_result['1'] / shots) / shots\n",
+    "    print('QKSD Matrix Element: ', mean_val[i], '+ -', error)\n",
+    "    i += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Classically Diagonalize the Subspace Matrix\n",
     "\n",
+    "For a problem of this size, numpy can be used to diagonalize the subspace and produce the eigenvalues and eigenvectors in the basis of non-orthogonal states. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-0.0027  -0.00408]\n",
+      " [-0.0061  -0.00056]]\n",
+      "Eigenvalues: \n",
+      "[-0.00782313  0.00456313]\n",
+      "Eigenvector: \n",
+      "[[-0.76575845  0.64312829]\n",
+      " [-0.64312829 -0.76575845]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
     "\n",
-    "@cudaq.kernel\n",
-    "def u_phi(q: cudaq.qview, theta: float):\n",
-    "    s(q[0])\n",
-    "    rx(theta, q[0])\n",
-    "    s(q[0])\n",
+    "my_mat = np.zeros((2, 2), dtype=float)\n",
+    "m = 0\n",
+    "for k in range(2):\n",
+    "    for j in range(2):\n",
+    "        my_mat[k, j] = mean_val[m]\n",
+    "        m += 1\n",
     "\n",
+    "print(my_mat)\n",
     "\n",
-    "@cudaq.kernel\n",
-    "def ham_circuit(q: cudaq.qview):\n",
-    "    x(q[0])\n",
-    "    x(q[1])\n",
+    "E, V = np.linalg.eigh(my_mat)\n",
     "\n",
+    "print('Eigenvalues: ')\n",
+    "print(E)\n",
     "\n",
-    "@cudaq.kernel\n",
-    "def kernel(angle0: float, angle1: float):\n",
-    "    ancilla = cudaq.qubit()\n",
-    "    q = cudaq.qvector(2)\n",
-    "    h(ancilla)\n",
-    "    cudaq.control(u_phi, ancilla, q, angle0)\n",
-    "    cudaq.control(ham_circuit, ancilla, q)\n",
-    "    cudaq.control(u_psi, ancilla, q, angle1)\n",
-    "\n",
-    "\n",
-    "angles = 2 * np.pi * np.random.rand(10, 2)\n",
-    "print(f\"{angles=}\")\n",
-    "\n",
-    "async_results = [\n",
-    "    cudaq.observe_async(\n",
-    "        kernel,\n",
-    "        x_0,\n",
-    "        float(angle[0]),\n",
-    "        float(angle[1]),\n",
-    "        qpu_id=i % num_qpus,\n",
-    "    )\n",
-    "    for i, angle in enumerate(angles)\n",
-    "]\n",
-    "\n",
-    "for i, async_result in enumerate(async_results):\n",
-    "    ev = async_result.get().expectation()\n",
-    "    print(f\"{i}-th {ev=}\")"
+    "print('Eigenvector: ')\n",
+    "print(V)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/sphinx/examples/python/tutorials/hybrid_qnns.ipynb b/docs/sphinx/examples/python/tutorials/hybrid_qnns.ipynb
index 20181d85ae..63ced39587 100644
--- a/docs/sphinx/examples/python/tutorials/hybrid_qnns.ipynb
+++ b/docs/sphinx/examples/python/tutorials/hybrid_qnns.ipynb
@@ -34,10 +34,7 @@
    "source": [
     "# Install the relevant packages.\n",
     "\n",
-    "!pip install matplotlib==3.8.4\n",
-    "!pip install torch==2.2.2\n",
-    "!pip install torchvision==0.17.0\n",
-    "!pip install scikit-learn==1.4.2"
+    "!pip install matplotlib==3.8.4 torch==2.2.2 torchvision==0.17.0 scikit-learn==1.4.2 -q"
    ]
   },
   {
@@ -46,8 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "# Import the relevant libraries \n",
+    "# Import the relevant libraries\n",
     "\n",
     "import cudaq\n",
     "from cudaq import spin\n",
@@ -191,7 +187,7 @@
     "    sample_to_plot = x_train[:10].to(torch.device('cpu'))\n",
     "else:\n",
     "    sample_to_plot = x_train[:10]\n",
-    "    \n",
+    "\n",
     "grid_img = torchvision.utils.make_grid(sample_to_plot,\n",
     "                                       nrow=5,\n",
     "                                       padding=3,\n",
diff --git a/docs/sphinx/examples/python/tutorials/images/QKSD.png b/docs/sphinx/examples/python/tutorials/images/QKSD.png
new file mode 100644
index 0000000000..fbba9593fb
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/QKSD.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/QVprocedure.png b/docs/sphinx/examples/python/tutorials/images/QVprocedure.png
new file mode 100644
index 0000000000..746d56d71f
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/QVprocedure.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/VQE.png b/docs/sphinx/examples/python/tutorials/images/VQE.png
new file mode 100644
index 0000000000..081e024b25
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/VQE.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/cas.png b/docs/sphinx/examples/python/tutorials/images/cas.png
new file mode 100644
index 0000000000..043610d691
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/cas.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/docking.png b/docs/sphinx/examples/python/tutorials/images/docking.png
new file mode 100644
index 0000000000..37422eb8a4
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/docking.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/gate-fuse.png b/docs/sphinx/examples/python/tutorials/images/gate-fuse.png
new file mode 100644
index 0000000000..a8154b7551
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/gate-fuse.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/htest.png b/docs/sphinx/examples/python/tutorials/images/htest.png
new file mode 100644
index 0000000000..b8e857ea73
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/htest.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/htestfactored.png b/docs/sphinx/examples/python/tutorials/images/htestfactored.png
new file mode 100644
index 0000000000..76af330579
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/htestfactored.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/kakdecomp.png b/docs/sphinx/examples/python/tutorials/images/kakdecomp.png
new file mode 100644
index 0000000000..95e95f7128
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/kakdecomp.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/parametershift.png b/docs/sphinx/examples/python/tutorials/images/parametershift.png
new file mode 100644
index 0000000000..733f3eb062
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/parametershift.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/partition.png b/docs/sphinx/examples/python/tutorials/images/partition.png
new file mode 100644
index 0000000000..f7f136287d
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/partition.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/qvplot.png b/docs/sphinx/examples/python/tutorials/images/qvplot.png
new file mode 100644
index 0000000000..92b0e00513
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/qvplot.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/statehandle.png b/docs/sphinx/examples/python/tutorials/images/statehandle.png
new file mode 100644
index 0000000000..bc79c134f8
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/statehandle.png differ
diff --git a/docs/sphinx/examples/python/tutorials/images/teleportation.png b/docs/sphinx/examples/python/tutorials/images/teleportation.png
new file mode 100644
index 0000000000..f6730a3527
Binary files /dev/null and b/docs/sphinx/examples/python/tutorials/images/teleportation.png differ
diff --git a/docs/sphinx/examples/python/tutorials/krylov.ipynb b/docs/sphinx/examples/python/tutorials/krylov.ipynb
new file mode 100644
index 0000000000..e98cf758d2
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/krylov.ipynb
@@ -0,0 +1,628 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "16e3036d-b1be-43b8-8838-95dfc14cad60",
+   "metadata": {},
+   "source": [
+    "# Multi-reference Quantum Krylov Algorithm - $H_2$ Molecule\n",
+    "\n",
+    "The multireference selected quantum Krylov (MRSQK) algorithm is defined in [this paper](https://arxiv.org/pdf/1911.05163) and was developed as a low-cost alternative to quantum phase estimation. This tutorial will demonstrate how this algorithm can be implemented in CUDA-Q and accelerated using multiple GPUs. The CUDA-Q Hadamard test tutorial might provide helpful background information for understanding this tutorial.\n",
+    "\n",
+    "The algorithm works by preparing an initial state, and then defining this state in a smaller subspace constructed with a basis that corresponds to Trotter steps of the initial state. This subspace can be diagonalized to produce an approximate energy for the system without variational optimization of any parameters.\n",
+    "\n",
+    "In the example below, the initial guess is the ground state of the diagonalized Hamiltonian for demonstration purposes.  In practice one could use a number of heuristics to prepare the ground state such as Hartree Fock or CISD. A very promising ground state preparation method which can leverage quantum computers is the linear combination of unitaries (LCU). LCU would allow for the state preparation to occur completely on the quantum computer and avoid storing an inputting the exponentially large state vector.\n",
+    "\n",
+    "\n",
+    "Regardless of the method used for state preparation, the procedure begins by selecting a $d$ dimensional basis of reference states ${\\Phi_0 \\cdots \\Phi_d}$ where each is a linear combination of slater determinants. \n",
+    "\n",
+    "$$ \\ket{\\Phi_I}  =  \\sum_{\\mu} d_{\\mu I}\\ket{\\phi_{\\mu}} $$\n",
+    "\n",
+    "\n",
+    "From this, a non-orthogonal Krylov Space $\\mathcal{K} = \\{\\psi_{0} \\cdots \\psi_{N}\\}$ is constructed by applying a family of $s$ unitary operators on each of the $d$ reference states resulting in $d*s = N$ elements in the Krylov space where, \n",
+    "$$ \\ket{\\psi_{\\alpha}} \\equiv \\ket{\\psi_I^{(n)}} = \\hat{U}_n\\ket{\\Phi_I} $$\n",
+    "\n",
+    "Therefore, the general quantum state that we originally set out to describe is\n",
+    "\n",
+    "$$ \\ket{\\Psi} = \\sum_{\\alpha} c_{\\alpha}\\ket{\\psi_{\\alpha}} = \\sum_{I=0}^d \\sum_{n=0}^s c_I^{(n)}\\hat{U}_n\\ket{\\Phi_I}  $$\n",
+    "\n",
+    "The energy of this state can be obtained by solving the generalized eigenvalue problem\n",
+    "$$ \\boldsymbol{Hc}=\\boldsymbol{Sc}E $$\n",
+    "\n",
+    "Where the elements of the overlap and Hamiltonian matrix are\n",
+    "\n",
+    "$$S_{\\alpha \\beta} = \\braket{\\psi_{\\alpha}|\\psi_{\\beta}} =   \\braket{\\Phi_I|\\hat{U}_m^{\\dagger}\\hat{U}_n|\\Phi_J}$$ \n",
+    "\n",
+    "$$H_{\\alpha \\beta} = \\braket{\\psi_{\\alpha}|\\hat{H}|\\psi_{\\beta}} =   \\braket{\\Phi_I|\\hat{U}_m^{\\dagger}\\hat{H}\\hat{U}_n|\\Phi_J}$$\n",
+    "\n",
+    "These matrix elements are computed using a quantum computer and the Hadamard test with a circuit shown below for the case of the overlap matrix elements (The Hamiltonian matrix elements circuit would include controlled application of the Hamiltonian in the circuit).  Once the matrices are constructed, the diagonalization is performed classically to produce an estimate for the ground state in question.\n",
+    "\n",
+    "![Htest](../images/krylovcircuit.png)\n",
+    "\n",
+    "The $2\\sigma_+$ term refers to measurement of the expectation value of this circuit with the $X+iY$ operator. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b90de056-4dc5-473f-bf50-29c7d8b2ad05",
+   "metadata": {},
+   "source": [
+    "### Setup\n",
+    "\n",
+    "This cell installs the necessary packages. This application can be parallelized, so please uncomment the `mgpu` specification below if you would like to run on more than one GPU."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ba61665c-dc3b-4e43-b1cf-340855ea68fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np\n",
+    "import scipy\n",
+    "\n",
+    "!pip install openfermion==1.6.1 pyscf==2.6.2 openfermionpyscf==0.5 -q\n",
+    "\n",
+    "# Single-node, single gpu\n",
+    "cudaq.set_target(\"nvidia\")\n",
+    "multi_gpu = False\n",
+    "\n",
+    "# Single-node, multi-GPU\n",
+    "#cudaq.set_target(\"nvidia\", option='mqpu,fp64')\n",
+    "#multi_gpu = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ba6e94e-a3e6-48aa-8392-e598429b0be7",
+   "metadata": {},
+   "source": [
+    "The molecule is defined below and its Hamiltonian is extracted as a matrix. The matrix is diagonalized to produce the ground state. The corresponding state vector will be used as the initial state to ensure good results for this demonstration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fb4192c-054a-4bff-b86f-a8d58cf8bac6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define H2 molecule\n",
+    "geometry = [('H', (0.0, 0.0, 0.0)), ('H', (0.0, 0.0, 0.7474))]\n",
+    "\n",
+    "hamiltonian, data = cudaq.chemistry.create_molecular_hamiltonian(\n",
+    "    geometry, 'sto-3g', 1, 0)\n",
+    "\n",
+    "electron_count = data.n_electrons\n",
+    "qubits_num = 2 * data.n_orbitals\n",
+    "\n",
+    "# Diagonalize Hamiltonian\n",
+    "spin_ham_matrix = hamiltonian.to_matrix()\n",
+    "e, c = np.linalg.eig(spin_ham_matrix)\n",
+    "\n",
+    "# Find the ground state energy and the corresponding eigenvector\n",
+    "print('Ground state energy (classical simulation)= ', np.min(e), ', index= ',\n",
+    "      np.argmin(e))\n",
+    "min_indices = np.argmin(e)\n",
+    "\n",
+    "# Eigenvector can be used to initialize the qubits\n",
+    "vec = c[:, min_indices]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "562f795e-cf4c-4e43-a0d9-3a3ae346277d",
+   "metadata": {},
+   "source": [
+    "The functions below take the original Hamiltonian defined above, and strip it into a list of Pauli words and a list of coefficients which will be uses later."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "014e72eb-ee66-48f5-bb58-73210e621fad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Collect coefficients from a spin operator so they can pass to a kernel\n",
+    "def termCoefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "# Collect Pauli words from a spin operator so they can pass to a kernel\n",
+    "def termWords(ham: cudaq.SpinOperator) -> list[str]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "#Build the lists of coefficients and Pauli Words from H2 Hamiltonian\n",
+    "coefficient = termCoefficients(hamiltonian)\n",
+    "pauli_string = termWords(hamiltonian)\n",
+    "\n",
+    "print(coefficient)\n",
+    "print(pauli_string)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74b4c079-8837-47ae-a484-52ec5f4a160e",
+   "metadata": {},
+   "source": [
+    "In the case of this example, the unitary operators that build the Krylov subspace are first-order Trotter operations at different time steps. The performance here could potentially be improved by increasing the size of the time step, using a higher order Trotter approximation, or using other sorts of approximations. The CUDA-Q kernels below define the unitary operations that construct the $\\psi$ basis.  Each receives the target qubits, the time step, and components of the Hamiltonian."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c98db2b7-eaaf-4e3a-83bb-4f7ad0730471",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Applies Unitary operation corresponding to Um\n",
+    "@cudaq.kernel\n",
+    "def U_m(qubits: cudaq.qview, dt: float, coefficients: list[complex],\n",
+    "        words: list[cudaq.pauli_word]):\n",
+    "    # Compute U_m = exp(-i m dt H)\n",
+    "    for i in range(len(coefficients)):\n",
+    "        exp_pauli(dt * coefficients[i].real, qubits, words[i])\n",
+    "\n",
+    "\n",
+    "# Applies Unitary operation corresponding to Un\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def U_n(qubits: cudaq.qview, dt: float, coefficients: list[complex],\n",
+    "        words: list[cudaq.pauli_word]):\n",
+    "    # Compute U_n = exp(-i n dt H)\n",
+    "    for i in range(len(coefficients)):\n",
+    "        exp_pauli(dt * coefficients[i].real, qubits, words[i])\n",
+    "\n",
+    "\n",
+    "# Applies the gate operations for a Hamiltonian Pauli Word\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def apply_pauli(qubits: cudaq.qview, word: list[int]):\n",
+    "    # Add H (Hamiltonian operator)\n",
+    "    for i in range(len(word)):\n",
+    "        if word[i] == 1:\n",
+    "            x(qubits[i])\n",
+    "        if word[i] == 2:\n",
+    "            y(qubits[i])\n",
+    "        if word[i] == 3:\n",
+    "            z(qubits[i])\n",
+    "\n",
+    "\n",
+    "# Performs Hadamard test circuit which determines matrix elements of S and H of subspace\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def qfd_kernel(dt_alpha: float, dt_beta: float, coefficients: list[complex],\n",
+    "               words: list[cudaq.pauli_word], word_list: list[int],\n",
+    "               vec: list[complex]):\n",
+    "\n",
+    "    ancilla = cudaq.qubit()\n",
+    "    qreg = cudaq.qvector(vec)\n",
+    "\n",
+    "    h(ancilla)\n",
+    "\n",
+    "    x(ancilla)\n",
+    "    cudaq.control(U_m, ancilla, qreg, dt_alpha, coefficients, words)\n",
+    "    x(ancilla)\n",
+    "\n",
+    "    cudaq.control(apply_pauli, ancilla, qreg, word_list)\n",
+    "    cudaq.control(U_n, ancilla, qreg, dt_beta, coefficients, words)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c8f9fb4-4974-44bf-aa8c-c9e86ffb0dd4",
+   "metadata": {},
+   "source": [
+    "The auxillary function below takes a Pauli word, and converts it to a list of integers which informs applications of this word to a circuit with the `apply_pauli` kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5bed072a-9fb6-4394-9759-b45ba292d0a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pauli_str(pauli_word, qubits_num):\n",
+    "\n",
+    "    my_list = []\n",
+    "    for i in range(qubits_num):\n",
+    "        if str(pauli_word[i]) == 'I':\n",
+    "            my_list.append(0)\n",
+    "        if str(pauli_word[i]) == 'X':\n",
+    "            my_list.append(1)\n",
+    "        if str(pauli_word[i]) == 'Y':\n",
+    "            my_list.append(2)\n",
+    "        if str(pauli_word[i]) == 'Z':\n",
+    "            my_list.append(3)\n",
+    "    return my_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "999675e2-a5b0-43d1-ba80-827f1c81b3dc",
+   "metadata": {},
+   "source": [
+    "The spin operators necessary for the Hadamard test are defined below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "297dbc29-e48a-411b-bc42-4fabe180a641",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the spin-op x for real component and y for the imaginary component.\n",
+    "x_0 = cudaq.spin.x(0)\n",
+    "y_0 = cudaq.spin.y(0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1880e50d-6d27-44e4-b27e-329d8c499bfb",
+   "metadata": {},
+   "source": [
+    "Finally, the time step for the unitary operations that build the Krylov space is defined as well as the dimension of the Krylov space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3ae6b210-13c4-40ba-be73-4fb906a1f7ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Define parameters for the quantum Krylov space\n",
+    "dt = 0.5\n",
+    "\n",
+    "# Dimension of the Krylov space\n",
+    "m_qfd = 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d59f13b-e9f8-44e6-b270-be4fc6a80c01",
+   "metadata": {},
+   "source": [
+    "### Computing the matrix elements \n",
+    "\n",
+    "The cell below computes the overlap matrix. This can be done in serial or in parallel, depending on the `multi_gpu` specification.  First, an operator is built to apply the identity to the overlap matrix circuit when `apply_pauli` is called. Next, the `wf_overlap` array is constructed which will hold the matrix elements. \n",
+    "\n",
+    "Next, a pair of nested loops, iterate over the time steps defined by the dimension of the subspace.  Each m,n combination corresponds to computation of an off-diagonal matrix element of the overlap matrix $S$ using the Hadamard test.  This is accomplished by calling the CUDA-Q `observe` function with the X and Y operators, along with the time steps, the components of the Hamiltonian matrix, and the initial state vector `vec`.\n",
+    "\n",
+    "The observe function broadcasts over the two provided operators $X$ and $Y$ and returns a list of results. The `expectation` function returns the expectation values which are summed and stored in the matrix.\n",
+    "\n",
+    "The multi-gpu case completes the same steps, expect for `observe_async` is used. This allows for the $X$ and $Y$ observables to be evaluated at the same time on two different simulated QPUs. In this case, the results are stored in lists corresponding to the real an imaginary parts, and then accessed later with the `get` command to build $S$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "875124e8-dba8-4ace-828b-d4b03352f9d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Single GPU:\n",
+    "if not multi_gpu:\n",
+    "\n",
+    "    # Add identity operator to compute overlap of basis\n",
+    "    observe_op = 1.0\n",
+    "    for m in range(qubits_num):\n",
+    "        observe_op *= cudaq.spin.i(m)\n",
+    "    identity_word = observe_op.to_string(False)\n",
+    "    pauli_list = pauli_str(identity_word, qubits_num)\n",
+    "\n",
+    "    # Empty overlap matrix S\n",
+    "    wf_overlap = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
+    "\n",
+    "    # Loop to solve for S matrix elements\n",
+    "    for m in range(m_qfd):\n",
+    "        dt_m = dt * m\n",
+    "        for n in range(m, m_qfd):\n",
+    "            dt_n = dt * n\n",
+    "            results = cudaq.observe(qfd_kernel, [x_0, y_0], dt_m, dt_n,\n",
+    "                                    coefficient, pauli_string, pauli_list, vec)\n",
+    "            temp = [result.expectation() for result in results]\n",
+    "            wf_overlap[m, n] = temp[0] + temp[1] * 1j\n",
+    "            if n != m:\n",
+    "                wf_overlap[n, m] = np.conj(wf_overlap[m, n])\n",
+    "\n",
+    "else:\n",
+    "\n",
+    "    ## Multi-GPU\n",
+    "\n",
+    "    # Add identity operator to compute overlap of basis\n",
+    "    observe_op = 1.0\n",
+    "\n",
+    "    for m in range(qubits_num):\n",
+    "        observe_op *= cudaq.spin.i(m)\n",
+    "\n",
+    "    identity_word = observe_op.to_string(False)\n",
+    "    pauli_list = pauli_str(identity_word, qubits_num)\n",
+    "\n",
+    "    # Empty overlap matrix S\n",
+    "    wf_overlap = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
+    "\n",
+    "    # Empty lists to store results\n",
+    "    collect_overlap_real = []\n",
+    "    collect_overlap_img = []\n",
+    "\n",
+    "    # Loop to compute matrix elements of S\n",
+    "    count = 0\n",
+    "    for m in range(m_qfd):\n",
+    "        dt_m = dt * m\n",
+    "        for n in range(m, m_qfd):\n",
+    "            dt_n = dt * n\n",
+    "\n",
+    "            # The count variable determines which (simulated) QPU the computation is sent to\n",
+    "            # The results are stored in a list corresponding to the real and imaginary parts\n",
+    "            count_id = count % 2\n",
+    "            collect_overlap_real.append(\n",
+    "                cudaq.observe_async(qfd_kernel,\n",
+    "                                    x_0,\n",
+    "                                    dt_m,\n",
+    "                                    dt_n,\n",
+    "                                    coefficient,\n",
+    "                                    pauli_string,\n",
+    "                                    pauli_list,\n",
+    "                                    vec,\n",
+    "                                    qpu_id=count_id))\n",
+    "\n",
+    "            collect_overlap_img.append(\n",
+    "                cudaq.observe_async(qfd_kernel,\n",
+    "                                    y_0,\n",
+    "                                    dt_m,\n",
+    "                                    dt_n,\n",
+    "                                    coefficient,\n",
+    "                                    pauli_string,\n",
+    "                                    pauli_list,\n",
+    "                                    vec,\n",
+    "                                    qpu_id=count_id + 2))\n",
+    "            count += 1\n",
+    "\n",
+    "    tot_dim = 0\n",
+    "\n",
+    "    # A second loop takes the lists of results and, using `get`, populates the matrix elements\n",
+    "    for n in range(m_qfd):\n",
+    "        for m in range(n, m_qfd):\n",
+    "            observe_result = collect_overlap_real[tot_dim].get()\n",
+    "            real_val = observe_result.expectation()\n",
+    "\n",
+    "            observe_result = collect_overlap_img[tot_dim].get()\n",
+    "            img_val = observe_result.expectation()\n",
+    "\n",
+    "            wf_overlap[m, n] = real_val + img_val * 1j\n",
+    "            if n != m:\n",
+    "                wf_overlap[n, m] = np.conj(wf_overlap[m, n])\n",
+    "\n",
+    "            tot_dim += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1fa0e0f1-0705-4dd6-a354-30db1526e266",
+   "metadata": {},
+   "source": [
+    "The Hamiltonian matrix elements are computed in the same way, except this time the Hamiltonian is applied as part of the circuit. This is accomplished with the extra for loop, which iterates through the terms in the Hamiltonian, computing an expectation value for each one and then summing the results to produce one matrix element."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "562a6063-b0fe-4d69-a4f4-c7d5309436da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Single GPU:\n",
+    "if not multi_gpu:\n",
+    "\n",
+    "    # Empty H\n",
+    "    ham_matrx = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
+    "\n",
+    "    # Loops over H matrix terms\n",
+    "    for m in range(m_qfd):\n",
+    "        dt_m = dt * m\n",
+    "        for n in range(m, m_qfd):\n",
+    "            dt_n = dt * n\n",
+    "\n",
+    "            # 2 entry array that stores real and imaginary part of matrix element\n",
+    "            tot_e = np.zeros(2)\n",
+    "\n",
+    "            # Loops over the terms in the Hamiltonian, computing expectation values\n",
+    "            for coef, word in zip(coefficient, pauli_string):\n",
+    "                #print(coef,word)\n",
+    "\n",
+    "                pauli_list = pauli_str(word, qubits_num)\n",
+    "                #print(pauli_list)\n",
+    "\n",
+    "                results = cudaq.observe(qfd_kernel, [x_0, y_0], dt_m, dt_n,\n",
+    "                                        coefficient, pauli_string, pauli_list,\n",
+    "                                        vec)\n",
+    "\n",
+    "                temp = [result.expectation() for result in results]\n",
+    "\n",
+    "                # Multiplies result by coefficient corresponding to Pauli Word\n",
+    "                temp[0] = coef.real * temp[0]\n",
+    "                temp[1] = coef.imag * temp[1]\n",
+    "\n",
+    "                # Accumulates results for each Pauli Word\n",
+    "                tot_e[0] += temp[0]\n",
+    "                tot_e[1] += temp[1]\n",
+    "\n",
+    "            # Sums real and imaginary totals to specify Hamiltonian entry\n",
+    "            ham_matrx[m, n] = tot_e[0] + tot_e[1] * 1j\n",
+    "            if n != m:\n",
+    "                ham_matrx[n, m] = np.conj(ham_matrx[m, n])\n",
+    "else:\n",
+    "\n",
+    "    ## Multi-GPU\n",
+    "\n",
+    "    # Empty H\n",
+    "    ham_matrx = np.zeros((m_qfd, m_qfd), dtype=complex)\n",
+    "\n",
+    "    # Loops over H matrix terms\n",
+    "    for m in range(m_qfd):\n",
+    "        dt_m = dt * m\n",
+    "        for n in range(m, m_qfd):\n",
+    "            dt_n = dt * n\n",
+    "\n",
+    "            #List storing results from real and imaginary circuit evaluations for each Pauli word\n",
+    "            ham_matrix_real = []\n",
+    "            ham_matrix_imag = []\n",
+    "\n",
+    "            # Loop to asynchronously compute real and imaginary parts for each Pauli word on two GPUs\n",
+    "            count = 0\n",
+    "            tot_e = np.zeros(2)\n",
+    "            for coef, word in zip(coefficient, pauli_string):\n",
+    "                count_id = count % 2\n",
+    "                #print(coef,word)\n",
+    "\n",
+    "                pauli_list = pauli_str(word, qubits_num)\n",
+    "                #print(pauli_list)\n",
+    "\n",
+    "                ham_matrix_real.append(\n",
+    "                    cudaq.observe_async(qfd_kernel,\n",
+    "                                        x_0,\n",
+    "                                        dt_m,\n",
+    "                                        dt_n,\n",
+    "                                        coefficient,\n",
+    "                                        pauli_string,\n",
+    "                                        pauli_list,\n",
+    "                                        vec,\n",
+    "                                        qpu_id=count_id))\n",
+    "                ham_matrix_imag.append(\n",
+    "                    cudaq.observe_async(qfd_kernel,\n",
+    "                                        y_0,\n",
+    "                                        dt_m,\n",
+    "                                        dt_n,\n",
+    "                                        coefficient,\n",
+    "                                        pauli_string,\n",
+    "                                        pauli_list,\n",
+    "                                        vec,\n",
+    "                                        qpu_id=count_id + 2))\n",
+    "\n",
+    "                count += 1\n",
+    "\n",
+    "            # Loops through coefficients to sum the real and imaginary parts of H matrix element\n",
+    "            i = 0\n",
+    "            for coef in coefficient:\n",
+    "\n",
+    "                observe_result = ham_matrix_real[i].get()\n",
+    "                real_val = observe_result.expectation()\n",
+    "\n",
+    "                observe_result = ham_matrix_imag[i].get()\n",
+    "                img_val = observe_result.expectation()\n",
+    "\n",
+    "                tot_e[0] += real_val * coef.real\n",
+    "                tot_e[1] += img_val * coef.imag\n",
+    "\n",
+    "                i += 1\n",
+    "\n",
+    "            # Enter final H matrix element\n",
+    "            ham_matrx[m, n] = tot_e[0] + tot_e[1] * 1j\n",
+    "            if n != m:\n",
+    "                ham_matrx[n, m] = np.conj(ham_matrx[m, n])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1917bd58-4ce3-4e3e-9ccf-096577c0da14",
+   "metadata": {},
+   "source": [
+    "### Determining the ground state energy of the Subspace\n",
+    "\n",
+    "The final step is to solve the generalized eigenvaulue problem with the overlap and Hamiltonian matrices constructed using the quantum computer. The procedure begins by diagonalizing  $S$ with the transform $$S = U\\Sigma U^{\\dagger}$$\n",
+    "\n",
+    "The eigenvectors $v$ and eigenvalues $s$ are used to construct a new matrix $X'$\n",
+    "\n",
+    "$$ X' = S ^{\\frac{-1}{2}} = \\sum_k v_{ki} \\frac{1}{\\sqrt{s_k}} v_{kj}$$\n",
+    "\n",
+    "The $X'$ matrix diagonalizes $H$\n",
+    "\n",
+    "$$ X'^{\\dagger}HX' = ES^{\\frac{1}{2}}C$$\n",
+    "\n",
+    "Using the eigenvectors of $H'$, ($^{\\frac{1}{2}}C$), the original eigenvectors to the problem can be found by left multiplying by $S^{\\frac{-1}{2}}C$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8b281533-bf3d-4aed-823b-9d2f926dfe3e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def eig(H, s):\n",
+    "    #Solver for generalized eigenvalue problem\n",
+    "    # HC = SCE\n",
+    "\n",
+    "    THRESHOLD = 1e-20\n",
+    "    s_diag, u = scipy.linalg.eig(s)\n",
+    "    s_prime = []\n",
+    "    for sii in s_diag:\n",
+    "        if np.imag(sii) > 1e-7:\n",
+    "            raise ValueError(\n",
+    "                \"S may not be hermitian, large imag. eval component.\")\n",
+    "        if np.real(sii) > THRESHOLD:\n",
+    "            s_prime.append(np.real(sii))\n",
+    "\n",
+    "    X_prime = np.zeros((len(s_diag), len(s_prime)), dtype=complex)\n",
+    "\n",
+    "    for i in range(len(s_diag)):\n",
+    "        for j in range(len(s_prime)):\n",
+    "            X_prime[i][j] = u[i][j] / np.sqrt(s_prime[j])\n",
+    "\n",
+    "    H_prime = (((X_prime.conjugate()).transpose()).dot(H)).dot(X_prime)\n",
+    "    e_prime, C_prime = scipy.linalg.eig(H_prime)\n",
+    "    C = X_prime.dot(C_prime)\n",
+    "\n",
+    "    return e_prime, C"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74c1fa51-4fae-412b-b90d-262e0b3aaf53",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eigen_value, eigen_vect = eig(ham_matrx[0:m_qfd, 0:m_qfd], wf_overlap[0:m_qfd,\n",
+    "                                                                      0:m_qfd])\n",
+    "print('Energy from QFD:')\n",
+    "print(np.min(eigen_value))"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/tutorials/maximum_vertex_weight_clique.ipynb b/docs/sphinx/examples/python/tutorials/maximum_vertex_weight_clique.ipynb
deleted file mode 100644
index 1b25ce1f3f..0000000000
--- a/docs/sphinx/examples/python/tutorials/maximum_vertex_weight_clique.ipynb
+++ /dev/null
@@ -1,325 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Molecular docking via DC-QAOA\n",
-    "\n",
-    "The data of the clique graph for the molecular docking are taken from this [paper](https://arxiv.org/pdf/2308.04098)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import cudaq\n",
-    "from cudaq import spin\n",
-    "import numpy as np\n",
-    "\n",
-    "# GPU: Default If an NVIDIA GPU and CUDA runtime libraries are available\n",
-    "#cudaq.set_target('nvidia')\n",
-    "\n",
-    "# CPU\n",
-    "cudaq.set_target('qpp-cpu')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Edges:  [[0, 1], [0, 2], [0, 4], [0, 5], [1, 2], [1, 3], [1, 5], [2, 3], [2, 4], [3, 4], [3, 5], [4, 5]]\n",
-      "Non-Edges:  [[0, 3], [1, 4], [2, 5]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# The two graphs input from the paper\n",
-    "\n",
-    "# BIG 1\n",
-    "\n",
-    "nodes = [0,1,2,3,4,5]\n",
-    "qubit_num=len(nodes)\n",
-    "edges = [[0,1],[0,2],[0,4],[0,5],[1,2],[1,3],[1,5],[2,3],[2,4],[3,4],[3,5],[4,5]]\n",
-    "non_edges = [[u,v] for u in nodes for v in nodes if u<v and [u,v] not in edges]\n",
-    "print('Edges: ', edges)\n",
-    "print('Non-Edges: ', non_edges)\n",
-    "weights = [0.6686,0.6686,0.6686,0.1453,0.1453,0.1453]\n",
-    "penalty = 6.0\n",
-    "num_layers = 3\n",
-    "\n",
-    "# BIG 2 (More expensive simulation)\n",
-    "\n",
-    "#nodes=[0,1,2,3,4,5,6,7]\n",
-    "#qubit_num=len(nodes)\n",
-    "#edges=[[0,1],[0,2],[0,5],[0,6],[0,7],[1,2],[1,4],[1,6],[1,7],[2,4],[2,5],[2,7],[3,4],[3,5],[3,6],\\\n",
-    "#    [4,5],[4,6],[5,6]]\n",
-    "#non_edges=[[u,v] for u in nodes for v in nodes if u<v and [u,v] not in edges]\n",
-    "#print('Edges: ', edges)\n",
-    "#print('Non-edges: ', non_edges)\n",
-    "#weights=[0.6686,0.6686,0.6886,0.1091,0.0770,0.0770,0.0770,0.0770]\n",
-    "#penalty=8.0\n",
-    "#num_layers=8"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Generate the Hamiltonian\n",
-    "def ham_clique(penalty, nodes, weights, non_edges)-> cudaq.SpinOperator:\n",
-    "    \n",
-    "    spin_ham = 0.0\n",
-    "    for wt,node in zip(weights,nodes):\n",
-    "        #print(wt,node)\n",
-    "        spin_ham += 0.5 * wt * spin.z(node)\n",
-    "        spin_ham -= 0.5 * wt * spin.i(node)\n",
-    "    \n",
-    "    for non_edge in non_edges:\n",
-    "        u,v=(non_edge[0],non_edge[1])\n",
-    "        #print(u,v)\n",
-    "        spin_ham += penalty/4.0 * (spin.z(u)*spin.z(v)-spin.z(u)-spin.z(v)+spin.i(u)*spin.i(v))\n",
-    "    \n",
-    "    return spin_ham   "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Collect coefficients from a spin operator so we can pass them to a kernel\n",
-    "def term_coefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
-    "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
-    "    return result\n",
-    "\n",
-    "    # Collect Pauli words from a spin operator so we can pass them to a kernel\n",
-    "def term_words(ham: cudaq.SpinOperator) -> list[str]:\n",
-    "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
-    "    return result\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@cudaq.kernel\n",
-    "def dc_qaoa(qubit_num:int, num_layers:int,thetas:list[float],\\\n",
-    "    coef:list[complex], words:list[cudaq.pauli_word]):\n",
-    "    \n",
-    "    qubits=cudaq.qvector(qubit_num)\n",
-    "    \n",
-    "    h(qubits)\n",
-    "    \n",
-    "    count=0\n",
-    "    for p in range(num_layers):\n",
-    "        \n",
-    "        for i in range(len(coef)):\n",
-    "            exp_pauli(thetas[count]*coef[i].real,qubits,words[i])\n",
-    "            count+=1\n",
-    "        \n",
-    "        for j in range(qubit_num):\n",
-    "            rx(thetas[count],qubits[j])\n",
-    "            count+=1 \n",
-    "        \n",
-    "        for k in range(qubit_num):\n",
-    "            ry(thetas[count],qubits[k])\n",
-    "            count+=1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1.5+0j] IIZIIZ\n",
-      "[1.5+0j] ZIIZII\n",
-      "[-1.1657+0j] IZIIII\n",
-      "[1.5+0j] IZIIZI\n",
-      "[-1.42735+0j] IIIZII\n",
-      "[3.2791499999999996+0j] IIIIII\n",
-      "[-1.1657+0j] IIZIII\n",
-      "[-1.42735+0j] IIIIIZ\n",
-      "[-1.1657+0j] ZIIIII\n",
-      "[-1.42735+0j] IIIIZI\n",
-      "\n",
-      "[(1.5+0j), (1.5+0j), (-1.1657+0j), (1.5+0j), (-1.42735+0j), (3.2791499999999996+0j), (-1.1657+0j), (-1.42735+0j), (-1.1657+0j), (-1.42735+0j)]\n",
-      "['IIZIIZ', 'ZIIZII', 'IZIIII', 'IZIIZI', 'IIIZII', 'IIIIII', 'IIZIII', 'IIIIIZ', 'ZIIIII', 'IIIIZI']\n"
-     ]
-    }
-   ],
-   "source": [
-    "ham= ham_clique(penalty,nodes,weights,non_edges)\n",
-    "print(ham)\n",
-    "\n",
-    "coef=term_coefficients(ham)\n",
-    "words=term_words(ham)\n",
-    "\n",
-    "print(term_coefficients(ham))\n",
-    "print(term_words(ham))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total number of parameters:  66\n",
-      "Initial parameters =  [0.21810696323572243, -0.20613464375211488, 0.2546877639814583, 0.3657985647468064, 0.37118004688049144, -0.03656087558321203, 0.08564174998504231, 0.21639801853794682, 0.11122286088634259, 0.1743727097033635, -0.36518146001762486, -0.15829741539542244, -0.3467434780387345, 0.28043500852894776, -0.09986021299050934, 0.14125225086023052, -0.19141728018199775, -0.11970943368650361, -0.3853063093646483, -0.1112643868789806, 0.3527177454825464, -0.22156160012057186, -0.1418496891385843, 0.32811766468303116, -0.367642000671186, -0.34158180583996006, 0.10196745745501312, 0.29359239180502594, -0.3858537615546677, 0.19366130907065582, 0.24570488114056754, -0.3332307385378807, 0.12287973244618389, 0.007274514934614895, -0.015799547372526146, 0.3578070967202224, -0.39268963055535144, -0.19872246354138554, 0.16668715544467982, -0.13777293592446055, -0.17514665212709513, 0.15350249947988204, 0.32872977428061945, -0.20068831419712105, -0.032919322131134854, -0.19399909325771983, -0.09477141125241506, 0.08210460401106645, 0.21392577760158515, -0.3393568044538389, 0.14615087942938465, 0.03790339186006314, -0.2843250892879255, -0.3151384847055956, -0.19983741137121905, -0.27348611567665115, 0.33457528180906904, 0.14145414847455462, -0.20604220093940323, 0.05410235084309195, 0.04447870918600966, -0.3355714098595045, 0.266806440171265, -0.07436189654442632, -0.2789176729721685, -0.2427508182662484]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Optimizer\n",
-    "\n",
-    "# Specify the optimizer and its initial parameters.\n",
-    "optimizer = cudaq.optimizers.NelderMead()\n",
-    "#optimizer = cudaq.optimizers.COBYLA()\n",
-    "\n",
-    "np.random.seed(13)\n",
-    "cudaq.set_random_seed(13)\n",
-    "\n",
-    "# if dc_qaoa used\n",
-    "parameter_count=(2*qubit_num+len(coef))*num_layers\n",
-    "\n",
-    "# if qaoa used\n",
-    "# parameter_count=(qubit_num+len(coef))*num_layers\n",
-    "\n",
-    "print('Total number of parameters: ', parameter_count)\n",
-    "optimizer.initial_parameters = np.random.uniform(-np.pi/8 , np.pi/8 ,parameter_count)\n",
-    "print(\"Initial parameters = \", optimizer.initial_parameters)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "optimal_expectation = -2.0057970170760537\n",
-      "optimal_parameters = [2.0617900450255213, -0.008832997414504553, 0.5446745231437978, 0.9170743966952536, 0.5684145055308018, 0.45653992738579674, 0.48765328828009236, 0.08690545932812363, 0.4396413285058074, 0.18459993158979182, -1.309747594917737, 1.2588385005776594, -0.834255663515425, 0.674712608431175, -0.40174553656823186, 0.1936475123928361, 0.11292461472367524, -0.40520422214477836, 0.5249647407525035, -0.8276837818165452, 0.2945660883282474, -0.8060498989662159, 0.08051672267342141, 0.016438756265571293, 1.5245041151262497, 1.4087477995498743, 0.24688680789607903, 2.1121838066265077, 1.1445970943333728, -0.22281558391261153, 0.29034932090910637, -1.0492037973620043, 0.2734013684834806, 0.5265417924961102, 0.5099056677967553, 0.8636684922225737, -0.6164906874232119, -0.42851259141848624, 0.09675272347583658, 0.05697275350531247, -0.7102412317670379, -0.11174687408874051, 0.32505750242276577, -0.4397450017834574, -0.023604090020531092, 2.072436348972407, -0.38357054930488194, 0.13613334013073858, -0.10505045798768743, 2.0359359294549595, -0.24377425227508304, 0.10609870738840588, -0.2073332743736556, 0.07232539343493427, -0.6190529241716675, -0.03799182564866846, 0.17548654124993912, 0.5257077568577536, -0.23376653076971432, 0.3391308272563698, 0.4193139961661264, 0.02390444901420668, 0.2521154835623746, 1.1843328649807838, -0.6609672889772077, -0.2612231428844001]\n"
-     ]
-    }
-   ],
-   "source": [
-    "cost_values=[]\n",
-    "def objective(parameters):\n",
-    "\n",
-    "    cost=cudaq.observe(dc_qaoa, ham, qubit_num, num_layers, parameters,coef,words).expectation()\n",
-    "    cost_values.append(cost)\n",
-    "    return cost\n",
-    "\n",
-    "# Optimize!\n",
-    "optimal_expectation, optimal_parameters = optimizer.optimize(\n",
-    "    dimensions=parameter_count, function=objective)\n",
-    "\n",
-    "print('optimal_expectation =', optimal_expectation)\n",
-    "print('optimal_parameters =', optimal_parameters)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{ 111000:200000 }\n",
-      "\n",
-      "The MVWCP is given by the partition:  111000\n",
-      "The MVWCP is given by the partition:  111000\n"
-     ]
-    }
-   ],
-   "source": [
-    "shots=200000\n",
-    "\n",
-    "counts = cudaq.sample(dc_qaoa, qubit_num, num_layers, optimal_parameters,coef,words, shots_count=shots)\n",
-    "print(counts)\n",
-    "\n",
-    "print('The MVWCP is given by the partition: ', max(counts, key=lambda x: counts[x]))\n",
-    "\n",
-    "# Alternative\n",
-    "print('The MVWCP is given by the partition: ', counts.most_probable())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "x_values = list(range(len(cost_values)))\n",
-    "y_values = cost_values\n",
-    "\n",
-    "plt.plot(x_values, y_values)\n",
-    "\n",
-    "plt.xlabel(\"Epochs\")\n",
-    "plt.ylabel(\"Cost Value\")\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/sphinx/examples/python/tutorials/quantum_fourier_transform.ipynb b/docs/sphinx/examples/python/tutorials/quantum_fourier_transform.ipynb
index 8d836113b3..52cd4e8e40 100644
--- a/docs/sphinx/examples/python/tutorials/quantum_fourier_transform.ipynb
+++ b/docs/sphinx/examples/python/tutorials/quantum_fourier_transform.ipynb
@@ -284,7 +284,8 @@
     "        for j in range(i + 1, qubit_count):\n",
     "            angle = (2 * np.pi) / (2**(j - i + 1))\n",
     "            cr1(angle, [qubits[j]], qubits[i])\n",
-    "            \n",
+    "\n",
+    "\n",
     "@cudaq.kernel\n",
     "def inverse_qft(qubits: cudaq.qview):\n",
     "    '''Args: \n",
@@ -332,7 +333,7 @@
    ],
    "source": [
     "@cudaq.kernel\n",
-    "def verification_example(input_state : List[int]):\n",
+    "def verification_example(input_state: List[int]):\n",
     "    '''Args: \n",
     "    input_state (list[int]): specifies the input state to be transformed with QFT and the inverse QFT.  '''\n",
     "    qubit_count = len(input_state)\n",
@@ -343,26 +344,25 @@
     "    for i in range(qubit_count):\n",
     "        if input_state[i] == 1:\n",
     "            x(qubits[i])\n",
-    "    \n",
+    "\n",
     "    # Apply the quantum Fourier Transform\n",
     "    quantum_fourier_transform2(qubits)\n",
     "\n",
     "    # Apply the inverse quantum Fourier Transform\n",
     "    inverse_qft(qubits)\n",
     "\n",
+    "\n",
     "# The state to which the QFT operation is applied to. The zeroth element in the list is the zeroth qubit.\n",
     "input_state = [1, 0, 1]\n",
     "\n",
-    "\n",
     "# Number of decimal points to round up the statevector to.\n",
     "precision = 2\n",
     "\n",
-    "\n",
     "print(cudaq.draw(verification_example, input_state))\n",
     "\n",
     "# Print the statevector to the specified precision\n",
     "statevector = np.array(cudaq.get_state(verification_example, input_state))\n",
-    "print(np.round(statevector, precision)) # The result should be the input state"
+    "print(np.round(statevector, precision))  # The result should be the input state"
    ]
   },
   {
diff --git a/docs/sphinx/examples/python/tutorials/quantum_teleportation.ipynb b/docs/sphinx/examples/python/tutorials/quantum_teleportation.ipynb
new file mode 100644
index 0000000000..ddf7b98ac5
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/quantum_teleportation.ipynb
@@ -0,0 +1,396 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Quantum Teleporation\n",
+    "\n",
+    "\n",
+    "Below we shall study an interesting quantum phenomena - teleportation.\n",
+    "\n",
+    "Let us start by implementing the circuit shown below and discuss its implications later. We normally assume that the input qubits are initialised to the $\\ket{0}$ state unless specified otherwise. In this case however, the circuit diagram depicts the 0<sup>th</sup> qubit to be initialised in an arbitary quantum state, $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$, and the 1<sup>st</sup> and 2<sup>nd</sup> qubit to be in the state $\\ket{\\beta_{00}} = \\tfrac{1}{\\sqrt{2}} [\\ket{00} + \\ket{11}]$.\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![tene.png](./images/teleportation.png)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np\n",
+    "\n",
+    "cudaq.set_target('qpp-cpu')\n",
+    "cudaq.set_random_seed(23)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We now replicate the circuit shown in the diagram above and step through each intermediate stage from psi0 to psi4.\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def teleportation():\n",
+    "\n",
+    "    # Initialize a 3 qubit quantum circuit\n",
+    "    qubits = cudaq.qvector(3)\n",
+    "\n",
+    "    # Psi0 - random quantum state, psi, on qubit 0.\n",
+    "    rx(3.14, qubits[0])\n",
+    "    ry(2.71, qubits[0])\n",
+    "    rz(6.62, qubits[0])\n",
+    "\n",
+    "    # Psi0 - create a maximally entangled state on qubits 1 and 2.\n",
+    "    h(qubits[1])\n",
+    "    cx(qubits[1], qubits[2])\n",
+    "\n",
+    "\n",
+    "# Let us save the statevector of the circuit so far for later use.\n",
+    "psi_0 = cudaq.get_state(teleportation)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now we continue with the rest of the circuit\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def teleportation():\n",
+    "\n",
+    "    # Initialize a 3 qubit quantum circuit\n",
+    "    qubits = cudaq.qvector(3)\n",
+    "\n",
+    "    # Psi0 - random quantum state, psi, on qubit 0.\n",
+    "    rx(3.14, qubits[0])\n",
+    "    ry(2.71, qubits[0])\n",
+    "    rz(6.62, qubits[0])\n",
+    "\n",
+    "    # Psi0 - create a maximally entangled state on qubits 1 and 2.\n",
+    "    h(qubits[1])\n",
+    "    cx(qubits[1], qubits[2])\n",
+    "\n",
+    "    # Psi1\n",
+    "    cx(qubits[0], qubits[1])\n",
+    "\n",
+    "    # Psi2\n",
+    "    h(qubits[0])\n",
+    "\n",
+    "    # Psi3 - measure qubits 0 and 1 and store it in variables m1 and m2\n",
+    "    m1 = mz(qubits[0])\n",
+    "    m2 = mz(qubits[1])\n",
+    "\n",
+    "    # Psi4 - apply conditioned pauli operators dependent on the measurement result of qubits 0 and 1.\n",
+    "    if m1 == 1:\n",
+    "        z(qubits[2])\n",
+    "\n",
+    "    if m2 == 1:\n",
+    "        x(qubits[2])\n",
+    "\n",
+    "\n",
+    "psi_4 = cudaq.get_state(teleportation)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The state of this 3 qubit system is described by a $2^3 = 8$ dimensional vector. Sometimes we would like to extract the state of a single qubit from a multipartite state. We can use the partial trace operation defined in the function below which allows us to translate our statevectors to the density matrix representation to trace out subsystems. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to be used below to calculate the partial trace yielding a density matrix.\n",
+    "\n",
+    "\n",
+    "def partial_trace(state_vector, trace_systems):\n",
+    "    \"\"\"\n",
+    "    Partial trace of multi-particle quantum state. \n",
+    "\n",
+    "    Arguments:\n",
+    "        state_vector: complex vector  of size 2**n\n",
+    "        trace_systems (list(int)): a list of subsystems (starting from 0) to trace over. \n",
+    "        dimensions (list(int)): a list of the dimensions of the subsystems.\n",
+    "  \n",
+    "    Returns:\n",
+    "        ndarray: A density matrix with the appropriate subsystems traced over.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    n_qubits = int(np.log2(state_vector.shape[0]))\n",
+    "\n",
+    "    dimensions = [2 for i in range(n_qubits)]\n",
+    "\n",
+    "    trace_systems = len(dimensions) - 1 - np.array(trace_systems)\n",
+    "\n",
+    "    rho = state_vector.reshape(dimensions)\n",
+    "    rho = np.tensordot(rho, rho.conj(), axes=(trace_systems, trace_systems))\n",
+    "    d = int(np.sqrt(np.prod(rho.shape)))\n",
+    "\n",
+    "    return rho.reshape(d, d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "|qubit_0> == |qubit_2>?  True\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Trace out qubits 1 and 2 leaving us with qubit 0.\n",
+    "state_of_q0 = partial_trace(state_vector=np.array(psi_0), trace_systems=[1, 2])\n",
+    "\n",
+    "# Trace out qubits 0 and 1 leaving us with qubit 2.\n",
+    "state_of_q2 = partial_trace(state_vector=np.array(psi_4), trace_systems=[0, 1])\n",
+    "\n",
+    "print(f\"|qubit_0> == |qubit_2>?  {np.allclose(state_of_q0, state_of_q2)}\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us discuss what has happened. \n",
+    "\n",
+    "We started with a 3 qubit quantum circuit with the 0<sup>th</sup> qubit in $\\ket{\\psi}$ and the 2<sup>nd</sup> qubit being a portion of the maximally entangled bell state $\\ket{\\beta_{00}}$.\n",
+    "\n",
+    "If we look closely at the code cell above, the output state on the 2<sup>nd</sup> qubit, `state_of_q2`, is the same as the random input state, $\\ket{\\psi}$, on the 0<sup>th</sup> qubit, `state_of_q0`. \n",
+    "\n",
+    "We have **teleported** a quantum state from one qubit to another. There is nothing to restrict how close qubits 0 and 2 have to be since they have no entangling operations between them. They can be placed in different labs or infinitely far apart. \n",
+    "\n",
+    "Moreover, we still obey the no-cloning theorem since the initial state $\\ket{\\psi}$ no longer exists on the 0<sup>th</sup> qubit and hence we only have 1 copy of it as shown below \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Using the final statevector, psi4, we show that psi has been teleported and only 1 copy of psi is preserved.\n",
+    "\n",
+    "# Trace out qubits 1 and 2 leaving us with qubit 0\n",
+    "state_of_q0 = partial_trace(state_vector=np.array(psi_4), trace_systems=[1, 2])\n",
+    "\n",
+    "# Trace out qubits 0 and 1 leaving us with qubit 2\n",
+    "state_of_q2 = partial_trace(state_vector=np.array(psi_4), trace_systems=[0, 1])\n",
+    "\n",
+    "np.allclose(state_of_q0, state_of_q2)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "None of this violates the universal limit of information travelling faster than the speed of light. Notice how we have conditioned operations meaning we have to communicate classical information via classical channels which adhere to this limit."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Teleportation explained\n",
+    "\n",
+    "We have stepped through the circuit above using code. We will now do the same using mathematics to enhance our understanding. \n",
+    "\n",
+    "\n",
+    "We start by gathering experimentalists in a lab and performing the following\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned} \n",
+    "CX_{01}H_{0}\\ket{00} &= CX_{01}\\tfrac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1})\\ket{0} \\\\\n",
+    "                        &= CX_{01}\\tfrac{1}{\\sqrt{2}}(\\ket{00}+\\ket{10}) \\\\\n",
+    "                        &= \\tfrac{1}{\\sqrt{2}}(\\ket{00}+\\ket{11}) \\\\\n",
+    "                        &= \\ket{\\beta_{00}}\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "to create an entangled bell pair. We then hand each qubit in $\\ket{\\beta_{00}}$ to two parties, namely Alice and Bob for safekeeping. Many moons later, Alice comes in posession of an arbitary quantum state $\\ket{\\psi} = \\alpha\\ket{0} + \\beta\\ket{1}$ which she would like to send to Bob who is many miles away. This entails communicating values of $\\alpha$ and $\\beta$. However, measurement would lead to state collapse and only yield one bit of information, 0 or a 1.\n",
+    "\n",
+    "Referring to circuit in the figure above, the 0<sup>th</sup> and the 1<sup>st</sup> qubits are in posession of Alice and the 2<sup>nd</sup> qubit is with Bob. The 1<sup>st</sup> and 2<sup>nd</sup> qubits have been entangled but are now seperated in distance. Let us now step through the circuit to describe its evolution. Our input state is \n",
+    "\n",
+    "$$ \n",
+    "\\begin{aligned} \n",
+    "\\ket{\\psi_{0}} &=  \\ket{\\psi} \\ket{\\beta_{00}}  = (\\alpha\\ket{0} + \\beta\\ket{1})(\\tfrac{1}{\\sqrt{2}} (\\ket{00} + \\ket{11}) \\\\\n",
+    "&= \\tfrac{1}{\\sqrt{2}}[\\alpha\\ket{0}(\\ket{00} + \\ket{11}) +\\beta\\ket{1}(\\ket{00} + \\ket{11})]\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "Alice then performs a CX gate between the qubits she posses i.e. qubit 0 and 1 \n",
+    "\n",
+    "$$ \n",
+    "\\begin{aligned} \n",
+    "\\ket{\\psi_{1}} &= CX_{01}\\ket{\\psi_{0}} \\\\\n",
+    "                &= \\tfrac{1}{\\sqrt{2}}[\\alpha\\ket{0}(\\ket{00} + \\ket{11}) +\\beta\\ket{1}(\\ket{10} + \\ket{01})]\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "which is then followed by Alice performing a Hadamard on the 0<sup>th</sup> qubit\n",
+    "\n",
+    "$$ \n",
+    "\\begin{aligned} \n",
+    "\\ket{\\psi_{2}} &= H_{0}\\ket{\\psi_{1}} \\\\\n",
+    "                &= \\tfrac{1}{{2}}[\\alpha(\\ket{0}+\\ket{1})(\\ket{00} + \\ket{11}) +\\beta(\\ket{0}-\\ket{1})(\\ket{10} + \\ket{01})].\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "If we expand all the inner brackets\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned} \n",
+    "\\ket{\\psi_{2}} &= \\tfrac{1}{{2}}[(\\alpha\\ket{0} + \\alpha\\ket{1})(\\ket{00} + \\ket{11}) + (\\beta\\ket{0} - \\beta\\ket{1})(\\ket{10} + \\ket{01})] \\\\\n",
+    "                &= \\tfrac{1}{{2}}[\\alpha\\ket{000}+\\alpha\\ket{011}  +\\alpha\\ket{100}  +\\alpha\\ket{111} +\\beta\\ket{010}+\\beta\\ket{001}-\\beta\\ket{110}-\\beta\\ket{101}]\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "and then collect like terms whilst maintaining qubit ordering, we yield \n",
+    "\n",
+    "\n",
+    "$$ \n",
+    "\\begin{aligned} \n",
+    "\\ket{\\psi_{2}} &= \\tfrac{1}{{2}}[  \\ket{00}(\\alpha\\ket{0}+\\beta\\ket{1}) + \\ket{01}(\\alpha\\ket{1}+\\beta\\ket{0}) +\n",
+    " \\ket{10}(\\alpha\\ket{0}-\\beta\\ket{1}) + \\ket{11}(\\alpha\\ket{1}+\\beta\\ket{0})                              ]\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "where the qubit ordering notation states that the left most qubit is the 0<sup>th</sup> qubit. This expression naturally breaks down into 4 terms where each term has all 3 qubits and the 4 terms represent all the possibilities they can be in after they have been evolved.  \n",
+    "\n",
+    "We now ask our friend Alice to measure her qubits. Quantum mechanically we know that upon measurement the possibilities of the 3 qubit system will collapse regardless of the distance between them and the unmeasured outcomes will therefore be deterministic. If her measurement result yields a 00, the first term in $\\ket{\\psi_{2}}$ tells us that Bob's qubit will be in the state $\\alpha\\ket{0}+\\beta\\ket{1}$ which is the the original state, $\\ket{\\psi}$, we wanted to teleport. Alice has other potential measurement outcomes all of which are summarised in the figure below \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "| Alices' measurement        | Bobs' state           | \n",
+    "| ---------------------------|:---------------------:| \n",
+    "|  $$00$$ | $$  \\ket{\\psi_3(00)} = \\alpha\\ket{0} + \\beta\\ket{1} $$ | \n",
+    "|  $$01$$ | $$ \\ket{\\psi_3(01)} =  \\alpha\\ket{1} + \\beta\\ket{0} $$ | \n",
+    "|  $$10$$ | $$ \\ket{\\psi_3(10)} = \\alpha\\ket{0} - \\beta\\ket{1} $$ | \n",
+    "|  $$11$$ | $$ \\ket{\\psi_3(11)} = \\alpha\\ket{1} - \\beta\\ket{0} $$ | \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A quick glance at the figure above shows us that Bob's qubit is nearly in the state $\\ket{\\psi}$ which is what we are after pending some minor corrections. The circuit diagram depicts conditioned gates that are applied depending on Alice's measurement result fulfilling the minor corrections required to complete the teleportation protocol. The final gate operations are summarised below "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "$$ \n",
+    "\\begin{aligned} \n",
+    "M1M2 = 00, \\ket{\\psi_4} = Z^{0}X^{0}\\ket{\\psi_3(00)} = \\alpha\\ket{0} + \\beta\\ket{1} = \\ket{\\psi} \\\\\n",
+    "M1M2 = 01, \\ket{\\psi_4} = Z^{0}X^{1}\\ket{\\psi_3(01)} = \\alpha\\ket{0} + \\beta\\ket{1} = \\ket{\\psi} \\\\\n",
+    "M1M2 = 10, \\ket{\\psi_4} = Z^{1}X^{0}\\ket{\\psi_3(10)} = \\alpha\\ket{0} + \\beta\\ket{1} = \\ket{\\psi} \\\\\n",
+    "M1M2 = 11, \\ket{\\psi_4} = Z^{1}X^{1}\\ket{\\psi_3(11)} = \\alpha\\ket{0} + \\beta\\ket{1} = \\ket{\\psi} \n",
+    "\\end{aligned}\n",
+    "$$"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It is clear to see that in all instances, we recover $\\ket{\\psi}$ on Bob's qubit thus fulfilling our ambition of teleporting an unknown quantum state between 2 parties. \n",
+    "\n",
+    "It is important to note that quantum teleportation does not allow communication faster than the speed of light. The state $\\ket{\\psi}$ does not instantly appear with Bob. Alice has to use a classical communication channel which is bound by the speed of classical physics to communicate her measurement results to Bob so that he can make the minor corrections required. \n",
+    "\n",
+    "Moreover teleportation does not violate the no-cloning theorem. The protocol does not allow us to create a copy of $\\ket{\\psi}$ leaving us with $\\ket{\\psi\\psi}$ but rather transmits $\\ket{\\psi}$ from Alice to Bob. "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The images used in this notebook are courtesey of the Quantum Computation and Quantum Information textbook by Nielsen & Chuang.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.12"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/sphinx/examples/python/tutorials/quantum_volume.ipynb b/docs/sphinx/examples/python/tutorials/quantum_volume.ipynb
new file mode 100644
index 0000000000..619425dccf
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/quantum_volume.ipynb
@@ -0,0 +1,402 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0b2a1f13-07b1-4b72-9c81-4da1ba62aec6",
+   "metadata": {},
+   "source": [
+    "# Quantum Volume\n",
+    "\n",
+    "[Quantum volume](https://en.wikipedia.org/wiki/Quantum_volume) (QV) is a metric for determining the power of a noisy quantum device.  The QV test is performed for a specified qubit number $N$. If the test is passed, then the device can claim a quantum volume of $2^N$.  In practice, the procedure repeats, until the device reaches a qubit number for which the test fails and its greatest passing score is the device's quantum volume. Though imperfect, the test is a reasonable  approximation of the devices usable processing power. This tutorial will demonstrate how CUDA-Q can be used to perform the quantum volume test.\n",
+    "\n",
+    "\n",
+    "The test consists of the following steps (see figure below):\n",
+    "1. A special random circuit is constructed (details below)\n",
+    "2. A simulation determines the exact probability distribution of every bitstring and the median probability is determined.\n",
+    "3. Every bitstring which has an associated probability greater than the median, is considered a heavy bitstring for that particular circuit.\n",
+    "4. The circuit is sampled on the noisy device, and the percent of shots resulting in heavy bitstring are\n",
+    "5. The process is repeated many times and the resulted averaged. The test is passed if the average is greater than 2/3.\n",
+    "\n",
+    "\n",
+    "\n",
+    "<img src=\"./images/QVprocedure.png\" alt=\"Drawing\" style=\"width: 700px;\"/>\n",
+    "\n",
+    "the circuits used are square, meaning they have the same number of layers as qubits. Each layer consists of a random permutation of qubits, followed by random SU4 operations applied to n/2 pairs of qubits.  (See the first step in the figure above).  For CUDA-Q implementation, the SU4 gates are decomposed using the KAK decomposition (figure from this [paper](https://arxiv.org/pdf/1811.12926)).\n",
+    "\n",
+    "\n",
+    "<img src=\"./images/kakdecomp.png\" alt=\"Drawing\" style=\"width: 500px;\"/>\n",
+    "\n",
+    "The cell below specifies a circuit size `n` and two CUDA-Q kernels, one performing an SU4 operation and another building the entire QV circuit. This example is constructed for an even number of qubits for simplicity.\n",
+    "\n",
+    "The QV kernel concludes with application of a bit flip operation on each qubit. This is not part of the QV circuit, but will be used later to introduce noise to the circuit. Otherwise the test would pass every time!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b748ca48-8c65-4158-8c8a-126bbbb39afe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np\n",
+    "\n",
+    "# Select an even number\n",
+    "n = 4\n",
+    "su4_per_circuit = int(n / 2 * n)\n",
+    "n_params_in_su4 = 21\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def su4_gate(q0: cudaq.qubit, q1: cudaq.qubit, params: list[float]):\n",
+    "    u3(params[0], params[1], params[2], q0)\n",
+    "    u3(params[3], params[4], params[5], q1)\n",
+    "    x.ctrl(q0, q1)\n",
+    "    u3(params[6], params[7], params[8], q0)\n",
+    "    u3(params[9], params[10], params[11], q1)\n",
+    "    x.ctrl(q1, q0)\n",
+    "    u3(params[12], params[13], params[14], q0)\n",
+    "    x.ctrl(q0, q1)\n",
+    "    u3(params[15], params[16], params[17], q0)\n",
+    "    u3(params[18], params[19], params[20], q0)\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def qv(n: int, params: list[float], permutations: list[int]):\n",
+    "\n",
+    "    reg = cudaq.qvector(n)\n",
+    "    param_index = 0\n",
+    "\n",
+    "    for layer in range(n):\n",
+    "        for gate in range(n / 2):\n",
+    "            su4_gate(reg[permutations[layer * n + gate * 2]],\n",
+    "                     reg[permutations[layer * n + gate * 2 + 1]],\n",
+    "                     params[param_index:param_index + 21])\n",
+    "            param_index += 21\n",
+    "\n",
+    "    x(reg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3d3fb4f-ca18-4eea-9b65-609fbc31317c",
+   "metadata": {},
+   "source": [
+    "Each circuit must be random. These function randomly choose parameters and permutations for each circuit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b139613f-f6ca-48de-a4c2-59aa7d705764",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_random_params() -> list[float]:\n",
+    "\n",
+    "    params = np.random.uniform(0, 2 * np.pi, n_params_in_su4 * su4_per_circuit)\n",
+    "\n",
+    "    params_list = params.tolist()\n",
+    "\n",
+    "    return params_list\n",
+    "\n",
+    "    return np.random.uniform(0, 2 * np.pi, n_params_in_su4 * su4_per_circuit)\n",
+    "\n",
+    "\n",
+    "def generate_random_permutations() -> list[int]:\n",
+    "\n",
+    "    circuit_permutations = []\n",
+    "\n",
+    "    for i in range(n):\n",
+    "        circuit_permutations.extend(\n",
+    "            np.random.permutation(n).astype(np.int64).tolist())\n",
+    "\n",
+    "    return circuit_permutations\n",
+    "\n",
+    "\n",
+    "parameters = generate_random_params()\n",
+    "permutations = generate_random_permutations()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d11fd5a-da31-4645-976d-7d944ba4e18e",
+   "metadata": {},
+   "source": [
+    "This function is an auxillary function used later to convert an integer into a \"big endian\" bitstring. This is used to help determine the heavy bitstrings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ded42cc6-3bf7-4b56-90ca-0e69cbe85dad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_bitstring(integer) -> str:\n",
+    "\n",
+    "    return bin(integer)[2:].zfill(n)[::-1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d631da6-97e3-473c-b59f-beb2302fa75e",
+   "metadata": {},
+   "source": [
+    "The `percent_heavy_sampled` function takes the random circuit parameters and permutations and the error rate and returns the percent of heavy bitstrings produced by a noisy circuit sample.  \n",
+    "\n",
+    "The function first sets up the noise model.  It assumes that each $X$ gate applied at the end of the circuit will fail with some probability denoted by the `error_rate`.\n",
+    "\n",
+    "Next, the noiseless simulation is performed on a GPU simulated with the `nvidia` backend to obtain the state vector.  The `density-matrix-cpu` backend is used to sample the noisy circuit. \n",
+    "\n",
+    "The rest of function processes these results to determine the heavy bitstring sample probabilities."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e852e3c5-29a0-4588-ac56-a102463aa100",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def percent_heavy_sampled(circuit_params,\n",
+    "                          layer_permutations,\n",
+    "                          error_rate,\n",
+    "                          print_output=False) -> float:\n",
+    "\n",
+    "    # Includes option to print results for a single circuit\n",
+    "\n",
+    "    # Define a bit flip error applied to all qubits\n",
+    "    noise = cudaq.NoiseModel()\n",
+    "    bf = cudaq.BitFlipChannel(error_rate)\n",
+    "    for i in range(n):\n",
+    "        noise.add_channel('x', [i], bf)\n",
+    "\n",
+    "    # Gets noiseless probability distribution\n",
+    "    # cudaq.set_target('nvidia')\n",
+    "    clean_result = np.array(\n",
+    "        cudaq.get_state(qv, n, circuit_params, layer_permutations))\n",
+    "\n",
+    "    # Performs noisy sampling\n",
+    "    cudaq.set_target('density-matrix-cpu')\n",
+    "    noisy_result = cudaq.sample(qv,\n",
+    "                                n,\n",
+    "                                circuit_params,\n",
+    "                                layer_permutations,\n",
+    "                                noise_model=noise,\n",
+    "                                shots_count=1000)\n",
+    "\n",
+    "    # Converts SV amplitudes to probabilities\n",
+    "    probs = clean_result * np.conjugate(clean_result)\n",
+    "\n",
+    "    # Determines the median value\n",
+    "    cutoff = np.median(probs).real\n",
+    "\n",
+    "    if print_output:\n",
+    "        print('The Median for this circuit is:')\n",
+    "        print(np.median(probs).real)\n",
+    "\n",
+    "    # Determines if a bitstring is heavy and saves the bitstring in a list if so.\n",
+    "    heavy = []\n",
+    "    index = 0\n",
+    "    circuit_prob = 0\n",
+    "    for outcome_prob in probs:\n",
+    "        if outcome_prob.real > cutoff:\n",
+    "            heavy.append(make_bitstring(index))\n",
+    "            circuit_prob += outcome_prob.real\n",
+    "        index += 1\n",
+    "\n",
+    "    if print_output:\n",
+    "\n",
+    "        print('The heavy bitstrings for this circuit are')\n",
+    "        print(heavy)\n",
+    "\n",
+    "        print('This circuit has an ideal havy sampling probability of:')\n",
+    "        print(circuit_prob)\n",
+    "\n",
+    "    # Determines percent of noisy sample results that are heavy\n",
+    "    prob_heavy_in_noisy = 0\n",
+    "    for heavy_bitstring in heavy:\n",
+    "        prob_heavy_in_noisy += noisy_result.probability(heavy_bitstring)\n",
+    "\n",
+    "    if print_output:\n",
+    "        print('Percent of time noisy sample returned heavy bitstring')\n",
+    "        print(prob_heavy_in_noisy)\n",
+    "\n",
+    "    # Returns this probability\n",
+    "    return prob_heavy_in_noisy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8eb4fff-c031-40d1-b521-7aea8bc1014f",
+   "metadata": {},
+   "source": [
+    "You can test a single circuit below to see if it passes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9cd7d79d-f489-426e-97a7-8664e62799a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The Median for this circuit is:\n",
+      "0.061406747\n",
+      "The heavy bitstrings for this circuit are\n",
+      "['1100', '1010', '0110', '1110', '0101', '1101', '1011', '1111']\n",
+      "This circuit has an ideal havy sampling probability of:\n",
+      "0.7811960875988007\n",
+      "Percent of time noisy sample returned heavy bitstring\n",
+      "0.297\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0.297"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "percent_heavy_sampled(parameters, permutations, 1, True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ecd2b646-df3e-4b4c-b9be-851f6bdb6116",
+   "metadata": {},
+   "source": [
+    "The true quantum volume is detemined by repeating the process many times and averaging the results. This function repeatedly applies the `percent _heavy_sampled` function for `n_circuit`number of times and prints if the test is passed and returns the average."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f94562c0-7ceb-4609-9e55-ae8791cd8dc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calc_qv(n_circuits, circuit_size, prob_of_error) -> float:\n",
+    "\n",
+    "    n = circuit_size\n",
+    "    su4_per_circuit = int(n / 2 * n)\n",
+    "    number_of_circuits = n_circuits\n",
+    "\n",
+    "    counter = 0\n",
+    "    circuit_results = []\n",
+    "\n",
+    "    # Loop over n_circuits\n",
+    "    while counter < number_of_circuits:\n",
+    "        parameters = generate_random_params()\n",
+    "        permutations = generate_random_permutations()\n",
+    "\n",
+    "        circuit_results.append(\n",
+    "            percent_heavy_sampled(parameters,\n",
+    "                                  permutations,\n",
+    "                                  prob_of_error,\n",
+    "                                  print_output=False))\n",
+    "\n",
+    "        counter += 1\n",
+    "\n",
+    "    # Average the results\n",
+    "    score = sum(circuit_results) / len(circuit_results)\n",
+    "\n",
+    "    print('The score is:')\n",
+    "    print(score)\n",
+    "\n",
+    "    # Determined if QV test is passed\n",
+    "    if score > 2 / 3:\n",
+    "        print('passed!')\n",
+    "        print('Quantum Volume')\n",
+    "        print(2**n)\n",
+    "\n",
+    "    else:\n",
+    "        print('failed QV Test')\n",
+    "\n",
+    "    return score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2279de84-bb73-48a9-a33b-3aa2efa66573",
+   "metadata": {},
+   "source": [
+    "Try running the QV procedure for 100 four qubit circuits with a 10% chance of error"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3cab12da-7cbc-4ff3-80d8-2a81007942ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The score is:\n",
+      "0.7269199999999999\n",
+      "passed!\n",
+      "Quantum Volume\n",
+      "16\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0.7269199999999999"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "n = 4\n",
+    "calc_qv(100, n, .1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afbc7d0a-2507-42e4-9946-3aa93384c645",
+   "metadata": {},
+   "source": [
+    "an interesting benefit of simulation is the ability to explore how noise might affect the QV results.  In this case, the noise model is trivial, but it is still possible to see a relationship between the probability of error in the $X$ gates and the QV outcome. \n",
+    "\n",
+    "\n",
+    "<img src=\"./images/qvplot.png\" alt=\"Drawing\" style=\"width: 900px;\"/>"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb b/docs/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb
index 1d1fee4095..ec366366bd 100644
--- a/docs/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb
+++ b/docs/sphinx/examples/python/tutorials/readout_error_mitigation.ipynb
@@ -33,10 +33,7 @@
    "source": [
     "# Install the relevant packages.\n",
     "\n",
-    "!pip install matplotlib==3.8.4\n",
-    "!pip install pandas==2.2.2\n",
-    "!pip install scipy==1.13.1\n",
-    "!pip install seaborn==0.13.2"
+    "!pip install matplotlib==3.8.4 pandas==2.2.2 scipy==1.13.1 seaborn==0.13.2 -q"
    ]
   },
   {
@@ -130,9 +127,8 @@
     "    for i, val in enumerate(state_label):\n",
     "        if val == 1:\n",
     "            x(qvector[i])\n",
-    "        rx(\n",
-    "            0.0, qvector[i]\n",
-    "        )  # Identity gate at the end on each qubit to model readout error\n",
+    "        rx(0.0, qvector[i]\n",
+    "          )  # Identity gate at the end on each qubit to model readout error\n",
     "    mz(qvector)"
    ]
   },
@@ -229,8 +225,14 @@
     "\n",
     "    # Constraint: all elements of p must be positive, and the distribution must sum to 1\n",
     "    cons = (\n",
-    "        {\"type\": \"ineq\", \"fun\": lambda p: p},\n",
-    "        {\"type\": \"eq\", \"fun\": lambda p: np.sum(p) - 1},\n",
+    "        {\n",
+    "            \"type\": \"ineq\",\n",
+    "            \"fun\": lambda p: p\n",
+    "        },\n",
+    "        {\n",
+    "            \"type\": \"eq\",\n",
+    "            \"fun\": lambda p: np.sum(p) - 1\n",
+    "        },\n",
     "    )\n",
     "    bnds = [(0, 1) for _ in range(len(empirical_dist))]\n",
     "    initial_value = np.random.uniform(size=len(empirical_dist))\n",
@@ -332,10 +334,14 @@
     "\n",
     "noise_1 = get_noise(n_qubits, p)\n",
     "\n",
-    "ghz_result = cudaq.sample(ghz_kernel, n_qubits, shots_count=shots, noise_model=noise_1)\n",
+    "ghz_result = cudaq.sample(ghz_kernel,\n",
+    "                          n_qubits,\n",
+    "                          shots_count=shots,\n",
+    "                          noise_model=noise_1)\n",
     "noisy_dict_1 = dict(list(ghz_result.items()))\n",
     "\n",
-    "noisy_res_1 = np.array([noisy_dict_1.get(state, 0) for i, state in enumerate(states)])\n",
+    "noisy_res_1 = np.array(\n",
+    "    [noisy_dict_1.get(state, 0) for i, state in enumerate(states)])\n",
     "\n",
     "noisy_dict_1"
    ]
@@ -378,10 +384,14 @@
     "\n",
     "noise_2 = get_noise(n_qubits, p)\n",
     "\n",
-    "ghz_result = cudaq.sample(ghz_kernel, n_qubits, shots_count=shots, noise_model=noise_2)\n",
+    "ghz_result = cudaq.sample(ghz_kernel,\n",
+    "                          n_qubits,\n",
+    "                          shots_count=shots,\n",
+    "                          noise_model=noise_2)\n",
     "noisy_dict_2 = dict(list(ghz_result.items()))\n",
     "\n",
-    "noisy_res_2 = np.array([noisy_dict_2.get(state, 0) for i, state in enumerate(states)])\n",
+    "noisy_res_2 = np.array(\n",
+    "    [noisy_dict_2.get(state, 0) for i, state in enumerate(states)])\n",
     "\n",
     "noisy_dict_2"
    ]
@@ -485,7 +495,8 @@
    "source": [
     "A = reduce(np.kron, [A_1] * n_qubits)  # joint confusion matrix\n",
     "A_pinv = np.linalg.pinv(A)  # Generate pseudoinverse confusion matrix.\n",
-    "mitigated = np.array(np.dot(A_pinv, noisy_res_1), dtype=int)  # Obtain mitigated counts\n",
+    "mitigated = np.array(np.dot(A_pinv, noisy_res_1),\n",
+    "                     dtype=int)  # Obtain mitigated counts\n",
     "print(f\"Mitigated counts:\\n{mitigated}\")\n",
     "\n",
     "if not np.all(mitigated >= 0):\n",
@@ -512,15 +523,16 @@
     }
    ],
    "source": [
-    "df = pd.DataFrame(\n",
-    "    {\n",
-    "        \"states\": states,\n",
-    "        \"noisy\": np.around(noisy_res_1 / sum(noisy_res_1), 3),\n",
-    "        \"mitigated_sg\": np.around(mitigated / sum(mitigated), 3),\n",
-    "    }\n",
-    ")\n",
+    "df = pd.DataFrame({\n",
+    "    \"states\": states,\n",
+    "    \"noisy\": np.around(noisy_res_1 / sum(noisy_res_1), 3),\n",
+    "    \"mitigated_sg\": np.around(mitigated / sum(mitigated), 3),\n",
+    "})\n",
     "\n",
-    "ax = df.plot(x=\"states\", y=[\"noisy\", \"mitigated_sg\"], kind=\"bar\", figsize=(8, 5))\n",
+    "ax = df.plot(x=\"states\",\n",
+    "             y=[\"noisy\", \"mitigated_sg\"],\n",
+    "             kind=\"bar\",\n",
+    "             figsize=(8, 5))\n",
     "ax.bar_label(ax.containers[0], labels=df[\"noisy\"])\n",
     "ax.bar_label(ax.containers[1], labels=df[\"mitigated_sg\"])\n",
     "ax.set_ylabel(\"probabilities\")\n",
@@ -561,8 +573,11 @@
     "local_states = [\"0\" * n_qubits, \"1\" * n_qubits]\n",
     "\n",
     "results = [\n",
-    "    cudaq.sample(kernel, n_qubits, label, shots_count=shots, noise_model=noise_2)\n",
-    "    for label in local_labels\n",
+    "    cudaq.sample(kernel,\n",
+    "                 n_qubits,\n",
+    "                 label,\n",
+    "                 shots_count=shots,\n",
+    "                 noise_model=noise_2) for label in local_labels\n",
     "]\n",
     "\n",
     "for i, state in enumerate(local_states):\n",
@@ -585,7 +600,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "counts = [dict(list(results[i].items())) for i, state in enumerate(local_states)]\n",
+    "counts = [\n",
+    "    dict(list(results[i].items())) for i, state in enumerate(local_states)\n",
+    "]\n",
     "matrices = []\n",
     "\n",
     "for k in range(n_qubits):\n",
@@ -600,7 +617,8 @@
     "    # matrix[i][j] is the probability of counting i for expected j\n",
     "    for i in range(2):\n",
     "        for j in range(2):\n",
-    "            matrix[i][j] = marginalized_counts[j].get(str(i), 0) / total_shots[j]\n",
+    "            matrix[i][j] = marginalized_counts[j].get(str(i),\n",
+    "                                                      0) / total_shots[j]\n",
     "    matrices.append(matrix)"
    ]
   },
@@ -697,15 +715,16 @@
     }
    ],
    "source": [
-    "df = pd.DataFrame(\n",
-    "    {\n",
-    "        \"states\": states,\n",
-    "        \"noisy\": np.around(noisy_res_2 / sum(noisy_res_2), 3),\n",
-    "        \"mitigated_k_local\": np.around(mitigated / sum(mitigated), 3),\n",
-    "    }\n",
-    ")\n",
+    "df = pd.DataFrame({\n",
+    "    \"states\": states,\n",
+    "    \"noisy\": np.around(noisy_res_2 / sum(noisy_res_2), 3),\n",
+    "    \"mitigated_k_local\": np.around(mitigated / sum(mitigated), 3),\n",
+    "})\n",
     "\n",
-    "ax = df.plot(x=\"states\", y=[\"noisy\", \"mitigated_k_local\"], kind=\"bar\", figsize=(8, 5))\n",
+    "ax = df.plot(x=\"states\",\n",
+    "             y=[\"noisy\", \"mitigated_k_local\"],\n",
+    "             kind=\"bar\",\n",
+    "             figsize=(8, 5))\n",
     "ax.bar_label(ax.containers[0], labels=df[\"noisy\"])\n",
     "ax.bar_label(ax.containers[1], labels=df[\"mitigated_k_local\"])\n",
     "ax.set_ylabel(\"probabilities\")\n",
@@ -745,8 +764,11 @@
    ],
    "source": [
     "results = [\n",
-    "    cudaq.sample(kernel, n_qubits, label, shots_count=shots, noise_model=noise_2)\n",
-    "    for label in labels\n",
+    "    cudaq.sample(kernel,\n",
+    "                 n_qubits,\n",
+    "                 label,\n",
+    "                 shots_count=shots,\n",
+    "                 noise_model=noise_2) for label in labels\n",
     "]\n",
     "\n",
     "for i, state in enumerate(states):\n",
diff --git a/docs/sphinx/examples/python/tutorials/Shors.ipynb b/docs/sphinx/examples/python/tutorials/shors.ipynb
similarity index 97%
rename from docs/sphinx/examples/python/tutorials/Shors.ipynb
rename to docs/sphinx/examples/python/tutorials/shors.ipynb
index dbfff32498..8063162ee4 100644
--- a/docs/sphinx/examples/python/tutorials/Shors.ipynb
+++ b/docs/sphinx/examples/python/tutorials/shors.ipynb
@@ -34,7 +34,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install contfrac"
+    "!pip install contfrac==1.0.0 -q"
    ]
   },
   {
@@ -53,7 +53,7 @@
     "from cudaq import *\n",
     "import fractions\n",
     "import matplotlib.pyplot as plt\n",
-    "import contfrac\n"
+    "import contfrac"
    ]
   },
   {
@@ -131,7 +131,8 @@
     "        divisor1 = gcd(a, N)\n",
     "        if divisor1 != 1:\n",
     "            divisor2 = N // divisor1\n",
-    "            print(\"Found factors of N={} by chance: {} and {}\".format(N, divisor1, divisor2))\n",
+    "            print(\"Found factors of N={} by chance: {} and {}\".format(\n",
+    "                N, divisor1, divisor2))\n",
     "            return (divisor1, divisor2)\n",
     "\n",
     "        # 3. Find the order of a mod N (i.e., r, where a^r = 1 (mod N))\n",
@@ -139,7 +140,7 @@
     "            r = find_order_quantum(a, N)\n",
     "        else:\n",
     "            r = find_order_classical(a, N)\n",
-    "        print(\"The order of a = {} is {}\".format(a,r))\n",
+    "        print(\"The order of a = {} is {}\".format(a, r))\n",
     "\n",
     "        # 4. If the order of a is found and it is\n",
     "        # * even and\n",
@@ -148,7 +149,8 @@
     "        # We also want to rule out the case of finding the trivial factors: 1 and N.\n",
     "        divisor1, divisor2 = test_order(a, r, N)\n",
     "        if (divisor1 != 0):  # test_order will return a 0 if no factor is found\n",
-    "            print(\"Found factors of N = {}: {} and {}\".format(N,divisor1, divisor2))\n",
+    "            print(\"Found factors of N = {}: {} and {}\".format(\n",
+    "                N, divisor1, divisor2))\n",
     "            return divisor1, divisor2\n",
     "\n",
     "        # 5. Repeat\n",
@@ -212,7 +214,7 @@
     "    # period did not produce a factor\n",
     "    else:\n",
     "        print('No non-trivial factor found')\n",
-    "        return 0, 0\n"
+    "        return 0, 0"
    ]
   },
   {
@@ -404,10 +406,11 @@
     "    x(work[0])\n",
     "    x(work[2])\n",
     "    x(work[4])\n",
-    "    \n",
+    "\n",
     "    swap(work[0], work[4])\n",
     "    swap(work[0], work[2])\n",
     "\n",
+    "\n",
     "@cudaq.kernel\n",
     "def modular_exp_5_21(exponent: cudaq.qview, work: cudaq.qview,\n",
     "                     control_size: int):\n",
@@ -418,8 +421,7 @@
     "    for exp in range(control_size):\n",
     "        ctrl_qubit = exponent[exp]\n",
     "        for _ in range(2**(exp)):\n",
-    "            cudaq.control(modular_mult_5_21, ctrl_qubit, work)\n",
-    "\n"
+    "            cudaq.control(modular_mult_5_21, ctrl_qubit, work)"
    ]
   },
   {
@@ -464,17 +466,18 @@
     "@cudaq.kernel\n",
     "def demonstrate_mod_exponentiation(iterations: int):\n",
     "    qubits = cudaq.qvector(5)\n",
-    "    x(qubits[0]) # initalizes the qubits in the state for y = 1 which is |10000>\n",
+    "    x(qubits[0]\n",
+    "     )  # initalizes the qubits in the state for y = 1 which is |10000>\n",
     "    for _ in range(iterations):\n",
     "        modular_mult_5_21(qubits)\n",
     "\n",
     "\n",
     "shots = 200\n",
     "\n",
-    "# The iterations variable determines the exponent in 5^x mod 21. \n",
+    "# The iterations variable determines the exponent in 5^x mod 21.\n",
     "# Change this value to verify that the demonstrate_mod_exponentiation\n",
     "# kernel carries out the desired calculation.\n",
-    "iterations = 1  \n",
+    "iterations = 1\n",
     "\n",
     "print(cudaq.draw(demonstrate_mod_exponentiation, iterations))\n",
     "\n",
@@ -486,11 +489,11 @@
     "\n",
     "# Reverse the order of the most probable measured bit string\n",
     "# and convert the binary string to an integer\n",
-    "integer_result = int(results.most_probable()[::-1],2)\n",
+    "integer_result = int(results.most_probable()[::-1], 2)\n",
     "\n",
     "print(\"For x = {}, 5^x mod 21 = {}\".format(iterations, (5**iterations) % 21))\n",
     "print(\"For x = {}, the computed result of the circuit is {}\".format(\n",
-    "    iterations, integer_result))\n"
+    "    iterations, integer_result))"
    ]
   },
   {
@@ -533,8 +536,7 @@
     "    x.ctrl(work[1], work[0])\n",
     "    x.ctrl([exponent[0], work[0]], work[1])\n",
     "    x.ctrl(work[1], work[0])\n",
-    "    swap(exponent[0], exponent[2])\n",
-    "    "
+    "    swap(exponent[0], exponent[2])"
    ]
   },
   {
@@ -574,7 +576,7 @@
     "    inverse_qft(control_register)\n",
     "\n",
     "    # Measure only the control_register and not the work_register\n",
-    "    mz(control_register)\n"
+    "    mz(control_register)"
    ]
   },
   {
@@ -797,15 +799,18 @@
     "    print('eigenphase is ', eigenphase)\n",
     "    coefficients_continued_fraction = list(\n",
     "        contfrac.continued_fraction(eigenphase))\n",
-    "    \n",
+    "\n",
     "    convergents_continued_fraction = list(contfrac.convergents(eigenphase))\n",
-    "    print('convergent sequence of fractions for this eigenphase is', convergents_continued_fraction)\n",
+    "    print('convergent sequence of fractions for this eigenphase is',\n",
+    "          convergents_continued_fraction)\n",
     "    for r in convergents_continued_fraction:\n",
-    "        print('using the denominators of the fractions in the convergent sequence, testing order =', r[1])\n",
+    "        print(\n",
+    "            'using the denominators of the fractions in the convergent sequence, testing order =',\n",
+    "            r[1])\n",
     "        if a**r[1] % N == 1:\n",
     "            print('Found order:', r[1])\n",
     "            return (r[1])\n",
-    "    return None\n"
+    "    return None"
    ]
   },
   {
@@ -864,11 +869,11 @@
     "        most_probable_bitpatterns = top_results(results, zero_result, threshold)\n",
     "\n",
     "        for key in most_probable_bitpatterns:\n",
-    "            # Convert the key bit string into an integer \n",
+    "            # Convert the key bit string into an integer\n",
     "            # This integer divided by 8 is an estimate for the phase\n",
     "            reverse_result = key[::-1]\n",
     "            phase = int(reverse_result, 2)\n",
-    "            \n",
+    "\n",
     "            print(\"Trying nonzero bitpattern from the phase estimation:\", key,\n",
     "                  \"=\", phase)\n",
     "            r = get_order_from_phase(phase, control_register_size, a, N)\n",
@@ -955,12 +960,6 @@
     "### Postscript\n",
     "Recent [work of Oded Regev](https://arxiv.org/abs/2308.06572) improves Shor's Algorithm by reducing the number of gates needed.  You can read more about it [here](https://www.quantamagazine.org/thirty-years-later-a-speed-boost-for-quantum-factoring-20231017/)."
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "db11e690",
-   "metadata": {},
-   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/sphinx/examples/python/tutorials/trotter.ipynb b/docs/sphinx/examples/python/tutorials/trotter.ipynb
new file mode 100644
index 0000000000..a44c78249f
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/trotter.ipynb
@@ -0,0 +1,297 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "231113c7-9432-497b-91f1-c4d068dd61b8",
+   "metadata": {},
+   "source": [
+    "# Computing Magnetization With The Suzuki-Trotter Approximation\n",
+    "\n",
+    "A key application for quantum computers is the simulation of quantum systems. This tutorial will demonstrate a CUDA-Q implementation of a Suzuki-Trotter simulation of a Heisenberg Model Hamiltonian to compute the magnetization of a spin chain.\n",
+    "\n",
+    "This example takes advantage of CUDA-Q's state handling abilities to perform the recursive Trotter simulations. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ccd64e3-9e36-470b-9b15-2a7de6bf6ee3",
+   "metadata": {},
+   "source": [
+    "### Problem Setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5c2633a0-979b-46b8-a7a6-44fa61bc62c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/qutip/__init__.py:66: UserWarning: The new version of Cython, (>= 3.0.0) is not supported.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cudaq\n",
+    "import time\n",
+    "import numpy as np\n",
+    "from typing import List"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbbf2909-2607-48d1-aa72-6594f09bbd88",
+   "metadata": {},
+   "source": [
+    "The goal of this problem is to estimate the time evolution of an initial quantum state, governed by a Hamiltonian, and then compute the average magnetization fo the final state.  The time evolution can be approximated using the Trotter method:\n",
+    "\n",
+    "$$  e^{-iHt} \\approx \\prod_{n=0}^N e^{\\frac{-iHt}{n}}$$\n",
+    "\n",
+    "The Heisenberg Hamiltonian is defined below, parameterized by these predefined constants: $g$, $Jx$, $Jy$, and $\\omega = 2\\pi$.   The time step $dt$ is selected for this problem as well as `n_steps` and `n_spins` ($N$), determining the size of the simulation.  The default setup considers 11 spins and 10 steps, which can easily be simulated on a CPU.  If you have access to at least one GPU, the problem can be increased to around 25 steps and 100 time steps.\n",
+    "\n",
+    "\n",
+    "$$ H = \\sum_{j=1}^{N}(J_x\\sigma^x_j\\sigma^x_{j+1} + J_x\\sigma^y_j\\sigma^y_{j+1} + J_x\\sigma^z_j\\sigma^z_{j+1} + \\cos(\\omega * t)\\sigma^x_j   )$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e409539e-e97b-4815-8021-477308726155",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "g = 1.0\n",
+    "Jx = 1.0\n",
+    "Jy = 1.0\n",
+    "Jz = g\n",
+    "dt = 0.05\n",
+    "n_steps = 10\n",
+    "n_spins = 11\n",
+    "omega = 2 * np.pi\n",
+    "\n",
+    "\n",
+    "def heisenbergModelHam(t: float) -> cudaq.SpinOperator:\n",
+    "    tdOp = cudaq.SpinOperator(num_qubits=n_spins)\n",
+    "    for i in range(0, n_spins - 1):\n",
+    "        tdOp += (Jx * cudaq.spin.x(i) * cudaq.spin.x(i + 1))\n",
+    "        tdOp += (Jy * cudaq.spin.y(i) * cudaq.spin.y(i + 1))\n",
+    "        tdOp += (Jz * cudaq.spin.z(i) * cudaq.spin.z(i + 1))\n",
+    "    for i in range(0, n_spins):\n",
+    "        tdOp += (np.cos(omega * t) * cudaq.spin.x(i))\n",
+    "    return tdOp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "067ae183-8e36-4171-adaf-c8506ac2ac48",
+   "metadata": {},
+   "source": [
+    "Next, two CUDA-Q kernels are defined. The first, `getInitState`, prepares an initial state where an $X$ gate is applied to the first and then every other qubit to initialize a chain of alternating spins. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1b64301b-f967-4e69-95d7-64a0091054cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def getInitState(numSpins: int):\n",
+    "    q = cudaq.qvector(numSpins)\n",
+    "    for qId in range(0, numSpins, 2):\n",
+    "        x(q[qId])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0077726b-7c07-4699-8f05-b685d8a4d3a7",
+   "metadata": {},
+   "source": [
+    "The second, `trotter`, performs a single Trotter step given some provided initial state and then returns the resulting state.  Two notes should be made about this kernel. \n",
+    "1. It takes advantage of CUDA-Q's state handling abilities, allowing each step to proceed from the previous, still stored in GPU memory during the simulation.  This provides a significant speedup which is demonstrated in the plot at the end of this tutorial.\n",
+    "2. This kernel takes advantage of the `pauli_word` object which allows a list of Pauli words and their coefficients to be passed into the kernel and applied as an exponentiated matrix operation using `exp_pauli`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4bd5de1b-76c5-4dd7-844a-dfc598a78e6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def trotter(state: cudaq.State, coefficients: List[complex],\n",
+    "            words: List[cudaq.pauli_word], dt: float):\n",
+    "    q = cudaq.qvector(state)\n",
+    "    for i in range(len(coefficients)):\n",
+    "        exp_pauli(coefficients[i].real * dt, q, words[i])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "74593ace-c2d5-4b4b-931f-54fc4f6ee855",
+   "metadata": {},
+   "source": [
+    "The functions below are used to strip the Hamiltonian spin operator into a list of coefficients and Pauli words."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0aeba077-3a12-4c1d-919e-efc521f531fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def termCoefficients(op: cudaq.SpinOperator) -> List[complex]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "def termWords(op: cudaq.SpinOperator) -> List[str]:\n",
+    "    result = []\n",
+    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02aa14dc-bf7a-40e2-b55c-77e4e1d13d33",
+   "metadata": {},
+   "source": [
+    "Finally, a second spin operator is defined which will be used to compute the expectation value corresponding to the average magnetization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e0be9949-0d1a-44f5-bdeb-6be751dfe136",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "average_magnetization = cudaq.SpinOperator(num_qubits=n_spins)\n",
+    "for i in range(0, n_spins):\n",
+    "    average_magnetization += ((1.0 / n_spins) * cudaq.spin.z(i))\n",
+    "average_magnetization -= 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5527c9b-86e0-4f3d-b5cf-db887d07b375",
+   "metadata": {},
+   "source": [
+    "### Running the Simulation\n",
+    "\n",
+    "Before looping through the Trotter steps, the initial state is constructed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "78348fa1-6f14-4238-a6ec-b0c8449892d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "state = cudaq.get_state(getInitState, n_spins)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "812b8f44-0a96-4d43-a622-8a4b4a59241d",
+   "metadata": {},
+   "source": [
+    "Next, the time steps are looped through. At each step, the time dependent Hamiltonian is defined. This Hamiltonian is used to construct the Trotter kernel for that time step, which is then used to compute the average magnetization expectation value.  The state is saved, and used as the initial state for the next time step. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "57e4929d-9b79-4d21-b48a-27d47d7e65a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Step 0: time [s]: 0.03444695472717285, result: -0.09042024163828166\n",
+      "Step 1: time [s]: 0.0026793479919433594, result: -0.08898564687193886\n",
+      "Step 2: time [s]: 0.002758026123046875, result: -0.08698024360923415\n",
+      "Step 3: time [s]: 0.002524852752685547, result: -0.08507694741170907\n",
+      "Step 4: time [s]: 0.0026259422302246094, result: -0.08394118068746997\n",
+      "Step 5: time [s]: 0.002542734146118164, result: -0.08394076573115139\n",
+      "Step 6: time [s]: 0.0027430057525634766, result: -0.08502222139504187\n",
+      "Step 7: time [s]: 0.0025305747985839844, result: -0.08677832064885871\n",
+      "Step 8: time [s]: 0.003045797348022461, result: -0.08863390649349775\n",
+      "Step 9: time [s]: 0.0025949478149414062, result: -0.09005513983609514\n",
+      "Step times: [0.03444695472717285, 0.0026793479919433594, 0.002758026123046875, 0.002524852752685547, 0.0026259422302246094, 0.002542734146118164, 0.0027430057525634766, 0.0025305747985839844, 0.003045797348022461, 0.0025949478149414062]\n",
+      "Results: [-0.09042024163828166, -0.08898564687193886, -0.08698024360923415, -0.08507694741170907, -0.08394118068746997, -0.08394076573115139, -0.08502222139504187, -0.08677832064885871, -0.08863390649349775, -0.09005513983609514]\n"
+     ]
+    }
+   ],
+   "source": [
+    "results = []\n",
+    "times = []\n",
+    "for i in range(0, n_steps):\n",
+    "    start_time = time.time()\n",
+    "    ham = heisenbergModelHam(i * dt)\n",
+    "    coefficients = termCoefficients(ham)\n",
+    "    words = termWords(ham)\n",
+    "    magnetization_exp_val = cudaq.observe(trotter, average_magnetization, state,\n",
+    "                                          coefficients, words, dt)\n",
+    "    result = magnetization_exp_val.expectation()\n",
+    "    results.append(result)\n",
+    "    state = cudaq.get_state(trotter, state, coefficients, words, dt)\n",
+    "    stepTime = time.time() - start_time\n",
+    "    times.append(stepTime)\n",
+    "    print(f\"Step {i}: time [s]: {stepTime}, result: {result}\")\n",
+    "\n",
+    "print(f\"Step times: {times}\")\n",
+    "print(f\"Results: {results}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b46a3b14-31c0-4711-9064-51ca1f48e7d4",
+   "metadata": {},
+   "source": [
+    "CUDA-Q's state handling capabilities provide a massive performance boost for this algorithm. Rather than resimulate all previous operation at any given time step, saving the previous state in GPU memory allows completion of the simulation with fewer operations. The figure below demonstrates the 24X speedup realized by a 100 step Trotter simulation.\n",
+    "\n",
+    "![Htest](./images/statehandle.png)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f59cf33e-e939-4abe-ae48-2a77f25be5a0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/sphinx/examples/python/tutorials/unitary_compilation.ipynb b/docs/sphinx/examples/python/tutorials/unitary_compilation_diffusion_models.ipynb
similarity index 96%
rename from docs/sphinx/examples/python/tutorials/unitary_compilation.ipynb
rename to docs/sphinx/examples/python/tutorials/unitary_compilation_diffusion_models.ipynb
index f0b3b1268b..e5020c5bee 100644
--- a/docs/sphinx/examples/python/tutorials/unitary_compilation.ipynb
+++ b/docs/sphinx/examples/python/tutorials/unitary_compilation_diffusion_models.ipynb
@@ -232,9 +232,11 @@
    },
    "outputs": [],
    "source": [
-    "vocab         = {i+1:gate for i, gate in enumerate(pipeline.gate_pool)}  # Gateset used during training, used for decoding\n",
-    "num_of_qubits = 3                                                        # Number of qubits\n",
-    "max_gates     = 12                                                       # Maximum number of gates"
+    "vocab = {\n",
+    "    i + 1: gate for i, gate in enumerate(pipeline.gate_pool)\n",
+    "}  # Gateset used during training, used for decoding\n",
+    "num_of_qubits = 3  # Number of qubits\n",
+    "max_gates = 12  # Maximum number of gates"
    ]
   },
   {
@@ -270,14 +272,15 @@
    },
    "outputs": [],
    "source": [
-    "U = np.matrix([[ 0.70710678,  0.        ,  0.        , 0.        ,  0.70710678,  0.        , 0.        ,  0.        ],\n",
-    "               [ 0.        , -0.70710678,  0.        , 0.        ,  0.        , -0.70710678, 0.        ,  0.        ],\n",
-    "               [-0.70710678,  0.        ,  0.        , 0.        ,  0.70710678,  0.        , 0.        ,  0.        ],\n",
-    "               [ 0.        ,  0.70710678,  0.        , 0.        ,  0.        , -0.70710678, 0.        ,  0.        ],\n",
-    "               [ 0.        ,  0.        ,  0.70710678, 0.        ,  0.        ,  0.        , 0.        ,  0.70710678],\n",
-    "               [ 0.        ,  0.        ,  0.        , 0.70710678,  0.        ,  0.        , 0.70710678,  0.        ],\n",
-    "               [ 0.        ,  0.        , -0.70710678, 0.        ,  0.        ,  0.        , 0.        ,  0.70710678],\n",
-    "               [ 0.        ,  0.        ,  0.        ,-0.70710678,  0.        ,  0.        , 0.70710678,  0.        ]], dtype=np.complex128)"
+    "U = np.matrix([[0.70710678, 0., 0., 0., 0.70710678, 0., 0., 0.],\n",
+    "               [0., -0.70710678, 0., 0., 0., -0.70710678, 0., 0.],\n",
+    "               [-0.70710678, 0., 0., 0., 0.70710678, 0., 0., 0.],\n",
+    "               [0., 0.70710678, 0., 0., 0., -0.70710678, 0., 0.],\n",
+    "               [0., 0., 0.70710678, 0., 0., 0., 0., 0.70710678],\n",
+    "               [0., 0., 0., 0.70710678, 0., 0., 0.70710678, 0.],\n",
+    "               [0., 0., -0.70710678, 0., 0., 0., 0., 0.70710678],\n",
+    "               [0., 0., 0., -0.70710678, 0., 0., 0.70710678, 0.]],\n",
+    "              dtype=np.complex128)"
    ]
   },
   {
@@ -452,7 +455,8 @@
    "outputs": [],
    "source": [
     "import cudaq\n",
-    "cudaq.set_target('qpp-cpu') # Note that cpu is faster for 3 qubit kernels\n",
+    "\n",
+    "cudaq.set_target('qpp-cpu')  # Note that cpu is faster for 3 qubit kernels\n",
     "\n",
     "# cudaq.set_target('nvidia') # Set to GPU for larger circuits"
    ]
@@ -494,23 +498,28 @@
     }
    ],
    "source": [
-    "kernel_list   = []\n",
+    "kernel_list = []\n",
     "valid_tensors = []\n",
     "\n",
     "invalid_tensors = 0\n",
     "for out_tensors_i in tqdm(out_tensors):\n",
     "\n",
     "    # Use a try-except to catch invalid tensors (if any)\n",
-    "    try:    kernel = genqc_to_cudaq(out_tensors_i, vocab)  # Convert out_tensors to CUDA-Q kernels\n",
-    "    except: kernel = None\n",
-    "        \n",
+    "    try:\n",
+    "        kernel = genqc_to_cudaq(out_tensors_i,\n",
+    "                                vocab)  # Convert out_tensors to CUDA-Q kernels\n",
+    "    except:\n",
+    "        kernel = None\n",
+    "\n",
     "    if kernel:\n",
     "        kernel_list.append(kernel)\n",
     "        valid_tensors.append(out_tensors_i)\n",
     "    else:\n",
-    "        invalid_tensors += 1 \n",
+    "        invalid_tensors += 1\n",
     "\n",
-    "print(f\"The model generated {invalid_tensors} invalid tensors that does not correspond to circuits.\")"
+    "print(\n",
+    "    f\"The model generated {invalid_tensors} invalid tensors that does not correspond to circuits.\"\n",
+    ")"
    ]
   },
   {
@@ -942,18 +951,20 @@
    ],
    "source": [
     "# First, we remove possible duplicates and only pick distinct circuits\n",
-    "_, idx_unique       = np.unique(np.array(valid_tensors), axis=0, return_index=True)\n",
-    "unique_tensors      = torch.stack(valid_tensors)[idx_unique]\n",
+    "_, idx_unique = np.unique(np.array(valid_tensors), axis=0, return_index=True)\n",
+    "unique_tensors = torch.stack(valid_tensors)[idx_unique]\n",
     "unique_infidelities = infidelities[idx_unique]\n",
-    "unique_kernels      = [kernel_list[idx] for idx in idx_unique]\n",
+    "unique_kernels = [kernel_list[idx] for idx in idx_unique]\n",
     "\n",
     "# Then, find the correct circuits\n",
-    "idx_correct     = torch.argwhere(torch.tensor(unique_infidelities) < 0.01).flatten()\n",
+    "idx_correct = torch.argwhere(torch.tensor(unique_infidelities) < 0.01).flatten()\n",
     "correct_tensors = unique_tensors[idx_correct]\n",
-    "print(f\"The model generated {correct_tensors.shape[0]} distinct correct circuits.\")\n",
+    "print(\n",
+    "    f\"The model generated {correct_tensors.shape[0]} distinct correct circuits.\"\n",
+    ")\n",
     "\n",
     "# Now let's flatten the last two dimensions (related to the actual circuit) and find out how many 5's (i.e. ccx) gates each circuit has:\n",
-    "num_ccx = (correct_tensors.flatten(1,2) == 5).sum(1)\n",
+    "num_ccx = (correct_tensors.flatten(1, 2) == 5).sum(1)\n",
     "print(\"These circuits have this number of ccx gates:\", num_ccx)"
    ]
   },
diff --git a/docs/sphinx/examples/python/tutorials/visualization.ipynb b/docs/sphinx/examples/python/tutorials/visualization.ipynb
deleted file mode 100644
index 518595b0c1..0000000000
--- a/docs/sphinx/examples/python/tutorials/visualization.ipynb
+++ /dev/null
@@ -1,301 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Visualization\n",
-    "\n",
-    "## Qubit Visualization\n",
-    "\n",
-    "What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?\n",
-    "\n",
-    "We know our qubit can have two distinct states: $\\ket{0}$ and $\\ket{1}$. If these were the only two states, we could represent them as two vectors on a one-dimensional line (i.e., the z-axis in the image below). We also know that qubits can be in an equal superposition of states: $\\ket{+}$ and $\\ket{-}$. In order to capture all of the states in equal superposition, we will need a 2D plane (i.e., the $xy$-plane in the image below). If you dive deeper you will learn about the existence of other states that will call for a 3D extension. \n",
-    "\n",
-    "In general, a quantum state can be written in the form $\\ket{\\psi} = \\cos(\\frac{\\theta}{2})\\ket{0}+e^{i\\varphi}\\sin(\\frac{\\theta}{2})\\ket{1}$ where $\\theta$ is a real number between $0$ and $\\pi$ and $\\varphi$ is a real value between $0$ and $2\\pi$.  For example, the minus state, $\\ket{-} = \\frac{1}{\\sqrt{2}}\\ket{0}- \\frac{1}{\\sqrt{2}}\\ket{1}$, can be rewritten as\n",
-    "$$\\ket{-}  = \\cos(\\frac{\\theta}{2})\\ket{0}+e^{i\\varphi}\\sin(\\frac{\\theta}{2})\\ket{1}\\text{ with }\\theta = \\frac{\\pi}{2}\\text{ and }\\varphi = \\pi.$$ \n",
-    "This can be visualized in the image below as a unit vector pointing in the direction of the negative $x$-axis.\n",
-    "\n",
-    "Using spherical coordinates, it is possible to depict all the possible states of a single qubit on a sphere. This is called a Bloch sphere. \n",
-    "\n",
-    "<img src=\"images/Bloch_sphere.png\" alt=\"Bloch Sphere\" width=\"300\" height=\"300\">\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. \n",
-    "First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.\n",
-    "\n",
-    "Note: CUDA-Q uses the [QuTiP](https://qutip.org) library to render Bloch spheres. The following code will throw an error if QuTiP is not installed. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "# install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.\n",
-    "# `matplotlib` is required for all visualization tasks.\n",
-    "# Make sure to restart your kernel if you execute this!\n",
-    "# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.\n",
-    "# In VSCode, click on the Restart button in the Jupyter toolbar.\n",
-    "\n",
-    "# The '\\' before the '>' operator is so that the shell does not misunderstand\n",
-    "# the '>' qualifier for the bash pipe operation.\n",
-    "\n",
-    "import sys\n",
-    "\n",
-    "try:\n",
-    "    import matplotlib.pyplot as plt\n",
-    "    import qutip\n",
-    "\n",
-    "except ImportError:\n",
-    "    print(\"Tools not found, installing. Please restart your kernel after this is done.\")\n",
-    "    !{sys.executable} -m pip install qutip\\>=5 matplotlib\\>=3.5\n",
-    "    print(\"\\nNew libraries have been installed. Please restart your kernel!\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import cudaq\n",
-    "import numpy as np\n",
-    "\n",
-    "## Retry the subsequent cells by setting the target to density matrix simulator.\n",
-    "# cudaq.set_target(\"density-matrix-cpu\")\n",
-    "\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def kernel(angles: np.ndarray):\n",
-    "    qubit = cudaq.qubit()\n",
-    "    rz(angles[0], qubit)\n",
-    "    rx(angles[1], qubit)\n",
-    "    rz(angles[2], qubit)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using `cudaq.add_to_bloch_sphere()` on the output state obtained from the random kernel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "rng = np.random.default_rng(seed=11)\n",
-    "blochSphereList = []\n",
-    "for _ in range(4):\n",
-    "    angleList = rng.random(3) * 2 * np.pi\n",
-    "    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))\n",
-    "    blochSphereList.append(sph)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can display the spheres with `cudaq.show()`. Show the first sphere:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cudaq.show(blochSphereList[0])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can also show multiple Bloch spheres side by side - simply set the `nrows` and `ncols` in the call to `cudaq.show()` accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cudaq.show(blochSphereList[:2], nrows=1, ncols=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can show them in a column too, if we want! Simply set the `nrows = 2` and `ncols = 1`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cudaq.show(blochSphereList[:2], nrows=2, ncols=1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Can we show the entire list of 4 Bloch spheres we created? Absolutely!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cudaq.show(blochSphereList[:], nrows=2, ncols=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the [QuTiP](https://www.qutip.org) toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to `cudaq.add_to_bloch_sphere()`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import qutip\n",
-    "\n",
-    "rng = np.random.default_rng(seed=47)\n",
-    "blochSphere = qutip.Bloch()\n",
-    "for _ in range(10):\n",
-    "    angleList = rng.random(3) * 2 * np.pi\n",
-    "    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This created a single Bloch sphere with 10 random vectors. Let us see how it looks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "blochSphere.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Kernel Visualization\n",
-    "\n",
-    "A CUDA-Q kernel can be visualized using the `cudaq.draw` API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@cudaq.kernel\n",
-    "def kernel_to_draw():\n",
-    "    q = cudaq.qvector(4)\n",
-    "    h(q)\n",
-    "    x.ctrl(q[0], q[1])\n",
-    "    y.ctrl([q[0], q[1]], q[2])\n",
-    "    z(q[2])\n",
-    "    \n",
-    "    swap(q[0], q[1])\n",
-    "    swap(q[0], q[3])\n",
-    "    swap(q[1], q[2])\n",
-    "\n",
-    "    r1(3.14159, q[0])\n",
-    "    tdg(q[1])\n",
-    "    s(q[2])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(cudaq.draw(kernel_to_draw))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(cudaq.draw('latex', kernel_to_draw))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Copy this output string into any LaTeX editor and export it to PDF.\n",
-    "\n",
-    "<img src=\"images/circuit_pdf.png\" alt=\"Circuit in PDF format\" width=\"500\" height=\"250\">"
-   ]
-  }
- ],
- "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.12"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/docs/sphinx/examples/python/tutorials/vqe.ipynb b/docs/sphinx/examples/python/tutorials/vqe.ipynb
index f6c8592354..207e195938 100644
--- a/docs/sphinx/examples/python/tutorials/vqe.ipynb
+++ b/docs/sphinx/examples/python/tutorials/vqe.ipynb
@@ -21,7 +21,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install openfermionpyscf==0.5 matplotlib==3.8.4 scipy==1.13.0"
+    "!pip install openfermionpyscf==0.5 matplotlib==3.8.4 scipy==1.13.0 -q"
    ]
   },
   {
diff --git a/docs/sphinx/examples/python/tutorials/vqe_advanced.ipynb b/docs/sphinx/examples/python/tutorials/vqe_advanced.ipynb
new file mode 100644
index 0000000000..fe06cb1185
--- /dev/null
+++ b/docs/sphinx/examples/python/tutorials/vqe_advanced.ipynb
@@ -0,0 +1,650 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# The Variational Quantum Eigensolver Featuring: Gradients, Active Spaces, and Gate Fusion\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This tutorial will explore the Variational Quantum Eigensolver, a hybrid quantum classical algorithm for determining the ground state energy of molecules. The first part of this tutorial will walk through the key aspects of the VQE algorithm and how to implement it with CUDA-Q.  The following sections explore advanced topics: parallel gradients, active spaces, and gate fusion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The Basics of VQE"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The VQE algorithm is hybrid quantum-classical algorithm, meaning some subroutines run on a quantum computer or quantum simulator and others run on a traditional (super)computer.  \n",
+    "\n",
+    "The goal is to take a parameterized quantum circuit and a qubit form of the molecular Hamiltonian, measure an expectation value that corresponds to the ground state energy of the molecule, and then repeat the process to variationally minimize the energy with respect to the parameters in the quantum circuit. The optimization is performed on a classical device while the expectation values are determined on a quantum device.  See the figure below.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![VQE.png](./images/VQE.png)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next few cells will elaborate on each part of the VQE procedure and show you how to build a VQE simulation to compute the ground state energy of the water molecule."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installing/Loading Relevant Packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install the relevant packages.\n",
+    "!pip install pyscf==2.6.2 openfermionpyscf==0.5 matplotlib==3.8.4 openfermion==1.6.1 -q"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openfermion\n",
+    "import openfermionpyscf\n",
+    "from openfermion.transforms import jordan_wigner, get_fermion_operator\n",
+    "\n",
+    "import os\n",
+    "import timeit\n",
+    "\n",
+    "import cudaq\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.optimize import minimize\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Implementing VQE in CUDA-Q"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Like most quantum chemistry programs, the first step is to specify a molecular geometry, basis set, charge, and multiplicity. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geometry = [('O', (0.1173, 0.0, 0.0)), ('H', (-0.4691, 0.7570, 0.0)),\n",
+    "            ('H', (-0.4691, -0.7570, 0.0))]\n",
+    "basis = 'sto3g'\n",
+    "multiplicity = 1\n",
+    "charge = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The VQE procedure requires some classical preprocessing.  The code below uses the PySCF package and OpenFermion to compute the Hartree Fock reference state and compute the integrals required for the Hamiltonian."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "molecule = openfermionpyscf.run_pyscf(\n",
+    "    openfermion.MolecularData(geometry, basis, multiplicity, charge))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, the Hamiltonian is built using `get_molecular_hamiltonian`. The Hamiltonian must then be converted to a qubit Hamiltonian consisting of qubit operators. The standard Jordan-Wigner transformation is used to perform this mapping. \n",
+    "\n",
+    "Finally, the Jordan-Wigner qubit Hamiltonian is converted into a CUDA-Q spin operator which can be used to evaluate an expectation value given a quantum circuit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "molecular_hamiltonian = molecule.get_molecular_hamiltonian()\n",
+    "\n",
+    "fermion_hamiltonian = get_fermion_operator(molecular_hamiltonian)\n",
+    "\n",
+    "qubit_hamiltonian = jordan_wigner(fermion_hamiltonian)\n",
+    "\n",
+    "spin_ham = cudaq.SpinOperator(qubit_hamiltonian)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, the quantum circuit needs to be defined, which models the wavefunction. This is done in CUDA-Q by specifying a CUDA-Q kernel. The kernel takes as an input the number of qubits, the number of electrons, and the parameters of the circuit ansatz (form of the wavefunction) yet to be defined. \n",
+    "\n",
+    "The number of qubits corresponds to the potential positions of electrons and is therefore twice the number of spatial orbitals constructed with the chosen basis set, as each can be occupied by two electrons. \n",
+    "\n",
+    "The Hartree-Fock reference is constructed by applying $X$ bitflip operations to each of the first $N$ qubits where $N$ is the number of electrons. Next, a parameterized ansatz is chosen. Theoretically, any set of operations can work as an ansatz, however, it is good practice to use an ansatz that captures the underlying physics of the problem. The most common choice for chemistry is the Unitary Coupled Cluster Ansatz with Single and Double excitations (UCCSD).  This UCCSD hate operations are automatically added to the kernel with the `cudaq.kernels.uccsd(qubits, thetas, electron_num, qubit_num)` function. \n",
+    "\n",
+    "The STO-3G water molecuule UCCSD ansatz requires optimization of 140 parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "electron_count = 10\n",
+    "qubit_count = 2 * 7\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(qubit_num: int, electron_num: int, thetas: list[float]):\n",
+    "    qubits = cudaq.qvector(qubit_num)\n",
+    "\n",
+    "    for i in range(electron_num):\n",
+    "        x(qubits[i])\n",
+    "\n",
+    "    cudaq.kernels.uccsd(qubits, thetas, electron_num, qubit_num)\n",
+    "\n",
+    "\n",
+    "parameter_count = cudaq.kernels.uccsd_num_parameters(electron_count,\n",
+    "                                                     qubit_count)\n",
+    "\n",
+    "print(parameter_count)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The classical optimizer requires a custom cost function which is defined below. The `cudaq.observe()` function computes an expectation given the Hamiltonian and the kernel defined above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cost(theta):\n",
+    "\n",
+    "    exp_val = cudaq.observe(kernel, spin_ham, qubit_count, electron_count,\n",
+    "                            theta).expectation()\n",
+    "\n",
+    "    return exp_val\n",
+    "\n",
+    "\n",
+    "exp_vals = []\n",
+    "\n",
+    "\n",
+    "def callback(xk):\n",
+    "    exp_vals.append(cost(xk))\n",
+    "\n",
+    "\n",
+    "# Initial variational parameters.\n",
+    "np.random.seed(42)\n",
+    "x0 = np.random.normal(0, 1, parameter_count)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The final step is to run the optimization using the scipy minimize function and a selected optimizer, in this case COBYLA. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cudaq.set_target('nvidia')\n",
+    "start_time = timeit.default_timer()\n",
+    "result = minimize(cost,\n",
+    "                  x0,\n",
+    "                  method='COBYLA',\n",
+    "                  callback=callback,\n",
+    "                  options={'maxiter': 50})\n",
+    "end_time = timeit.default_timer()\n",
+    "\n",
+    "print('UCCSD-VQE energy =  ', result.fun)\n",
+    "print('Total number of qubits = ', qubit_count)\n",
+    "print('Total number of parameters = ', parameter_count)\n",
+    "print('Total number of terms in the spin hamiltonian = ',\n",
+    "      spin_ham.get_term_count())\n",
+    "print('Total elapsed time (s) = ', end_time - start_time)\n",
+    "\n",
+    "plt.plot(exp_vals)\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Energy')\n",
+    "plt.title('VQE')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The result of this procedure is an estimate of the ground state energy of water. However, the convergence behavior is not perfect, more iterations would greatly improve the result, but would take a few minutes to run."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parallel Parameter Shift Gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One way to accelerate VQE is to use an optimizer that accepts a gradient. This can drastically lower the number of VQE iterations required at the cost of computing the gradient on the quantum side of the algorithm.\n",
+    "\n",
+    "The parameter shift rule is a common technique to compute the gradient for parameterized circuits. It is obtained by computing two expectation values for each parameter corresponding to a small forward and backward shift in the ith parameter. These results are used to estimate  finite difference contribution to the gradient.\n",
+    "\n",
+    "![parametershift.png](./images/parametershift.png)\n",
+    "\n",
+    "This procedure can become cost prohibitive as the number of parameters becomes large."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Each of the expectation values needed to evaluate a parameter shift gradient can be computed independently.  The CUDA-Q `nvidia-mqpu` backend is designed for parallel computations across multiple simulated QPUs. The function below uses `cudaq.observe_asynch` to distribute all of the expectation values evaluations across as many GPUs that are available. First, try it with `num_qpus` set to 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)\n",
+    "x0 = np.random.normal(0, 1, parameter_count)\n",
+    "\n",
+    "cudaq.set_target(\"nvidia-mqpu\")\n",
+    "\n",
+    "num_qpus = 4\n",
+    "\n",
+    "epsilon = np.pi / 4\n",
+    "\n",
+    "\n",
+    "def batched_gradient_function(kernel, parameters, hamiltonian, epsilon):\n",
+    "\n",
+    "    x = np.tile(parameters, (len(parameters), 1))\n",
+    "\n",
+    "    xplus = x + (np.eye(x.shape[0]) * epsilon)\n",
+    "\n",
+    "    xminus = x - (np.eye(x.shape[0]) * epsilon)\n",
+    "\n",
+    "    g_plus = []\n",
+    "    g_minus = []\n",
+    "    gradients = []\n",
+    "\n",
+    "    qpu_counter = 0  # Iterate over the number of GPU resources available\n",
+    "    for i in range(x.shape[0]):\n",
+    "\n",
+    "        g_plus.append(\n",
+    "            cudaq.observe_async(kernel,\n",
+    "                                hamiltonian,\n",
+    "                                qubit_count,\n",
+    "                                electron_count,\n",
+    "                                xplus[i],\n",
+    "                                qpu_id=qpu_counter))\n",
+    "        qpu_counter += 1\n",
+    "\n",
+    "        g_minus.append(\n",
+    "            cudaq.observe_async(kernel,\n",
+    "                                hamiltonian,\n",
+    "                                qubit_count,\n",
+    "                                electron_count,\n",
+    "                                xminus[i],\n",
+    "                                qpu_id=qpu_counter))\n",
+    "        qpu_counter += 1\n",
+    "\n",
+    "        if qpu_counter % num_qpus == 0:\n",
+    "            qpu_counter = 0\n",
+    "\n",
+    "    gradients = [\n",
+    "        (g_plus[i].get().expectation() - g_minus[i].get().expectation()) /\n",
+    "        (2 * epsilon) for i in range(len(g_minus))\n",
+    "    ]\n",
+    "\n",
+    "    assert len(gradients) == len(\n",
+    "        parameters) == x.shape[0] == xplus.shape[0] == xminus.shape[0]\n",
+    "\n",
+    "    return gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The cost function needs to be slightly updated to make use of the gradient in the optimization procedure and allow for a gradient based optimizer like L-BFGS-B to be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "gradient = batched_gradient_function(kernel, x0, spin_ham, epsilon)\n",
+    "\n",
+    "exp_vals = []\n",
+    "\n",
+    "\n",
+    "def objective_function(parameter_vector: list[float], \\\n",
+    "                       gradient=gradient, hamiltonian=spin_ham, kernel=kernel):\n",
+    "\n",
+    "    get_result = lambda parameter_vector: cudaq.observe\\\n",
+    "        (kernel, hamiltonian, qubit_count, electron_count, parameter_vector).expectation()\n",
+    "\n",
+    "    cost = get_result(parameter_vector)\n",
+    "    exp_vals.append(cost)\n",
+    "    gradient_vector = batched_gradient_function(kernel, parameter_vector,\n",
+    "                                                spin_ham, epsilon)\n",
+    "\n",
+    "    return cost, gradient_vector"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run the code below. Notice how the result is converged to a lower energy using only 10% of the steps as optimization above without a gradient. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.random.seed(42)\n",
+    "init_params = np.random.normal(0, 1, parameter_count)\n",
+    "\n",
+    "start_time = timeit.default_timer()\n",
+    "result_vqe = minimize(objective_function,\n",
+    "                      init_params,\n",
+    "                      method='L-BFGS-B',\n",
+    "                      jac=True,\n",
+    "                      tol=1e-8,\n",
+    "                      options={'maxiter': 5})\n",
+    "end_time = timeit.default_timer()\n",
+    "\n",
+    "print('VQE-UCCSD energy= ', result_vqe.fun)\n",
+    "print('Total elapsed time (s) = ', end_time - start_time)\n",
+    "\n",
+    "plt.plot(exp_vals)\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Energy')\n",
+    "plt.title('VQE')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, run the code again (the three previous cells) and specify `num_qpus` to be more than one if you have access to multiple GPUs and notice resulting speedup.  Thanks to CUDA-Q, this code could be used without modification in a setting where multiple physical QPUs were availible."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using an Active Space"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Performing electronic structure computations with all electrons and orbitals is often prohibitively expensive and unnecessary.  Most of the interesting chemistry can be modeled by restricting simulations to the highest energy occupied molecular orbitals and lowest energy unoccupied molecular orbitals. This is known as the active space approximation. \n",
+    "\n",
+    "Below is an example of STO-3G water modeled with a 4 electron 3 orbital active space simulated with UCCSD-VQE. Using an active space means you can run VQE for the same molecule using fewer qubits and a more shallow circuit.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![cas.png](./images/cas.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The molecule is defined the same way, expect for you now include variables `nele_cas` and `norb_cas` to define the active space. The `ncore` "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "geometry = [('O', (0.1173, 0.0, 0.0)), ('H', (-0.4691, 0.7570, 0.0)),\n",
+    "            ('H', (-0.4691, -0.7570, 0.0))]\n",
+    "basis = 'sto3g'\n",
+    "multiplicity = 1\n",
+    "charge = 0\n",
+    "ncore = 3\n",
+    "nele_cas, norb_cas = (4, 3)\n",
+    "\n",
+    "molecule = openfermionpyscf.run_pyscf(\n",
+    "    openfermion.MolecularData(geometry, basis, multiplicity, charge))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The Hamiltonian is now constrcuted with the same steps, but only models the active space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n",
+    "    occupied_indices=range(ncore),\n",
+    "    active_indices=range(ncore, ncore + norb_cas))\n",
+    "\n",
+    "fermion_hamiltonian = get_fermion_operator(molecular_hamiltonian)\n",
+    "\n",
+    "qubit_hamiltonian = jordan_wigner(fermion_hamiltonian)\n",
+    "\n",
+    "spin_ham = cudaq.SpinOperator(qubit_hamiltonian)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Similarly, the kernel is defined only by the orbitals and electrons in the active space. Notice how this means you only need to optimize 8 parameters now. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "electron_count = nele_cas\n",
+    "qubit_count = 2 * norb_cas\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(qubit_num: int, electron_num: int, thetas: list[float]):\n",
+    "    qubits = cudaq.qvector(qubit_num)\n",
+    "\n",
+    "    for i in range(electron_num):\n",
+    "        x(qubits[i])\n",
+    "\n",
+    "    cudaq.kernels.uccsd(qubits, thetas, electron_num, qubit_num)\n",
+    "\n",
+    "\n",
+    "parameter_count = cudaq.kernels.uccsd_num_parameters(electron_count,\n",
+    "                                                     qubit_count)\n",
+    "\n",
+    "print(parameter_count)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cost(theta):\n",
+    "\n",
+    "    exp_val = cudaq.observe(kernel, spin_ham, qubit_count, electron_count,\n",
+    "                            theta).expectation()\n",
+    "    thetas = theta\n",
+    "    return exp_val\n",
+    "\n",
+    "\n",
+    "exp_vals = []\n",
+    "\n",
+    "\n",
+    "def callback(xk):\n",
+    "    exp_vals.append(cost(xk))\n",
+    "\n",
+    "\n",
+    "# Initial variational parameters.\n",
+    "np.random.seed(42)\n",
+    "x0 = np.random.normal(0, 1, parameter_count)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The VQE procedure below is much faster using an active space compared to inclusion of all orbitals and electrons."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cudaq.set_target(\"nvidia\")\n",
+    "\n",
+    "start_time = timeit.default_timer()\n",
+    "result = minimize(cost,\n",
+    "                  x0,\n",
+    "                  method='COBYLA',\n",
+    "                  callback=callback,\n",
+    "                  options={'maxiter': 500})\n",
+    "end_time = timeit.default_timer()\n",
+    "\n",
+    "print('UCCSD-VQE energy =  ', result.fun)\n",
+    "print('Total number of qubits = ', qubit_count)\n",
+    "print('Total number of parameters = ', parameter_count)\n",
+    "print('Total number of terms in the spin hamiltonian = ',\n",
+    "      spin_ham.get_term_count())\n",
+    "print('Total elapsed time (s) = ', end_time - start_time)\n",
+    "\n",
+    "plt.plot(exp_vals)\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Energy')\n",
+    "plt.title('VQE')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Gate Fusion for Larger Circuits"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "CUDA-Q simulations take advantage of a technique called gate fusion. Gate fusion is an optimization technique where consecutive gates are combined into a single gate operation to improve the efficiency of the simulation (See figure below).  By targeting the `nvidia-mgpu` backend and setting the `CUDAQ_MGPU_FUSE` environment variable, you can select the degree of fusion that takes place. \n",
+    "\n",
+    "![gate-fuse.png](./images/gate-fuse.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This is particularly important for larger circuits and can have a significant impact on the performance of the simulation. Each system is different, so you should test different gate fusion levels to find out what is best for your system. You can find more information [here](https://developer.nvidia.com/blog/new-nvidia-cuda-q-features-boost-quantum-application-performance/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/sphinx/examples/python/tutorials/vqe_water_active_space.ipynb b/docs/sphinx/examples/python/tutorials/vqe_water_active_space.ipynb
deleted file mode 100644
index 7b5d0306ee..0000000000
--- a/docs/sphinx/examples/python/tutorials/vqe_water_active_space.ipynb
+++ /dev/null
@@ -1,235 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Water Molecule with Active Space (CPU vs. GPU)\n",
-    "\n",
-    "#### A- Classical simulation as a reference: CCSD"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install the relevant packages.\n",
-    "!pip install pyscf==2.6.2\n",
-    "!pip install openfermionpyscf==0.5\n",
-    "!pip install matplotlib==3.8.4\n",
-    "!pip install openfermion==1.6.1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "converged SCF energy = -75.9839755372789\n",
-      "Total number of electrons =  10\n",
-      "Total number of orbitals =  13\n",
-      "ncore occupied orbitals =  3\n",
-      "E(CCSD) = -75.98508980454675  E_corr = -0.001114267267875617\n",
-      "Total CCSD energy for active space Hamiltonian =  -75.98508980454675 \n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "from pyscf import gto, scf, mcscf, cc\n",
-    "\n",
-    "geometry ='O 0.1173 0.0 0.0; H -0.4691 0.7570 0.0; H -0.4691 -0.7570 0.0'\n",
-    "mol=gto.M(\n",
-    "    atom = geometry,\n",
-    "    spin = 0,\n",
-    "    charge = 0,\n",
-    "    basis = '631g',\n",
-    ")\n",
-    "\n",
-    "myhf = scf.RHF(mol)\n",
-    "myhf.max_cycle=100\n",
-    "myhf.kernel()\n",
-    "nelec = mol.nelectron\n",
-    "print('Total number of electrons = ', nelec)\n",
-    "norb = myhf.mo_coeff.shape[1]\n",
-    "print('Total number of orbitals = ', norb)\n",
-    "\n",
-    "norb_cas, nele_cas = (4,4)\n",
-    "mycasci = mcscf.CASCI(myhf, norb_cas, nele_cas)\n",
-    "print('ncore occupied orbitals = ', mycasci.ncore)\n",
-    "\n",
-    "frozen = []\n",
-    "frozen += [y for y in range(0,mycasci.ncore)]\n",
-    "frozen += [y for y in range(mycasci.ncore+norb_cas, len(mycasci.mo_coeff))]\n",
-    "mycc = cc.CCSD(myhf,frozen=frozen).run()\n",
-    "print('Total CCSD energy for active space Hamiltonian = ', mycc.e_tot, '\\n')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### B- VQE-UCCSD:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[\u001b[38;2;255;000;000mwarning\u001b[0m] Target \u001b[38;2;000;000;255mnvidia-fp64\u001b[0m: \u001b[38;2;000;000;255mThis target is deprecating. Please use the 'nvidia' target with option 'fp64'.\u001b[0m\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_23147/4290935201.py:35: ComplexWarning: Casting complex values to real discards the imaginary part\n",
-      "  spin_ham = cudaq.SpinOperator(qubit_hamiltonian)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "UCCSD-VQE energy =   -75.98415928173183\n",
-      "Pyscf-CCSD energy =  -75.98508980454675\n",
-      "Total number of qubits =  8\n",
-      "Total number of parameters =  26\n",
-      "Total number of terms in the spin hamiltonian =  105\n",
-      "Total elapsed time (s) =  28.929891359000067\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABcd0lEQVR4nO3dd3xUZd4+/utMzaT3RmihhS4CZmkWQIqsAZVnLSBFXB8V0UdYd0FFVH4Kj4jr7n53LY8xYEERBQELSLXQQZCaICWEQBIgZVKnn98fkzmZk0wmIUwymcn1fr3mZeacMyf3DIlcfO7PuY8giqIIIiIiInJJ4e0BEBEREbVmDEtEREREbjAsEREREbnBsERERETkBsMSERERkRsMS0RERERuMCwRERERucGwREREROQGwxIRERGRGwxLRERERG4wLBGR30pLS0NgYCDKysrqPWbKlCnQaDQoLCwEAFRUVGDx4sXo168fAgMDERYWhhEjRuDjjz+Gq7tDCYJQ7+Pxxx9vtvdGRC1H5e0BEBE1lylTpmDjxo1Yt24dpk2bVmd/ZWUl1q9fj3HjxiEqKgoFBQUYNWoUTp06hQceeABPPfUUDAYDvvrqK0ybNg2bNm3Cxx9/DIVC/u/MO++80+X5u3fv3mzvjYhaDsMSEfmttLQ0hISEYNWqVS7DzPr161FRUYEpU6YAAKZPn45Tp05h3bp1SEtLk457+umn8dxzz+HNN9/ETTfdhOeee052nu7du2Pq1KnN+2aIyGs4DUdEfkun0+Hee+/Ftm3bcOXKlTr7V61ahZCQEKSlpWHv3r3YvHkzZsyYIQtKDkuWLEG3bt2wdOlSVFVVtcTwiaiVYFgiIr82ZcoUWCwWfPHFF7LtRUVF2Lx5M+655x7odDps3LgRAFxWoABApVLhoYceQlFREXbv3i3bZzAYcO3atToPk8nUPG+KiFoUwxIR+bWRI0ciISEBq1atkm1fs2YNzGazNAV38uRJAED//v3rPZdjn+NYh/T0dMTExNR5rF271pNvhYi8hD1LROTXlEolHnjgAfz9739HdnY2OnXqBMA+BRcXF4dRo0YBgHTFXEhISL3ncuyrfXXdxIkT8dRTT9U5vm/fvp54C0TkZQxLROT3pkyZgr///e9YtWoVnn/+eeTm5uLnn3/G008/DaVSCUAehMLDw12exxGSYmNjZduTkpIwevTo5nsDRORVnIYjIr83cOBApKSk4LPPPgMAfPbZZxBFUZqCA4BevXoBAI4ePVrveRz7kpOTm3G0RNTaMCwRUZswZcoUHD9+HEePHsWqVavQrVs3DB48WNp/9913AwA++ugjl6+3Wq3S1N2tt97aImMmotaBYYmI2gRHFemll17CkSNHZFUlAPjDH/6AMWPGICMjA998802d17/wwgs4ffo0/vrXv0KlYgcDUVsiiK7W7yci8kPDhg2TLvv//fff0bVrV9n+goICjBw5EpmZmXjooYcwYsQIGI1GrF27Fjt37sTUqVPx0UcfQRAE6TWCINS7gndcXBzuvPPO5n1TRNTsGJaIqM34z3/+g9mzZ+OWW27Bvn37XB5TXl6Ot956C1988QXOnj0Lg8EAAFi4cCFeffXVOsc7B6fabrvtNuzcudMjYyci72FYIiJy49KlSxg6dCgsFgv27NmDDh06eHtIRNTC2LNERORGu3btsGnTJhgMBowfPx7FxcXeHhIRtTBWloiIiIjcYGWJiIiIyA2GJSIiIiI3GJaIiIiI3GBYIiIiInKDy9B6gM1mw+XLlxESEuJ2zRUiIiJqPURRRFlZGRITE6FQ1F8/YljygMuXL6N9+/beHgYRERE1wcWLF5GUlFTvfoYlDwgJCQFg/7BDQ0O9PBoiIiJqjNLSUrRv3176e7w+DEse4Jh6Cw0NZVgiIiLyMQ210LDBm4iIiMgNhiUiIiIiNxiWiIiIiNxgWCIiIiJyg2GJiIiIyA2GJSIiIiI3GJaIiIiI3GBYIiIiInKDYYmIiIjIDYYlIiIiIjcYloiIiIjcYFgiIiIicoNhyQdUmawQRdHbwyAiImqTGJZauROX9ej50iYs+T7T20MhIiJqkxiWWrml1SHp/Z/OeXkkREREbRPDUitXbrR4ewhERERtGsNSK1duYFgiIiLyJoalVo6VJSIiIu9iWGrlWFkiIiLyLoalVq6MlSUiIiKvYlgiIiIicoNhqRWz2bgQJRERkbcxLLVipQaz7DlX8SYiImp5DEut2LVyk+y52cqwRERE1NIYllqxogp5WDJZbV4aCRERUdvFsNSKFZYbZc+NZquXRkJERNR2MSy1YoWsLBEREXkdw1IrVlirZ8loZlgiIiJqaQxLrVhhhXwajpUlIiKilsew1IrVnoZjZYmIiKjlMSy1YrUbvE1WNngTERG1NIalVqz20gGsLBEREbU8lbcHQPXrlRCKALUSvxeUo8pshZE9S0RERC2OlaVW7O0HBmDDU8PRKzEUACtLRERE3sCw5AM0SvsfE6+GIyIiankMSz5Aq7b/MXEFbyIiopbHsOQDWFkiIiLyHoYlH6BVKwGwZ4mIiMgbGJZ8ACtLRERE3sOw5ANqepYYloiIiFoaw5IPqKksscGbiIiopTEs+QBWloiIiLyHYckHaNmzRERE5DUMSz6AV8MRERF5D8OSD+DVcERERN7DsOQDpJ4lCxu8iYiIWppPhKWdO3dCEASXjwMHDgAAsrOzXe7fu3ev23Pn5ORgwoQJCAwMRGxsLJ577jlYLJaWeFuNplVVV5YsrCwRERG1NJW3B9AYQ4cORV5enmzbwoULsW3bNgwaNEi2fevWrejdu7f0PCoqqt7zWq1WTJgwAfHx8di9ezfy8vIwbdo0qNVqvP766559EzdAo3JUlhiWiIiIWppPhCWNRoP4+Hjpudlsxvr16zFnzhwIgiA7NioqSnasOz/88ANOnjyJrVu3Ii4uDjfddBMWL16Mv/3tb3j55Zeh0Wg8+j6aSqtigzcREZG3+MQ0XG0bNmxAYWEhZs6cWWdfWloaYmNjMXz4cGzYsMHtefbs2YO+ffsiLi5O2jZ27FiUlpbixIkTHh93UzkavI1s8CYiImpxPlFZqi09PR1jx45FUlKStC04OBjLly/HsGHDoFAo8NVXX2HSpEn4+uuvkZaW5vI8+fn5sqAEQHqen59f7/c3Go0wGo3S89LS0ht5Ow2qWZSSDd5EREQtzauVpfnz59fbuO14ZGZmyl6Tm5uLzZs3Y9asWbLt0dHRmDt3LlJTUzF48GAsXboUU6dOxbJlyzw+7iVLliAsLEx6tG/f3uPfwxmXDiAiIvIer1aW5s2bhxkzZrg9Jjk5WfY8IyMDUVFR9VaLnKWmpmLLli317o+Pj8f+/ftl2woKCqR99VmwYAHmzp0rPS8tLW3WwMRFKYmIiLzHq2EpJiYGMTExjT5eFEVkZGRIV6w15MiRI0hISKh3/5AhQ/Daa6/hypUriI2NBQBs2bIFoaGh6NWrV72v02q10Gq1jR73jWJliYiIyHt8qmdp+/btOH/+PB599NE6+1auXAmNRoMBAwYAANauXYsPP/wQH3zwgXTMunXrsGDBAmlqb8yYMejVqxcefvhhvPHGG8jPz8eLL76I2bNnt2gYagh7loiIiLzHp8JSeno6hg4dipSUFJf7Fy9ejAsXLkClUiElJQWrV6/G5MmTpf16vR5ZWVnSc6VSiW+++QZPPPEEhgwZgqCgIEyfPh2vvvpqs7+X68HKEhERkfcIoiiK3h6ErystLUVYWBj0ej1CQ0M9fv4rZQbc8to2CAJw7vW76qwtRURERNevsX9/++Q6S22NVmlv8BZFwGJjtiUiImpJDEs+wNGzBPCWJ0RERC2NYckHOHqWAN5Ml4iIqKUxLPkAhUKAWmnvUzJaeEUcERFRS2JY8hHSFXGsLBEREbUohiUfIa3izbBERETUohiWfAQrS0RERN7BsOQjpFW82bNERETUohiWfISjssSb6RIREbUshiUfEVDds2RgZYmIiKhFMSz5iAA1K0tERETewLDkI1hZIiIi8g6GJR+hVVWHJVaWiIiIWhTDko9wTMMZzKwsERERtSSGJR8hTcOxskRERNSiGJZ8hFbFyhIREZE3MCz5CDZ4ExEReQfDko/g0gFERETewbDkIwJUjhvpsrJERETUkhiWfIRzg/fxS3qs2pcDURS9PCoiIiL/p/L2AKhxnJcOeH7dMRzN1aNXYihuah/u3YERERH5OVaWfIRWqixZcbXMCAC4Umrw5pCIiIjaBIYlH+E8DVdhtAAAyqv/S0RERM2HYclHSOssWayoNNmbvBmWiIiImh/Dko9wVJZKq8yw2OyN3WUGhiUiIqLmxrDkIwKqK0tFFSZpGytLREREzY9hyUc4KkslVWZpW5nBXN/hRERE5CEMSz7CEZacl1Yq5zQcERFRs2NY8hGOdZaccRqOiIio+TEs+QhHZcnZ9TR4W20i0n85j5OXSz05LCIiIr/HsOQjHPeGc3Y9laVdZ65h8Tcnsfibk54cFhERkd9jWPIRWhfTcNdTWcqvXu27uNLUwJFERETkjGHJRzgWpXR2PZWl0uqr6Axmq8fGRERE1BYwLPkIQRDqBKbruRqupNIelqoYloiIiK4Lw5IPqd3kbbLaYLQ0LvzopcqSzePjIiIi8mcMSz7E5fIBjawuORazZGWJiIjo+jAs+ZAbWT7AUVkyWWyw2sQGjiYiIiIHhiUfciPLB+idroJjkzcREVHjMSz5EFfTcNdbWQI4FUdERHQ9GJZ8iNbFNFxjK0vON+CtMjEsERERNRbDkg9xvdaS2cWRcjabKK2zBKDRV9ARERERw5JPcW7wjg7WAGjcNFyZ0QLnnu4qE5cPICIiaiyGJR/iHJbiQgMANC4sOVeVAPYsERERXQ+GJR8S4DQNF18dlhrTs+RYvduBYYmIiKjxGJZ8iKyyFFYdlhpRWSqpkt88lw3eREREjcew5EOclw6IC2l8ZUlfaxqO6ywRERE1HsOSD3FUlgQBiAnRAgDKDGaIooiD2UUoqTS5fF3taTiGJSIiosZjWPIhjrAUpFEhVKcCAJQaLDiQXYzJ7+7B/K+OuXxd7cpShcmKT/ddwOmCsuYdMBERkR9QeXsA1HiOdZYCNUqE6dQAAH2lGeeulgNAveGndljanlmAXWcKkdo5Eqv/e0gzjpiIiMj3sbLkQxwreAdrVYgItK+zVFxpQnH1NFtBqcHl6/S1puHOX60AAFwqqWquoRIREfkNnwhLO3fuhCAILh8HDhwAAGRnZ7vcv3fv3nrP+9tvv+HBBx9E+/btodPp0LNnT/zjH/9oqbd13RxLBwRqlYgIsoelkkqz1KtUYbK6bPh2XA0XpLGHrYIyIwCgqMJ1jxMRERHV8IlpuKFDhyIvL0+2beHChdi2bRsGDRok275161b07t1beh4VFVXveQ8dOoTY2Fh88sknaN++PXbv3o3HHnsMSqUSTz31lGffhAc4pt4iAjWICLR/bbLaZBWiglIDgmOCZa9zTMPFhwXg7NUKWKuX8640WVFlskKnqXvPOSIiIrLzibCk0WgQHx8vPTebzVi/fj3mzJkDQRBkx0ZFRcmOdeeRRx6RPU9OTsaePXuwdu3aVhmWbu0eg2dHd8fIlFjo1EpoVAqYLDacv1YhHVOgN6CLU1iqNFmQlW/vZWofGYizVytk5yysMCJJE9gyb4CIiMgH+cQ0XG0bNmxAYWEhZs6cWWdfWloaYmNjMXz4cGzYsOG6z63X6xEZGen2GKPRiNLSUtmjJQSolXhmdDf0TQqDIAhSdUkWlsrkfUuf7s1BcaUZHaMCMaJbTJ1zciqOiIjIPZ8MS+np6Rg7diySkpKkbcHBwVi+fDnWrFmDb7/9FsOHD8ekSZOuKzDt3r0bq1evxmOPPeb2uCVLliAsLEx6tG/fvsnv5UY4mrwrnVbkLig1Sl9Xmax476dzAIDZt3dFsLbudFthOcMSERGRO14NS/Pnz6+3cdvxyMzMlL0mNzcXmzdvxqxZs2Tbo6OjMXfuXKSmpmLw4MFYunQppk6dimXLljVqLMePH8fEiROxaNEijBkzxu2xCxYsgF6vlx4XL168vjfuIeHVlSVnzlfE/fz7VVwrNyIxLAD33NxOdrsUh0JWloiIiNzyas/SvHnzMGPGDLfHJCcny55nZGQgKioKaWlpDZ4/NTUVW7ZsafC4kydPYtSoUXjsscfw4osvNni8VquFVqtt8Ljm5qgsOXMOS47puUGdIqFWKqBzFZbKjXW2ERERUQ2vhqWYmBjExNTto6mPKIrIyMjAtGnToFbXrarUduTIESQkJLg95sSJExg5ciSmT5+O1157rdFjaQ3CXYalmvCTU1QJAOgQaW/gdnXVG3uWiIiI3POJq+Ectm/fjvPnz+PRRx+ts2/lypXQaDQYMGAAAGDt2rX48MMP8cEHH0jHrFu3DgsWLJCm9o4fP46RI0di7NixmDt3LvLz8wEASqXyukKct0Q0MA0nhaWo6rDEaTgiIqLr5lNhKT09HUOHDkVKSorL/YsXL8aFCxegUqmQkpKC1atXY/LkydJ+vV6PrKws6fmXX36Jq1ev4pNPPsEnn3wibe/YsSOys7Ob7X14ivM0nFopwGwVcaXUCFEUIQhCncqSy54lTsMRERG5JYiiKHp7EL6utLQUYWFh0Ov1CA0NbbHvu+bgRTz35VEAQI+4EGRV3xvu14V3IjRAhZSFm2Cxidg9fyQSw3U4c6Uco9/6UXaO/klhWP/U8BYbMxERUWvR2L+/fXLpALJzrizFhmoRVX0LlIJSA/L0BlhsIjRKBeJCAwC47lm6xqUDiIiI3GJY8mGO+8MB9mbvpAgdAOBUXikuVk/BJUXqoFTYVzl37lly3DqFDd5ERETuMSz5MOcG74hANW7tbm9K/+FEAS7U6lcC5GGpS0wQAKDKbMVPp69K4YqIiIjkGJZ8mPM0XHigBmN72++Jt/P0Fel+cM5hSauq+eNuFxEITfXzaR/ux63LduDxjw+hwmhpiaETERH5DIYlHxaqU8NxH+HIQDV6J4aiXbgOBrMNXxy0ryruHJYUCkEKTBGBapgsNmmfKAKbTuRjR9aVlnsDREREPoBhyYcpFYLUexQRpIEgCBjTOw5Azf3inMMSUNPkHa5TY1DHCADA6J6xuH+Q/f52jooUERER2TEs+bjI6iZvx5Tc5IFJUCsFBKgVuLNXHIZ1jZYd7+hbCgvU4P+7pw9ev6cv3pk6ECkJIQCATIYlIiIiGZ9alJLqmjOyK3ZkXsUtnSMBAL0Tw3D4pTHQKBVST5IzR1gK16mREh+KlHj7uhI94u1hiZUlIiIiOYYlH3fPgCTcMyBJti1YW/8fa0iAfV90iPxGwI7QlFNUiQqjBUFuzkFERNSWcBqujfnL2B54dHhnDO0SJdseGaRBTHWA+v1KuTeGRkRE1CoxLLUxI7rF4MU/9oJaWfePvkecYyqutKWHRURE1GoxLJHE0bfEJm8iIqIaDEskYZM3ERFRXQxLJOlYvSZTvt7g5ZEQERG1HgxLJIkKtjd4Xys3enkkRERErQfDEkmig+0LW5YaLLJboRAREbVlDEskCQ1QQ6mw32yuuNLk5dEQERG1DgxLJFEoBOn2KZyKIyIismNYIpmo6rBUWM7KEhEREcCwRLVEVzd5F1awskRERAQwLFEtUcGsLBERETljWCIZR89SYQXDEhEREcCwRLVI03Bs8CYiIgLAsES1sMGbiIhIjmGJZKRVvDkNR0REBIBhiWqpafDmNBwRERHAsES1OKbhilhZIiIiAsCwRLU4puEqTVZUmixeHg0REZH3MSyRTJBGCa3K/mPBJm8iIiKGJapFEASnVbwZloiIiBiWqI5IqW+JTd5EREQMS1RHoEYJAKgwWr08EiIiIu9jWKI6HGGpysSwRERExLBEdQRqVACAKjPDEhEREcMS1aGrrixVsrJERETEsER11UzDcZ0lIiIihiWqg5UlIiKiGgxLVIdOXR2W2LNERETEsER1OabhDKwsERERMSxRXbrqq+E4DUdERMSwRC4EchqOiIhIwrBEdfBqOCIiohpNCksVFRWeHge1IgENXA13/loFV/cmIqI2o0lhKS4uDo888gh++eUXT4+HWgHHNJyrQHT2ajnueHMn5nz2a0sPi4iIyCuaFJY++eQTFBUVYeTIkejevTuWLl2Ky5cve3ps5CXubneSU1hp/29RZYuOiYiIyFuaFJYmTZqEr7/+GpcuXcLjjz+OVatWoWPHjvjjH/+ItWvXwmJhr4svc7copclqAwBYrGKLjomIiMhbbqjBOyYmBnPnzsXRo0fx1ltvYevWrZg8eTISExPx0ksvobKS1QdfVNPg7SIsWexhyWyzteiYiIiIvEV1Iy8uKCjAypUrsWLFCly4cAGTJ0/GrFmzkJubi//93//F3r178cMPP3hqrNRCHGHJZLXBYrVBpazJ1I6wxMoSERG1FU0KS2vXrkVGRgY2b96MXr164cknn8TUqVMRHh4uHTN06FD07NnTU+OkFhRQ3eAN2NdaCnUKS2bHNJyNYYmIiNqGJoWlmTNn4oEHHsCuXbswePBgl8ckJibihRdeuKHBkXdoVQooBMAm2m95EhqglvbV9CxxGo6IiNqGJvUs5eXl4b333qs3KAGATqfDokWLmjwwZzt37oQgCC4fBw4cAABkZ2e73L93795GfY/CwkIkJSVBEASUlJR4ZNy+ShAE6Yq4SpNVqiYBnIYjIqK2p0mVJYvFgtLS0jrbBUGAVquFRqO54YE5Gzp0KPLy8mTbFi5ciG3btmHQoEGy7Vu3bkXv3r2l51FRUY36HrNmzUK/fv1w6dKlGx+wH9BplCg3WjB/7VEcv1SK754egQ5RgVJliQ3eRETUVjSpshQeHo6IiIg6j/DwcOh0OnTs2BGLFi2CzUN/oWo0GsTHx0uPqKgorF+/HjNnzoQgCLJjo6KiZMeq1ep6zlrjnXfeQUlJCf7yl794ZLz+wNHkvfdcEcqNFqzckw0AMFvsFSUre5aIiKiNaFJlacWKFXjhhRcwY8YM3HLLLQCA/fv3Y+XKlXjxxRdx9epVvPnmm9BqtXj++ec9OmAA2LBhAwoLCzFz5sw6+9LS0mAwGNC9e3f89a9/RVpamttznTx5Eq+++ir27duHc+fONer7G41GGI1G6bmrKpuv0zk1eQNARKA9dJqs9uUEzFYRoijWCatERET+pklhaeXKlVi+fDn+9Kc/Sdvuvvtu9O3bF++99x62bduGDh064LXXXmuWsJSeno6xY8ciKSlJ2hYcHIzly5dj2LBhUCgU+Oqrr6TFM+sLTEajEQ8++CCWLVuGDh06NDosLVmyBK+88opH3ktr5ViY0iEySAugpmcJsFeXVEqGJSIi8m9NmobbvXs3BgwYUGf7gAEDsGfPHgDA8OHDkZOT4/Y88+fPr7dx2/HIzMyUvSY3NxebN2/GrFmzZNujo6Mxd+5cpKamYvDgwVi6dCmmTp2KZcuW1fv9FyxYgJ49e2Lq1KmNfevS6/R6vfS4ePHidb3eFwTWCksalf1HxezU2M3lA4iIqC1oUmWpffv2SE9Px9KlS2Xb09PT0b59ewD2q8siIiLcnmfevHmYMWOG22OSk5NlzzMyMhAVFdXg9BoApKamYsuWLfXu3759O44dO4Yvv/wSACCK9r/8o6Oj8cILL9RbPdJqtdBqtQ1+f1+mU8t/NBxLBRidKksMS0RE1BY0KSy9+eab+K//+i98//330vIBBw8eRGZmphQ8Dhw4gPvvv9/teWJiYhATE9Po7yuKIjIyMjBt2rRGNW4fOXIECQkJ9e7/6quvUFVVJT0/cOAAHnnkEfz888/o0qVLo8flj2pXlszVwch5GQGutURERG1Bk8JSWloasrKy8N577yErKwsAMH78eHz99dfo1KkTAOCJJ57w2CAdtm/fjvPnz+PRRx+ts2/lypXQaDTS9ODatWvx4Ycf4oMPPpCOWbduHRYsWCBN7dUORNeuXQMA9OzZU7YaeVtUOyw5gpFzz5KZay0REVEbcN1hyWw2Y9y4cXj33XexZMmS5hhTvdLT0zF06FCkpKS43L948WJcuHABKpUKKSkpWL16NSZPnizt1+v1Urgj9wLUtcOSPRiZZNNwrCwREZH/u+6wpFarcfTo0eYYS4NWrVpV777p06dj+vTpbl8/Y8YMtz1St99+u9S31NbVnYarXoxSNg3Hz4qIiPxfk66Gmzp1KtLT0z09FmpF6k7DVVeWrGzwJiKitqXJtzv58MMPsXXrVgwcOBBBQUGy/W+99ZZHBkfeo9O4vhpONg3HBm8iImoDmhSWjh8/jptvvhkAcPr0adk+rujsH+q7Gs65ssQGbyIiaguaFJZ27Njh6XFQK1P7didWF0sH8P5wRETUFjSpZ8nhzJkz2Lx5s7RWEZuj/Uft252YXS0dwKvhiIioDWhSWCosLMSoUaPQvXt33HXXXcjLywMAzJo1C/PmzfPoAMk7usYGw3lG1eXSAZyGIyKiNqBJYenZZ5+FWq1GTk4OAgMDpe33338/Nm3a5LHBkfd0iQnG3gWj8PSobgBq1lSS3RuODd5ERNQGNKln6YcffsDmzZuRlJQk296tWzdcuHDBIwMj74sLDZB6lxwhifeGIyKitqZJlaWKigpZRcmhqKjI728w29aolfa5OEcVSbYoJXuWiIioDWhSWBoxYgQ++ugj6bkgCLDZbHjjjTdwxx13eGxw5H0qhT0sSUsH8N5wRETUxjRpGu6NN97AqFGjcPDgQZhMJvz1r3/FiRMnUFRUhF27dnl6jORFKqU9T0uLUvJ2J0RE1MY0qbLUp08fnD59GsOHD8fEiRNRUVGBe++9F4cPH0aXLl08PUbyopppOBFWmyhbW4nTcERE1BY0qbIEAGFhYXjhhRc8ORZqhZQKe54220RZvxLAyhIREbUNTQ5LJSUl2L9/P65cuQJbrQrDtGnTbnhg1Do4KktWm002BQewskRERG1Dk8LSxo0bMWXKFJSXlyM0NFR2PzhBEBiW/IjKUVmyirLmbsc2IiIif9eknqV58+bhkUceQXl5OUpKSlBcXCw9ioqKPD1G8iKV09IBtafheG84IiJqC5oUli5duoSnn37a5VpL5F+kBm+bq8pS3Wm4Lw/l4k/v7kFhubFFxkdERNTcmhSWxo4di4MHD3p6LNQKuZuGc7WC9+oDOdifXYTdZwtbZHxERETNrUk9SxMmTMBzzz2HkydPom/fvlCr1bL9aWlpHhkceZ/zNFydBm8XlSWD2b6tymRt/sERERG1gCaFpT//+c8AgFdffbXOPkEQYLXyL0p/oXYsSuliGs5VZclosf/ZV5n5M0BERP6hSWGp9lIB5L+k251YbXWufnO1zpIjUFWyskRERH7iunqW7rrrLuj1eun50qVLUVJSIj0vLCxEr169PDY48j6psuRq6QAXodlYfQwrS0RE5C+uKyxt3rwZRmPNVU6vv/66bKkAi8WCrKwsz42OvE6pcFwNZ4Op1vSqu8pSlcnS/IMjIiJqAdcVlkRRdPuc/I986QD5n7erdZZYWSIiIn/TpKUDqO1wLB1gsYp1roZztc6S1OBtYl8bERH5h+sKS4IgyG5t4thG/suxdIDZaoO59tVwtabhbDZRagKvMnMajoiI/MN1XQ0niiJmzJgBrVYLADAYDHj88ccRFBQEALJ+JvIPsqUDaleWajV4O+/nOktEROQvrissTZ8+XfZ86tSpdY7hTXT9i2PpAKuLdZZq9ywZnfZz6QAiIvIX1xWWMjIymmsc1EqplDUztbUDUO1pOEe/EgAY2OBNRER+gg3e5JbjajgAqKy1HEDtBm/nyhOvhiMiIn/BsERuOa6GA4AKoz0AaZz6mJxxGo6IiPwRwxK55ehZAmqucNNplABchCVzTVjiNBwREfkLhiVyS6EQ4MhLjspSoCMs1Z6G49VwRETkhxiWqEGOJm/H1FpNWKpdWaoJSJVmK1d4JyIiv8CwRA1SV5eWHNNwgRr7RZTu1lkSRXkPExERka9iWKIGOSpLjmk4R89SnXWWzPJwxKk4IiLyBwxL1CDH8gFVtabhzHXWWaoVlm6gydtiteFiUWWTX09EROQpDEvUIMfyARXV6ywFVU/D1W3wloejGwlLL288gRFv7MD+80VNPgcREZEnMCxRg1S1KkstMQ135kq57L9ERETewrBEDXLcTNdRWZKm4dw0eAM3Vlmqqg5etVcNJyIiamkMS9Qgx8KUhuoAEyhNw7mvLN3IKt5V1SGJi1sSEZG3MSxRg5ROq3gDQFA9Dd51Kks3EpaqQxJvm0JERN7GsEQNckzDOYQHaQAA1lrTcMZaVaAbqQpVmRzTcAxLRETkXQxL1CBHg7dDuE4NwMU0nMVz03COoMW1moiIyNsYlqhBakWtylKgPSzVbvD21DpLoihKr72RJnEiIiJPYFiiBtWuLEUE2qfhGqosVTXxSjaT1SYtS8BpOCIi8jaGJWqQqlbPUphjGs4mym6Wa/JQZclgqjmP4350DdmReQUzMvbjWrmxSd+TiIioPgxL1CC109VwKoWAYK1Keu68MKXRIr8dSpWpaTfSdQ5ZjaksWW0iZq44gJ1ZV/HxngtN+p5ERET1YViiBjlPwwVpVbLnFllYsocjRwN4Y6tCtTmHpcY0eO/MuiJ9rVHxR5qIiDyLf7NQg5yn4YK1KtlSAmantZUc03ChjrDUxH4j51W7GzOVt2pfjvS1rdYtWIiIiG6UT4SlnTt3QhAEl48DBw4AALKzs13u37t3b4PnX7FiBfr164eAgADExsZi9uzZzf2WfIrzNFywViWt6A24noZzXC3X1OZsw3VMw2Xml2KHU2WpklfPERGRh6kaPsT7hg4diry8PNm2hQsXYtu2bRg0aJBs+9atW9G7d2/peVRUlNtzv/XWW1i+fDmWLVuG1NRUVFRUIDs722Nj9wdKp6UDggNUshW9nVfxdlSWHFfLNbXB27nXyV11qsJowexPf4VzMYnrMhERkaf5RFjSaDSIj4+XnpvNZqxfvx5z5syBIMgva4+KipId605xcTFefPFFbNy4EaNGjZK29+vXzzMD9xNqpbyyJAgCVAoBFpsIi9NaS46eJcfVck1dwVvWs2S2QhTFOn/OAPD21tM4e7UCcaFaTOibiA93nee95IiIyON8Yhqutg0bNqCwsBAzZ86ssy8tLQ2xsbEYPnw4NmzY4PY8W7Zsgc1mw6VLl9CzZ08kJSXhT3/6Ey5evOj2dUajEaWlpbKHP1PVCkvO25xvnuuoLIXd4DScc8+S1SbWueecw77zRQCA5+/qiXYRuhv6nkRERPXxybCUnp6OsWPHIikpSdoWHByM5cuXY82aNfj2228xfPhwTJo0yW1gOnfuHGw2G15//XW8/fbb+PLLL1FUVIQ777wTJpOp3tctWbIEYWFh0qN9+/YefX+tjUohb/AGalb1vv3NnXjx62MAaipLiWH24HK5pAoVRgue+OQQPt7b+Ev6a1eHXE2tiaKI89cqAAA9E0KhU1cvV8DKEhEReZhXw9L8+fPrbdx2PDIzM2Wvyc3NxebNmzFr1izZ9ujoaMydOxepqakYPHgwli5diqlTp2LZsmX1fn+bzQaz2Yx//vOfGDt2LP7whz/gs88+w++//44dO3bU+7oFCxZAr9dLj4YqUb5OXWvpAABQOm378fRVADUN3v2SwqBVKVBcaca7P57F98fzsfyHLNkCls4aCkeuqkVFFSaUGSwQBKBDZKDT2k4MS0RE5Fle7VmaN28eZsyY4faY5ORk2fOMjAxERUUhLS2twfOnpqZiy5Yt9e5PSEgAAPTq1UvaFhMTg+joaOTk5NT3Mmi1Wmi12ga/v7+QLR0QUD0N51RtKiq3V+Ec03DBWhX6JYXhQHYxVuzKBgCUVJpxsagKHaICZef+302ZSP/5PL6ePQy9EkMBAFXmhlcCd1SVEsN0CFArEcDKEhERNROvhqWYmBjExMQ0+nhRFJGRkYFp06ZBrVY3ePyRI0ekQOTKsGHDAABZWVnSlF5RURGuXbuGjh07Nnpc/s556YAQxzScU2WpwmSFwWyVpuG0KiVu7hiBA9nFKDPW9B/9lltSJyztOVsIk9WGX3OKncJSw9NwjrDUKdp+PkdliT1LRETkaT7Vs7R9+3acP38ejz76aJ19K1euxGeffYbMzExkZmbi9ddfx4cffog5c+ZIx6xbtw4pKSnS8+7du2PixIl45plnsHv3bhw/fhzTp09HSkoK7rjjjhZ5T77AubIUVKvB26GowiRVlrRqBW7uEFHnPEdzS+psK6m0V6UKy2t6xGrfgNdVAMourA5LUUEAAF11WOLVcERE5Gk+sXSAQ3p6OoYOHSoLPM4WL16MCxcuQKVSISUlBatXr8bkyZOl/Xq9HllZWbLXfPTRR3j22WcxYcIEKBQK3Hbbbdi0aVOjKldthexquOppOGOtqbKrZUbp1icapTwsKRUCrDYRR3P1dc5dVFEdlipqboBbu7JUaap725Tsa5UAgM7R1WFJraz3WCIiohvhU2Fp1apV9e6bPn06pk+f7vb1M2bMqNMjFRoaivT0dKSnp3tiiH5JLbsazh5KrpQZZcfk6Q3S11q1AhEaFTpEBiKnqBJ/7JeA9Ucu4/glPaw2UVrU0my1odRgDzfyypI8iLmqFknTcLUqS2zwJiIiT/OpaTjyDqXsdieuK255+irpa031tN0Tt3fBgA7h+Nu4FOjUSlSYrDh3tVw6rqTSLH19rbwmfNUOR7Wn4URRrJmGq1VZYoM3ERF5GsMSNUi+dIDS5TGOypJSIUg9Tg/e0gHrnhyGxHAd+rSzN28fu1QzFVdcWVNNKqwwIaewEqv25aDUYIaz2mHpapkRlSYrFNXLBgA1Dd5mqyi7uS8REdGN8qlpOPIO5wbvkHoqS5dL7JUljdJ1/k6JD8WB7GJkFZShymRFnr5K6lcCgMJyI1795gS2nqq5Ka7jliq1p9bOVFenkiICoVHZv59j6QDAXplS1zMOIiKi68W/UahBTrNwUoP34om90SshFNOG2JdYyK+uLGnVrn+kesSHAABO55dh4frjGLn8R2w7VSDtL6404+Rl+W1jIoPsN+StXVnKyi+TnRMAtCqFNE72LRERkSexskQNcqyfBNRMwz08pBMeHtIJn+6z38bEMQ2nVbkPS5n5ZagwFgOArIoEAJedmsQBe1i6Umas04fkCEspTmFJEASpL4p9S0RE5EkMS9Qg52UCtCp5z1JUdfXncnWDt6aesNQ91h5snK+ac1zRVp+oYPu5a6+7lOmisgQAOo0KFSYrF6YkIiKP4jQcNcjdQo9Rwfbbvjhu+1Y7TDmEBaoRHxpwXd83Msh+bufwY7OJOF1Qt7IEADqN/ceZlSUiIvIkhiVqkPM0XG2OviKHbrHB9R7bvVa4aYijalXpFH4uFlei0mSFRqWQ1lhyCFTbC6XsWSIiIk9iWKIG1b6fm7OoWmHp1u713+uvdiWoIRGB9nMbnMKPYwquW2yw7Co9AAjgwpRERNQM2LNEDbp3QDsU6A0Y0iWqzr7QAPlSAu7CUvc4e1hyLHJprb49SlKEDrnFVXWOd/QsOU/DuboSziHQccsTTsMREZEHsbJEDVIpFZgzqhsGdYqss0+hkN9Qt124rt7zpHaORIBagdu7xyAxvKZ/qb6pO0fV6vglPb48lAuz1YYjF0sAuK5SSTfTZWWJiIg8iGGJPKZ7XP39SgDQPjIQe+aPwr+n3CytvA0A3eJqgk9yTE0fUqjOXrUqM1rwlzW/4alVv2J7pn25gdt7xNY5vyMs8Wa6RETkSQxLdMPuuzkJALDwj70aPDYiSIMAtRLtI2rCUtfqypJKIaB/Uri0PUwnn+LbfMK+iOVdfeOlKT1nNfeH4+1OiIjIc9izRDds8aTeeGZUN7eN4LW1r64sKRUCeiXY7xuXHBOE2FCtdEyvhFA8O7o7OkTp8GPWVXx95DIA4OlR3VyeUwpLrCwREZEHMSzRDQvUqNAh6vp+lBxhKSJQjT7twvCPB25C97gQXC0z4r0fzwGw90M9M9oejG7vHovCChNuah+OlPjQesbhqCxZIYoilm3OQkpCKNL6Jzb1rRERETEskXf0SQyFIABdYuxTcBNvagcA6JkA/OOBm9AtVj7NFhGkwcezUt2eM0BdE5Y2nyjAf3aeBQCGJSIiuiEMS+QVyTHB+P6ZES5X9XYEp+sVKDV4W/Fbbom0XRRFCIJQz6uIiIjcY1gir6lvOq2ppKUDzFZcclq3yWC2SfuIiIiuF8MS+Q1Hg3elyYriypob9uqrzAxLRETUZFw6gPyGIxBVGC3Iyi+VtpcazN4aEhER+QGGJfIbjp6lU3llMDittaSvYlgiIqKmY1giv+G4Gq7cKF9nqZRhiYiIbgDDEvmNQI3rFjxWloiI6EYwLJHf6BIT5HIpAlaWiIjoRvBqOPIbIQFq/PjX27HrzDVcLjHgaG4JvjiYC30Vb39CRERNx7BEfkWrUmJkShwAYOn39rWWeDUcERHdCE7Dkd8K1dn/LcCeJSIiuhEMS+S3wnRqAOxZIiKiG8OwRH4rNMAellhZIiKiG8GwRH5LqiwZ7A3eoigyOBER0XVjWCK/FVprGu6tLadx06s/YM/ZQm8Oi4iIfAzDEvmt2j1LW09dgSgCB7OLvDksIiLyMQxL5LdCA+xXw5UZLagyWfF7QRkA4LK+ypvDIiIiH8OwRH7LMQ0HAAcvFMFiEwEAl0sMKKowYdPxPJittvpeTkREBIBhifyYWqlAoMZ+c13nPqU8fRVe/+4UHv/kV3x7NM9bwyMiIh/BFbzJr4Xp1Kg0WbHbKSxdLjFAgB4AcP5ahbeGRkREPoKVJfJrjrWWjlwskbaVGy04c7UcAHClzOiNYRERkQ9hWCK/FubUtwQAgmD/r7W6f+kqwxIRETWAYYn8WnhgTVgK1CjRPTZEtv9qOcMSERG5x54l8muP3ZoMs9WGKrMVaf3bYdupAmRVLyEAAFdLDV4cHRER+QKGJfJrgzpFImPmLdLzk3l62f6r5UaIogjBMT9HRERUC6fhqE1JCNPJnputvF8cERG5x7BEbUq7cF2dbbwijoiI3GFYojYlISwAAKBUCOgYFQgAOHulHNtOFcBWfYUcERGRM4YlalN6JYYiLlSLkSmxUpVpzmeHMWvlQXxx8KKXR0dERK0RwxK1KSEBauz620i8//BAxIRoAUC6Z9wPJwu8OTQiImqleDUctTkqpf3fCLHVYclhz9lCGC1WnL1Sgde+Owmj2YZxfeLx8JCO0KqU3hgqERG1AgxL1GbF1ApLVWYrFn9zEl8cyIXJagMAHLxQjCCtCg/e0sEbQyQiolaA03DUZjmHJU11temTvTkwWW0Y3TMWd/aKA8Cb7RIRtXUMS9RmRQbVhKVpQzpKX4/rHY/3Hx6EIclRAIBLJVUtPjYiImo9fCIs7dy5E4IguHwcOHAAAJCdne1y/969e92e+8CBAxg1ahTCw8MRERGBsWPH4rfffmuJt0Ve1iEyUPr6yTu6IjZEi5vah2P5n/pDoRCQWH213KVihiUiorbMJ8LS0KFDkZeXJ3s8+uij6Ny5MwYNGiQ7duvWrbLjBg4cWO95y8vLMW7cOHTo0AH79u3DL7/8gpCQEIwdOxZmM1d19nedo4Ow8pFb8N3TIxAZpMHu+SPx1RNDEaS1t/I5lha47Kay9NvFEsxdfQR5egYqIiJ/5RMN3hqNBvHx8dJzs9mM9evXY86cOXXu6RUVFSU71p3MzEwUFRXh1VdfRfv27QEAixYtQr9+/XDhwgV07drVc2+CWqXbusdIXzuuknNIDLcvYHmlzAijxeryirh3dp7FphP56BIbjNl38OeFiMgf+URlqbYNGzagsLAQM2fOrLMvLS0NsbGxGD58ODZs2OD2PD169EBUVBTS09NhMplQVVWF9PR09OzZE506dar3dUajEaWlpbIH+Z/IIA20KvuvSIHe9S1RTheUAXBffSIiIt/mk2EpPT0dY8eORVJSkrQtODgYy5cvx5o1a/Dtt99i+PDhmDRpktvAFBISgp07d+KTTz6BTqdDcHAwNm3ahO+//x4qVf1FtyVLliAsLEx6OKpS5F8EQZCm4lw1eRvMVmQX2q+Uy9cbGjzf5hP52Huu0LODJCKiZufVsDR//vx6G7cdj8zMTNlrcnNzsXnzZsyaNUu2PTo6GnPnzkVqaioGDx6MpUuXYurUqVi2bFm937+qqgqzZs3CsGHDsHfvXuzatQt9+vTBhAkTUFVVf6VgwYIF0Ov10uPiRd4mw18luulbOne1Ao7byeU1EJYKy4144pND+O+PD3l8jERE1Ly82rM0b948zJgxw+0xycnJsucZGRmIiopCWlpag+dPTU3Fli1b6t2/atUqZGdnY8+ePVAoFNK2iIgIrF+/Hg888IDL12m1Wmi1Wpf7yL84+pZchaXfr5RJXzfU4H213AibCOirzPX2PxERUevk1bAUExODmJiYhg+sJooiMjIyMG3aNKjV6gaPP3LkCBISEurdX1lZCYVCIWsSdzy32WyNHhf5L6myVB2GsvLLoFYKSI4JlvqVAKC40gyD2YoAtesQpK+subqy3GCBNphhiYjIV/jE1XAO27dvx/nz5/Hoo4/W2bdy5UpoNBoMGDAAALB27Vp8+OGH+OCDD6Rj1q1bhwULFkhTe3feeSeee+45zJ49G3PmzIHNZsPSpUuhUqlwxx13tMybolZNWmupxIC95wrx0P/thU0ERqXE4lqFSXZsnt6AztFBqDJZoVIKUDtdXVdqsEhflxstiApmZZKIyFf4VFhKT0/H0KFDkZKS4nL/4sWLceHCBahUKqSkpGD16tWYPHmytF+v1yMrK0t6npKSgo0bN+KVV17BkCFDoFAoMGDAAGzatMltRYrajqTqsJSVX4q5q49IPUrbMq/UOTZPX4Ws/DI8t+Y3JMcEYf1Tw6V9pVVOlSWjpc5riYio9RJEURS9PQhfV1pairCwMOj1eoSGhnp7OORBefoqDFmyXXreOToIb/2pPx76v32oMlsBAD3iQpBVUIbhXaPxy5lr0rHHXxmL4OoFLjN2nccrG08CAFY/9gekVt9KhYiIvKexf3/75NIBRC0lIUyHFTMH494B7XBzh3D8v4cGYECHCLz38EAIAtAxKhB92oUBgCwoAcDFokrp69Iq+TQcERH5Dp+ahiPyhtt7xOL2HrGybbd2j8G2ubchWKvCx3svSNsVAtAuQoeLRVXIKapEzwT7v1T0nIYjIvJZDEtETZQcEwzAXn1yuKVzJKKDtbhYVCWvLBlqwlKZgWGJiMiXMCwR3aCEsADp6zG94nGt3H5rlBzZNBwrS0REvoo9S0Q3KDa0ZhmAMb3j0CEyEECtsGSQr7NERES+g5UlohuUEh+Ku/rGIz5Uh6SIQNdhiQ3eREQ+i2GJ6AYpFQL+M2Wg9Lx9dVjKLaqCzSZCoRDY4E1E5MM4DUfkYQlhAVApBJisNhSU2W+wy2k4IiLfxbBE5GEqpQLtIuxXyOUUVsJmE2XVJFaWiIh8C8MSUTNw7lsqM1rgvE5+GcMSEZFPYVgiagZJEfawdLG4SrZsAACUG8yuXkJERK0UwxJRM0iqnoa7VFwla+4GOA1HRORrGJaImkG78OqwVFIpNXdrlPZfNzZ4ExH5FoYlomaQWB2WLpcYpDWWEsLtK31XmKyw2cR6X+tpV8oMuFpmbLHvR0TkbxiWiJqB42q4PH0V9FUmAECi0z3kKkwtU10yWqwY//bPGP+Pn2Gx2lrkexIR+RuGJaJmEBeihVIhwGwVceZKOQAgJkQLtVIA0HJ9S5dLDCisMOFaubFO7xQRETUOwxJRM1ApFYgPtU+7ncorAwCE6dQI1toXzW+pvqXLJVXS1yUMS0RETcKwRNRMHE3ep/JKAQChOhWCA+xhqaXWWrpUXBOWWFkiImoahiWiZuLoWyqssPcsxYcGIEhTt7J0/JJemqrztEslDEtERDeKYYmomTgqSw6jesYhpLqy5OhZKq4w4d53duP+9/Y0yxVyztNwtRfHJCKixmFYImomiU5h6eYO4UgM19X0LFWHpROXS2Gy2FBYYUJeqcHjY7isZ2WJiOhGMSwRNRPHNBwA3NU3AQAQHKAGAJRU2qfmMvNLpWMuXKvw+Bice5ZKKhmWiIiagmGJqJk4T8M5wlLnKPs94/617QwO5xQjM79MOuZ8oT0sncorxexVvyK3uPKGvr/NJuKyvqZaxcoSEVHTqLw9ACJ/1SUmCI/dmoyoII00Jffft3XB3nNF2J9dhD9/dAhRQRrp+AuF9nD09y2n8cPJAsQEa7Ho7l6oMFml6bvrUVhhgslSsxClvsosNXzX7qciIqL6sbJE1EwEQcDzd/XEf9/WRdoWpFUhY+ZgxIRoca3ciKwCp8rStQrYbCL2nS8CABzOKcYn+3LQZ9FmbDqef93f37m5GwCulRvxx3/+jLv/9YssRBERkXsMS0QtLEirwoTqaTlnFworcDKvVJouO3G5FCt3ZwMAtp4quO7vc6lWWDp5uRTFlWYUVZiQp6+q51VERFQbwxKRF6TdlCh9HR1sn4q7UFiJ3WevSdsttppbpWQ59TbV52JRpSwgOSpLEYH2pvIrTjfTzS1mWCIiaiyGJSIvGNA+HO0j7X1Dd/SIhUohwGixYd3hywAAQZAf//uVMljdrMN0uaQK497+CWn/+gUGsxUAcPaqPWj1Tgyrc/wlhiUiokZjWCLyAkEQMGtYZwDA+L7x6BBpv0rOcWuUu/rIp+kMZhtyiuq/Ou7vW06jwmRFYYUJB7LtPU97z9n/OzIlts7xuSUMS0REjcWwROQlM4Z1xqlXx2FkShzaV4clAEiK0GHKHzpIzx1XwmXl2/uZRFHEp/suYNK/d2HvuUL8XlCGr37NlY7/+fdryNNX4fy1CigE4M5ecXW+940uS0BE1JZw6QAiL9JplACAWzpH4sfTVzGsaxSW3tsPMSFadIwKREiACt1jQ7D28CXM++I3VJisiArSSPebm/PZYUQHa2ET7b1P18pN+On0VaTEhwAA+iaFy1YSd7hUXIVDF4ogisCgTpHSdoPZigC1sgXeORGR72BYImoFnry9Cyb0TUDHqEAI1Q1L2+fdDlEUkbErGzh8CRUmey9SYYUJCgGICtbiapkRV8uMiA7WIGPGLbj7//2CzPwyfH3E3vs0JDkKSoWA0AAVSp1u3nu6oAwP/d8+AMD+50cjLFCNtb/m4i9rfsPEm9rh9Xv6SkGOiKit4zQcUSsgCAI6RQdJQQkAlAoBKqUCPaqrRIC9ArVi5mBseGo40qcPgkohQKNU4L2HB6JvUhj6tAsFAPx0+ioAYGiXKABAWPUVcQ7FlWYYLTYYLTb8mlMMURTxr+1nYBOBdYcvYWr6PrcN5c42Hc/D14cv3dD7JyJqzVhZImrleiaESl8vuruX7Oq2758ZAZVSgc7RQQCAsb3icfySvUk8RKvCoE4RAIAwnRoXUQWVQoAgAGZrTRA6kF0ErUqB89cqEFRdTTp0oRj7zhdiaJdot2PL1xvw5Ke/wiYCfdqFomtsiNvjiYh8EcMSUSsXE6LFu1NvhkalqLMMQLc4eTh54vYuGNgpAoXlJqTEhyBQY/8VD9PZK0vxYQFQCILsyrqD2cW4UP180oB2sFhFrD54ERt/u9xgWFp/5BIcBajvjuXj6VEMS0TkfzgNR+QDxvVJwMiUule11aZSKjC0SzTu7p8oC1LhOvvCl+3CdUiKsDd8O2b8jlwswebq26k8lNpBWjDzu2P5stuimCw2aQ0nABBFUXYV3nfH8pr47oiIWjdWlojagNDqylK7CB2U1SlpaJconMorQ1H1lXWje8aid2IYrDYRMSH25vEvDl7Ebd1jsO7wJfzfz+cQolVhw5zh2HqyAAeyi3G6oBwapQI2UURmfhnOXi1Hl5hgmK02LP7mJEqrzFg8qQ9CAtT1jo2IqLVjWCJqAxxLCdzUPhzxoQFYf+QyHv5DR3z16yVsOVmAQI0Sr0zsA8DeWD6xfyI++OU8Xvz6uOw8ZQYLHvq/vThdUC5tG90rFhVGK348fRWvf3sKC+5KwX92nMXa6qbv3OIqvD9tECKDNC30bomIPEsQRbFxl7xQvUpLSxEWFga9Xo/Q0NCGX0DUwkRRxLlrFegcFQSFQoAoihAEAd8fy8P/rD6CVyf2xv2DaxbCrDJZ8cbmTHxx4CIMFhtu7hCO23vE4s0fsuD4P8aEvglIDA/A9KGdcOZKOR5ZcQDOF9ApFQIC1UqUGS1QKwWM7R2Pl9N6IzpY28Lv3rUjF0vw4Pt7MW9Mdzw6ItnbwyEiL2js398MSx7AsES+zGYToVAILvcZLVZYbaLUKL74m5NI/+U8xvSKw7tTB8pe99vFEixcfxyZ+WWIC9Xib+NS0DEyCPPXHsWJy/Yr9KKDtZiS2gHj+8YjJb5pvyuiKGL/+SL0bx9+Qwtozv/qKD4/cBHd44Lxw7O3Nfk8ROS7GJZaEMMStRVWmz2oDOoUAbWy8deHHMvVY96aI9L0nUohYOUjt2BYV/nVdgazFZtP5KNTVBCCtEoczdVjVEqcbJ2olbuzsWjDCfwhORIfz0q9rnE4iKKIIUu2I7/UAAD47aUxddaiIiL/19i/v3k1HBE1mlIhYEiXqOsOKH2TwrDhqeFYem9fpHaOhMUm4olPDuHbo3nQV5kB2Ctc//P5ETzz+RFM/PcujH7rJ8z94jc8/skhOP5NZ7WJ+L+fzwGw3yj4b18dxdHcEjTm33z/3nEGz64+gjKDGZn5ZVJQAoBfc4qlr0/llWLCP3/GmoMXr+s9EpH/YmXJA1hZImo8g9mKB/9vLw7nlAAAQgJUWDa5H3afLcRHey5ArRSgVSmlZQtMVhtm39EFgRoVTBYb/rHtdwRqlKg01SxjcFv3GDw3tgeO5urRt10YdBoldmZdwYAO4RjYMRIbf7uMOZ8dBgCMTInFwI4RWLY5S3r9vTe3g1IQcFuPGPxnx1mczCtFSIAKv/x1JEICVNJ04/lrFUgMD4BWpYS+yozQABXMVhFfH76EWzpHIkirwttbT+NauREdo4LwlzE9oFHx36RErRWn4VoQwxLR9SmuMOH/7TiDbacKkF1YKdu3/L/6Y+JNibCJwIrd5/H6d5l1Xj/7ji7olRCGLw5exN5zhTA6rQdVW/+kMJy7VoEyp3vjKQTAJgJ924Xh2CV9va8d1DECmfll+NOg9kiK0OHVb06ie1wwUjtH4eO9F/DHfgmIDtZixe5shOnUiAvVyq4UfCWtN6YP7XQdnwwRtSSGpRbEsETUNCaLDS9+fQxfHMxFcnQQ5o7pjj/2S5T2W6w2TM/Yj1N5ZbipfTh2n70GrUqJzf9zK+LDAgAAxy/p8eePDiK/1IB+SeE4dbkUZpsNN3eIwG8XS2CpvkSvT7tQPDo8GfPXHoXBbEOAWoEPpg3G1HT7DYU1SgVMVnvomtA3Ad82cZHN6GAt7uwVh8/25yAmRIufnrujzk2JTRYblnx/CiculWLhH3uhb1JYPWcjoubEsNSCGJaIbsylkirEhwZAWc9VeQ5lBjOsNhHhgfI1m6pMVlSZrYgM0kBfZYbFakNUsBa5xZX4NacE+iozxvaOQ2xIAMoMZuQWVyE8UI340ACkvr4NV8qMeGNyP7QL16Gg1IBJN7XD9Iz9OJJTgjt7xUlrRo3rHY+SKhPOXq3AmF5x+HRfDgAgrX8iSg1mZOaV4YPpg9A9LgQjl+9EbnEVRqXEYmjXaJgsNiTHBCFIo8K/d5zBnnOFAAC1UsCzd3bHzKGdcbG4Eu3CdQjS2q8+NFttMFtt0tWItV0pNeCl9SdwMq8Uf7//JgzsGHFDfw5EbQ3DUgtiWCLyXcdy9bhYXInxfeIhCDVhzVpdkVIqBHy8JxtZBWV4/q6eCNSopIby5T+cxonLerx9/wCEBaplyzCsP3IJz3x+pN7vG6RR4uaOEfj592sAaqYGAzVKDOsaDYVgb2IvM5hxW/cYDOsajbjQAFhtIkxWG05eLsVXv+ZK04uBGiXm3tkd/duHo31EIBSKmhBpNNtgstpQbrBgy6kCXCsz4v7B7XGxqBLZhZX4Y78E9E4MgyBAthyDKIr4Nce+UvugjhHoGhsMAMgpqkRplQVatQIJYQH46fQ1nLtajqFdo7Du8CUcOF+Mp0Z2xaiesag0WREdrMWlkiqcv1qBmzqEw2C2IqeoEh0jAxESoIYIERqlQvb5u+JYH4zIUxiWWhDDEhG5svdcIXZkXkFuSRXUCgHHLulRZrDgjh6xmDWiM7rFBuOrXy9hyXenUFhhgkalkN2PrzH6tgtDSIAKu88WemTM0cEaAAJMFit0GiUKSo3SvpAAFXRqJa6UGes/QT3nvFZuv62OWinAbK37145CAAI1KgRplQjXaSBChMlir6qVGc24WmaEwWxDiFaF2FAt1EoFFIIApUKAQiFAKdiDrWOb0WJD9rUKCAIQExKAuFAtYkO0iAzSQoQIm02ETQRUSgEapQJWm4jc4ipoVQokhutgstpQabTAYhORGK5DSIAKl4qrsOlEPgI1KozrHQ+rzQYRgFalQFGFGSJEBFVXAW2iCJVCQJfYYIQHalBmMKPMYEGZwQyD2YaIIA1igrWICFSj0mxFmcECg9mKyEANyoxmXC4xoGNUIKw2EReLKhEfpkO4Tg2z1YYAjRLa6nCpEOz3hFQrBVSarLCJIrQqBbQqJRSCAKtNhFUUYbWJsDn+67RNo1IgTKeGwWyFKNr/DMxWGyw2EYIACAAUggBBqPmvAAEKRfV/Bft9JgVBgKdirCMQC6i5h6UAAfFhAR6/YIJhqQUxLBHRjag0WZCvN6BjVBAO5xTj+CU9RAC9EkIRFazFd8fykJVfhqvlRmiq/2KMDNIi7aZEDO8aDYvNhhW7srH3XCFOF5QjT18FEYBOrUSgRgmtSgmNSgGNUoG+SWEI1qqw+sBFJIQFoF9SGL47nl9vSNOqFOiXFIbfcvXSMRqlAlHBGpQbLSgzWBATokWfxFD8cuYakqODMaJbNFbuya4TiuJCtVL4ig3RXnfoorZt+7zbkBwT7NFz+lVY2rlzJ+644w6X+/bv34/BgwcDsJdoly9fjvfffx8XLlxAdHQ0nnzySbzwwgv1nruoqAhz5szBxo0boVAocN999+Ef//gHgoMb/wfCsERErYnVJlb/i79x/9Y3WqywWEWYrTbkFldBIQjQqAToqyzoEhOE8EANjBYrsq9VotRgRt92YQhQKyGKIkqrLAjSKqFSKmTTkOVGi71yoVTgVH4p4kMDkBAWgAuFlQgOUCE6WAuD2SpdyWgwW1FpsqLCaEFxpQlKQYBKqUCFyWKvJoUEIECjQGmVBVfLjFLFxGYT5V9XV0yUCgGdooKgEAQUlBlwpdSAK6VGFFWaoBAEqBT2som1+n2LgL2iZLEhv9SAAJUSQVolBNjvb2iwWBGkUeGOlFgUV5qw71wRQnUqKAQBBrMVEUEaKAVBWtJCEOzvKSu/DFVmG0ICVAgNUCFYq0KAWomiChOulhtRUmlGoEYpbS+uNCFApURieACyCyuhVAjoGBWIfL0BFSYr1AoBVWYrzFYbbKJ9fTKLzf4edBollIK9qmYwWyECUErVN0ClUEDhogKnrzJDVz39WmmyQqtSQKkQIEKEKKL6IUKEvWJmc7FNFO3/vdHqkuj0heNrR0z55ukR6BwddIPfQc6vwpLJZEJRUZFs28KFC7Ft2zacPXtW+h/C008/jR9++AFvvPEG+vbti6KiIhQVFeHOO++s99zjx49HXl4e3nvvPZjNZsycORODBw/GqlWrGj0+hiUiIiLf41dhqTaz2Yx27dphzpw5WLhwIQDg1KlT6NevH44fP44ePXo06jynTp1Cr169cODAAQwaNAgAsGnTJtx1113Izc1FYmJiA2ewY1giIiLyPX59u5MNGzagsLAQM2fOlLZt3LgRycnJ+Oabb9C5c2d06tQJjz76aJ2KlLM9e/YgPDxcCkoAMHr0aCgUCuzbt69Z3wMRERH5Bp8MS+np6Rg7diySkpKkbefOncOFCxewZs0afPTRR1ixYgUOHTqEyZMn13ue/Px8xMbGyrapVCpERkYiPz+/3tcZjUaUlpbKHkREROSfvBqW5s+fb7/c0M0jM1N+q4Pc3Fxs3rwZs2bNkm232WwwGo346KOPMGLECNx+++1IT0/Hjh07kJWVBU9asmQJwsLCpEf79u09en4iIiJqPVwvC9tC5s2bhxkzZrg9Jjk5WfY8IyMDUVFRSEtLk21PSEiASqVC9+7dpW09e/YEAOTk5LjsY4qPj8eVK1dk2ywWC4qKihAfH1/vmBYsWIC5c+dKz0tLSxmYiIiI/JRXw1JMTAxiYmIafbwoisjIyMC0adOgVqtl+4YNGwaLxYKzZ8+iS5cuAIDTp08DADp27OjyfEOGDEFJSQkOHTqEgQMHAgC2b98Om82G1NTUeseh1Wqh1WobPW4iIiLyXT51Ndy2bdswevRonDp1CikpKbJ9NpsNgwcPRnBwMN5++23YbDbMnj0boaGh+OGHHwDY12SaNm0atm3bhnbt2gGwLx1QUFCAd999V1o6YNCgQVw6gIiIyM/55dVw6enpGDp0aJ2gBAAKhQIbN25EdHQ0br31VkyYMAE9e/bE559/Lh1TWVmJrKwsmM1madunn36KlJQUjBo1CnfddReGDx+O999/v0XeDxEREbV+PlVZaq1YWSIiIvI9fllZIiIiImppDEtEREREbjAsEREREbnBsERERETkBsMSERERkRteXZTSXzguKOQ94oiIiHyH4+/thhYGYFjygLKyMgDgLU+IiIh8UFlZGcLCwurdz3WWPMBms+Hy5csICQmBIAgeO6/jnnMXL17k+k0N4Gd1ffh5NR4/q8bjZ9V4/Kwarzk/K1EUUVZWhsTERCgU9XcmsbLkAQqFAklJSc12/tDQUP4yNRI/q+vDz6vx+Fk1Hj+rxuNn1XjN9Vm5qyg5sMGbiIiIyA2GJSIiIiI3GJZaMa1Wi0WLFkGr1Xp7KK0eP6vrw8+r8fhZNR4/q8bjZ9V4reGzYoM3ERERkRusLBERERG5wbBERERE5AbDEhEREZEbDEtEREREbjAstWL//ve/0alTJwQEBCA1NRX79+/39pC87uWXX4YgCLJHSkqKtN9gMGD27NmIiopCcHAw7rvvPhQUFHhxxC3np59+wt13343ExEQIgoCvv/5atl8URbz00ktISEiATqfD6NGj8fvvv8uOKSoqwpQpUxAaGorw8HDMmjUL5eXlLfguWkZDn9WMGTPq/JyNGzdOdkxb+ayWLFmCwYMHIyQkBLGxsZg0aRKysrJkxzTm9y4nJwcTJkxAYGAgYmNj8dxzz8FisbTkW2l2jfmsbr/99jo/W48//rjsmLbwWb3zzjvo16+ftNDkkCFD8P3330v7W9vPFMNSK7V69WrMnTsXixYtwq+//or+/ftj7NixuHLlireH5nW9e/dGXl6e9Pjll1+kfc8++yw2btyINWvW4Mcff8Tly5dx7733enG0LaeiogL9+/fHv//9b5f733jjDfzzn//Eu+++i3379iEoKAhjx46FwWCQjpkyZQpOnDiBLVu24JtvvsFPP/2Exx57rKXeQotp6LMCgHHjxsl+zj777DPZ/rbyWf3444+YPXs29u7diy1btsBsNmPMmDGoqKiQjmno985qtWLChAkwmUzYvXs3Vq5ciRUrVuCll17yxltqNo35rADgz3/+s+xn64033pD2tZXPKikpCUuXLsWhQ4dw8OBBjBw5EhMnTsSJEycAtMKfKZFapVtuuUWcPXu29NxqtYqJiYnikiVLvDgq71u0aJHYv39/l/tKSkpEtVotrlmzRtp26tQpEYC4Z8+eFhph6wBAXLdunfTcZrOJ8fHx4rJly6RtJSUlolarFT/77DNRFEXx5MmTIgDxwIED0jHff/+9KAiCeOnSpRYbe0ur/VmJoihOnz5dnDhxYr2vaauflSiK4pUrV0QA4o8//iiKYuN+77777jtRoVCI+fn50jHvvPOOGBoaKhqNxpZ9Ay2o9mcliqJ42223ic8880y9r2mrn5UoimJERIT4wQcftMqfKVaWWiGTyYRDhw5h9OjR0jaFQoHRo0djz549XhxZ6/D7778jMTERycnJmDJlCnJycgAAhw4dgtlsln1uKSkp6NChQ5v/3M6fP4/8/HzZZxMWFobU1FTps9mzZw/Cw8MxaNAg6ZjRo0dDoVBg3759LT5mb9u5cydiY2PRo0cPPPHEEygsLJT2teXPSq/XAwAiIyMBNO73bs+ePejbty/i4uKkY8aOHYvS0lKpkuCPan9WDp9++imio6PRp08fLFiwAJWVldK+tvhZWa1WfP7556ioqMCQIUNa5c8Ub6TbCl27dg1Wq1X2QwAAcXFxyMzM9NKoWofU1FSsWLECPXr0QF5eHl555RWMGDECx48fR35+PjQaDcLDw2WviYuLQ35+vncG3Eo43r+rnynHvvz8fMTGxsr2q1QqREZGtrnPb9y4cbj33nvRuXNnnD17Fs8//zzGjx+PPXv2QKlUttnPymaz4X/+538wbNgw9OnTBwAa9XuXn5/v8mfPsc8fufqsAOChhx5Cx44dkZiYiKNHj+Jvf/sbsrKysHbtWgBt67M6duwYhgwZAoPBgODgYKxbtw69evXCkSNHWt3PFMMS+ZTx48dLX/fr1w+pqano2LEjvvjiC+h0Oi+OjPzJAw88IH3dt29f9OvXD126dMHOnTsxatQoL47Mu2bPno3jx4/L+gTJtfo+K+e+tr59+yIhIQGjRo3C2bNn0aVLl5Yeplf16NEDR44cgV6vx5dffonp06fjxx9/9PawXOI0XCsUHR0NpVJZp/O/oKAA8fHxXhpV6xQeHo7u3bvjzJkziI+Ph8lkQklJiewYfm6Q3r+7n6n4+Pg6FxBYLBYUFRW1+c8vOTkZ0dHROHPmDIC2+Vk99dRT+Oabb7Bjxw4kJSVJ2xvzexcfH+/yZ8+xz9/U91m5kpqaCgCyn6228llpNBp07doVAwcOxJIlS9C/f3/84x//aJU/UwxLrZBGo8HAgQOxbds2aZvNZsO2bdswZMgQL46s9SkvL8fZs2eRkJCAgQMHQq1Wyz63rKws5OTktPnPrXPnzoiPj5d9NqWlpdi3b5/02QwZMgQlJSU4dOiQdMz27dths9mk/6G3Vbm5uSgsLERCQgKAtvVZiaKIp556CuvWrcP27dvRuXNn2f7G/N4NGTIEx44dkwXMLVu2IDQ0FL169WqZN9ICGvqsXDly5AgAyH622sJn5YrNZoPRaGydP1Mebxknj/j8889FrVYrrlixQjx58qT42GOPieHh4bLO/7Zo3rx54s6dO8Xz58+Lu3btEkePHi1GR0eLV65cEUVRFB9//HGxQ4cO4vbt28WDBw+KQ4YMEYcMGeLlUbeMsrIy8fDhw+Lhw4dFAOJbb70lHj58WLxw4YIoiqK4dOlSMTw8XFy/fr149OhRceLEiWLnzp3Fqqoq6Rzjxo0TBwwYIO7bt0/85ZdfxG7duokPPvigt95Ss3H3WZWVlYl/+ctfxD179ojnz58Xt27dKt58881it27dRIPBIJ2jrXxWTzzxhBgWFibu3LlTzMvLkx6VlZXSMQ393lksFrFPnz7imDFjxCNHjoibNm0SY2JixAULFnjjLTWbhj6rM2fOiK+++qp48OBB8fz58+L69evF5ORk8dZbb5XO0VY+q/nz54s//vijeP78efHo0aPi/PnzRUEQxB9++EEUxdb3M8Ww1Ir961//Ejt06CBqNBrxlltuEffu3evtIXnd/fffLyYkJIgajUZs166deP/994tnzpyR9ldVVYlPPvmkGBERIQYGBor33HOPmJeX58URt5wdO3aIAOo8pk+fLoqiffmAhQsXinFxcaJWqxVHjRolZmVlyc5RWFgoPvjgg2JwcLAYGhoqzpw5UywrK/PCu2le7j6ryspKccyYMWJMTIyoVqvFjh07in/+85/r/EOlrXxWrj4nAGJGRoZ0TGN+77Kzs8Xx48eLOp1OjI6OFufNmyeazeYWfjfNq6HPKicnR7z11lvFyMhIUavVil27dhWfe+45Ua/Xy87TFj6rRx55ROzYsaOo0WjEmJgYcdSoUVJQEsXW9zMliKIoer5eRUREROQf2LNERERE5AbDEhEREZEbDEtEREREbjAsEREREbnBsERERETkBsMSERERkRsMS0RERERuMCwREXmAIAj4+uuvvT0MImoGDEtE5PNmzJgBQRDqPMaNG+ftoRGRH1B5ewBERJ4wbtw4ZGRkyLZptVovjYaI/AkrS0TkF7RaLeLj42WPiIgIAPYpsnfeeQfjx4+HTqdDcnIyvvzyS9nrjx07hpEjR0Kn0yEqKgqPPfYYysvLZcd8+OGH6N27N7RaLRISEvDUU0/J9l+7dg333HMPAgMD0a1bN2zYsEHaV1xcjClTpiAmJgY6nQ7dunWrE+6IqHViWCKiNmHhwoW477778Ntvv2HKlCl44IEHcOrUKQBARUUFxo4di4iICBw4cABr1qzB1q1bZWHonXfewezZs/HYY4/h2LFj2LBhA7p27Sr7Hq+88gr+9Kc/4ejRo7jrrrswZcoUFBUVSd//5MmT+P7773Hq1Cm88847iI6ObrkPgIiarlluz0tE1IKmT58uKpVKMSgoSPZ47bXXRFG03w3+8ccfl70mNTVVfOKJJ0RRFMX3339fjIiIEMvLy6X93377rahQKMT8/HxRFEUxMTFRfOGFF+odAwDxxRdflJ6Xl5eLAMTvv/9eFEVRvPvuu8WZM2d65g0TUYtizxIR+YU77rgD77zzjmxbZGSk9PWQIUNk+4YMGYIjR44AAE6dOoX+/fsjKChI2j9s2DDYbDZkZWVBEARcvnwZo0aNcjuGfv36SV8HBQUhNDQUV65cAQA88cQTuO+++/Drr79izJgxmDRpEoYOHdqk90pELYthiYj8QlBQUJ1pMU/R6XSNOk6tVsueC4IAm80GABg/fjwuXLiA7777Dlu2bMGoUaMwe/ZsvPnmmx4fLxF5FnuWiKhN2Lt3b53nPXv2BAD07NkTv/32GyoqKqT9u3btgkKhQI8ePRASEoJOnTph27ZtNzSGmJgYTJ8+HZ988gnefvttvP/++zd0PiJqGawsEZFfMBqNyM/Pl21TqVRSE/WaNWswaNAgDB8+HJ9++in279+P9PR0AMCUKVOwaNEiTJ8+HS+//DKuXr2KOXPm4OGHH0ZcXBwA4OWXX8bjjz+O2NhYjB8/HmVlZdi1axfmzJnTqPG99NJLGDhwIHr37g2j0YhvvvlGCmtE1LoxLBGRX9i0aRMSEhJk23r06IHMzEwA9ivVPv/8czz55JNISEjAZ599hl69egEAAgMDsXnzZjzzzDMYPHgwAgMDcd999+Gtt96SzjV9+nQYDAb8/e9/x1/+8hdER0dj8uTJjR6fRqPBggULkJ2dDZ1OhxEjRuDzzz/3wDsnouYmiKIoensQRETNSRAErFu3DpMmTfL2UIjIB7FniYiIiMgNhiUiIiIiN9izRER+j90GRHQjWFkiIiIicoNhiYiIiMgNhiUiIiIiNxiWiIiIiNxgWCIiIiJyg2GJiIiIyA2GJSIiIiI3GJaIiIiI3GBYIiIiInLj/wf+ryIaxpISlQAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import openfermion\n",
-    "import openfermionpyscf\n",
-    "from openfermion.transforms import jordan_wigner, get_fermion_operator\n",
-    "\n",
-    "import timeit\n",
-    "\n",
-    "\n",
-    "import cudaq\n",
-    "import matplotlib.pyplot as plt\n",
-    "from scipy.optimize import minimize\n",
-    "import numpy as np\n",
-    "\n",
-    "# GPU\n",
-    "cudaq.set_target(\"nvidia-fp64\")\n",
-    "# CPU\n",
-    "#cudaq.set_target(\"qpp-cpu\")\n",
-    "\n",
-    "# 1- Classical pre-processing:\n",
-    "\n",
-    "geometry = [('O', (0.1173,0.0,0.0)), ('H', (-0.4691,0.7570,0.0)), ('H', (-0.4691,-0.7570,0.0))]\n",
-    "basis = '631g'\n",
-    "multiplicity = 1\n",
-    "charge = 0\n",
-    "ncore = 3\n",
-    "norb_cas, nele_cas = (4,4)\n",
-    "\n",
-    "molecule = openfermionpyscf.run_pyscf(openfermion.MolecularData(geometry, basis, multiplicity,charge))\n",
-    "\n",
-    "molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n",
-    "        occupied_indices=range(ncore), active_indices=range(ncore, ncore + norb_cas))\n",
-    "\n",
-    "fermion_hamiltonian = get_fermion_operator(molecular_hamiltonian)\n",
-    "qubit_hamiltonian = jordan_wigner(fermion_hamiltonian)\n",
-    "\n",
-    "spin_ham = cudaq.SpinOperator(qubit_hamiltonian)\n",
-    "\n",
-    "# 2- Quantum computing using UCCSD ansatz\n",
-    "\n",
-    "electron_count = nele_cas\n",
-    "qubit_count = 2*norb_cas\n",
-    "\n",
-    "@cudaq.kernel\n",
-    "def kernel(qubit_num:int, electron_num:int, thetas: list[float]):\n",
-    "        qubits = cudaq.qvector(qubit_num)\n",
-    "\n",
-    "        for i in range(electron_num):\n",
-    "                x(qubits[i])\n",
-    "\n",
-    "        cudaq.kernels.uccsd(qubits, thetas, electron_num, qubit_num)\n",
-    "\n",
-    "parameter_count = cudaq.kernels.uccsd_num_parameters(electron_count,qubit_count)\n",
-    "\n",
-    "# Define a function to minimize\n",
-    "def cost(theta):\n",
-    "\n",
-    "        exp_val = cudaq.observe(kernel, spin_ham, qubit_count, electron_count, theta).expectation()\n",
-    "\n",
-    "        return exp_val\n",
-    "\n",
-    "\n",
-    "exp_vals = []\n",
-    "\n",
-    "def callback(xk):\n",
-    "        exp_vals.append(cost(xk))\n",
-    "\n",
-    "# Initial variational parameters.\n",
-    "np.random.seed(42)\n",
-    "x0 = np.random.normal(0, 1, parameter_count)\n",
-    "\n",
-    "# Use the scipy optimizer to minimize the function of interest\n",
-    "start_time = timeit.default_timer()\n",
-    "result = minimize(cost, x0, method='COBYLA', callback=callback, options={'maxiter': 300})\n",
-    "end_time = timeit.default_timer()\n",
-    "\n",
-    "print('UCCSD-VQE energy =  ', result.fun)\n",
-    "print('Pyscf-CCSD energy = ', mycc.e_tot)\n",
-    "print('Total number of qubits = ', qubit_count)\n",
-    "print('Total number of parameters = ', parameter_count)\n",
-    "print('Total number of terms in the spin hamiltonian = ',spin_ham.get_term_count())\n",
-    "print('Total elapsed time (s) = ', end_time-start_time)\n",
-    "\n",
-    "plt.plot(exp_vals)\n",
-    "plt.xlabel('Epochs')\n",
-    "plt.ylabel('Energy')\n",
-    "plt.title('VQE')\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "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.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/sphinx/examples/visualization.ipynb b/docs/sphinx/examples/visualization.ipynb
new file mode 100644
index 0000000000..b5cc4c5967
--- /dev/null
+++ b/docs/sphinx/examples/visualization.ipynb
@@ -0,0 +1,394 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Visualization\n",
+    "\n",
+    "## Qubit Visualization\n",
+    "\n",
+    "What are the possible states a qubit can be in and how can we build up a visual cue to help us make sense of quantum states and their evolution?\n",
+    "\n",
+    "We know our qubit can have two distinct states: $\\ket{0}$ and $\\ket{1}$. If these were the only two states, we could represent them as two vectors on a one-dimensional line (i.e., the z-axis in the image below). We also know that qubits can be in an equal superposition of states: $\\ket{+}$ and $\\ket{-}$. In order to capture all of the states in equal superposition, we will need a 2D plane (i.e., the $xy$-plane in the image below). If you dive deeper you will learn about the existence of other states that will call for a 3D extension. \n",
+    "\n",
+    "In general, a quantum state can be written in the form $\\ket{\\psi} = \\cos(\\frac{\\theta}{2})\\ket{0}+e^{i\\varphi}\\sin(\\frac{\\theta}{2})\\ket{1}$ where $\\theta$ is a real number between $0$ and $\\pi$ and $\\varphi$ is a real value between $0$ and $2\\pi$.  For example, the minus state, $\\ket{-} = \\frac{1}{\\sqrt{2}}\\ket{0}- \\frac{1}{\\sqrt{2}}\\ket{1}$, can be rewritten as\n",
+    "$$\\ket{-}  = \\cos(\\frac{\\theta}{2})\\ket{0}+e^{i\\varphi}\\sin(\\frac{\\theta}{2})\\ket{1}\\text{ with }\\theta = \\frac{\\pi}{2}\\text{ and }\\varphi = \\pi.$$ \n",
+    "This can be visualized in the image below as a unit vector pointing in the direction of the negative $x$-axis.\n",
+    "\n",
+    "Using spherical coordinates, it is possible to depict all the possible states of a single qubit on a sphere. This is called a Bloch sphere. \n",
+    "\n",
+    "<img src=\"./images/Bloch_sphere.png\" alt=\"Bloch Sphere\" width=\"300\" height=\"300\">\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us try to showcase the functionality to render such a 3D representation with CUDA-Q. \n",
+    "First, let us define a single-qubit kernel that returns a different state each time. This kernel uses random rotations.\n",
+    "\n",
+    "Note: CUDA-Q uses the [QuTiP](https://qutip.org) library to render Bloch spheres. The following code will throw an error if QuTiP is not installed. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# install `qutip` in the current Python kernel. Skip this if `qutip` is already installed.\n",
+    "# `matplotlib` is required for all visualization tasks.\n",
+    "# Make sure to restart your kernel if you execute this!\n",
+    "# In a Jupyter notebook, go to the menu bar > Kernel > Restart Kernel.\n",
+    "# In VSCode, click on the Restart button in the Jupyter toolbar.\n",
+    "\n",
+    "# The '\\' before the '>' operator is so that the shell does not misunderstand\n",
+    "# the '>' qualifier for the bash pipe operation.\n",
+    "\n",
+    "import sys\n",
+    "\n",
+    "try:\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import qutip\n",
+    "\n",
+    "except ImportError:\n",
+    "    print(\"Tools not found, installing. Please restart your kernel after this is done.\")\n",
+    "    !{sys.executable} -m pip install qutip\\>=5 matplotlib\\>=3.5\n",
+    "    print(\"\\nNew libraries have been installed. Please restart your kernel!\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cudaq\n",
+    "import numpy as np\n",
+    "\n",
+    "## Retry the subsequent cells by setting the target to density matrix simulator.\n",
+    "# cudaq.set_target(\"density-matrix-cpu\")\n",
+    "\n",
+    "\n",
+    "@cudaq.kernel\n",
+    "def kernel(angles: np.ndarray):\n",
+    "    qubit = cudaq.qubit()\n",
+    "    rz(angles[0], qubit)\n",
+    "    rx(angles[1], qubit)\n",
+    "    rz(angles[2], qubit)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we instantiate a random number generator, so we can get random outputs. We then create 4 random single-qubit states by using `cudaq.add_to_bloch_sphere()` on the output state obtained from the random kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rng = np.random.default_rng(seed=11)\n",
+    "blochSphereList = []\n",
+    "for _ in range(4):\n",
+    "    angleList = rng.random(3) * 2 * np.pi\n",
+    "    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList))\n",
+    "    blochSphereList.append(sph)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can display the spheres with `cudaq.show()`. Show the first sphere:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cudaq.show(blochSphereList[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also show multiple Bloch spheres side by side - simply set the `nrows` and `ncols` in the call to `cudaq.show()` accordingly. Make sure to have more spaces than spheres in your list, else it will throw an error! Let us show two spheres in a row:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cudaq.show(blochSphereList[:2], nrows=1, ncols=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can show them in a column too, if we want! Simply set the `nrows = 2` and `ncols = 1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cudaq.show(blochSphereList[:2], nrows=2, ncols=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Can we show the entire list of 4 Bloch spheres we created? Absolutely!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cudaq.show(blochSphereList[:], nrows=2, ncols=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What if we had to add multiple vectors to a single Bloch sphere? CUDA-Q uses the [QuTiP](https://www.qutip.org) toolbox to construct Bloch spheres. We can then add multiple states to the same Bloch sphere by passing the sphere object as an argument to `cudaq.add_to_bloch_sphere()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qutip\n",
+    "\n",
+    "rng = np.random.default_rng(seed=47)\n",
+    "blochSphere = qutip.Bloch()\n",
+    "for _ in range(10):\n",
+    "    angleList = rng.random(3) * 2 * np.pi\n",
+    "    sph = cudaq.add_to_bloch_sphere(cudaq.get_state(kernel, angleList), blochSphere)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This created a single Bloch sphere with 10 random vectors. Let us see how it looks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "blochSphere.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Unfortunately, there is no such handy visualization for multi-qubit states. In particular, a multi-qubit state cannot be visualized as multiple Bloch spheres due to the nature of entanglement that makes quantum computing so powerful. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Kernel Visualization\n",
+    "\n",
+    "A CUDA-Q kernel can be visualized using the `cudaq.draw` API which returns a string representing the drawing of the execution path, in the specified format. ASCII (default) and LaTeX formats are supported."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@cudaq.kernel\n",
+    "def kernel_to_draw():\n",
+    "    q = cudaq.qvector(4)\n",
+    "    h(q)\n",
+    "    x.ctrl(q[0], q[1])\n",
+    "    y.ctrl([q[0], q[1]], q[2])\n",
+    "    z(q[2])\n",
+    "    \n",
+    "    swap(q[0], q[1])\n",
+    "    swap(q[0], q[3])\n",
+    "    swap(q[1], q[2])\n",
+    "\n",
+    "    r1(3.14159, q[0])\n",
+    "    tdg(q[1])\n",
+    "    s(q[2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "     ╭───╮                  ╭───────────╮       \n",
+      "q0 : ┤ h ├──●────●────╳───╳─┤ r1(3.142) ├───────\n",
+      "     ├───┤╭─┴─╮  │    │   │ ╰───────────╯╭─────╮\n",
+      "q1 : ┤ h ├┤ x ├──●────╳───┼───────╳──────┤ tdg ├\n",
+      "     ├───┤╰───╯╭─┴─╮╭───╮ │       │      ╰┬───┬╯\n",
+      "q2 : ┤ h ├─────┤ y ├┤ z ├─┼───────╳───────┤ s ├─\n",
+      "     ├───┤     ╰───╯╰───╯ │               ╰───╯ \n",
+      "q3 : ┤ h ├────────────────╳─────────────────────\n",
+      "     ╰───╯                                      \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(cudaq.draw(kernel_to_draw))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\\documentclass{minimal}\n",
+      "\\usepackage{quantikz}\n",
+      "\\begin{document}\n",
+      "\\begin{quantikz}\n",
+      "  \\lstick{$q_0$} & \\gate{H} & \\ctrl{1} & \\ctrl{2} & \\swap{1} & \\swap{3} & \\gate{R_1(3.142)} & \\qw & \\qw \\\\\n",
+      "  \\lstick{$q_1$} & \\gate{H} & \\gate{X} & \\ctrl{1} & \\targX{} & \\qw & \\swap{1} & \\gate{T^\\dag} & \\qw \\\\\n",
+      "  \\lstick{$q_2$} & \\gate{H} & \\qw & \\gate{Y} & \\gate{Z} & \\qw & \\targX{} & \\gate{S} & \\qw \\\\\n",
+      "  \\lstick{$q_3$} & \\gate{H} & \\qw & \\qw & \\qw & \\targX{} & \\qw & \\qw & \\qw \\\\\n",
+      "\\end{quantikz}\n",
+      "\\end{document}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(cudaq.draw('latex', kernel_to_draw))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Copy this output string into any LaTeX editor and export it to PDF.\n",
+    "\n",
+    "<img src=\"./images/circuit_pdf.png\" alt=\"Circuit in PDF format\" width=\"500\" \n",
+    "height=\"250\">\n",
+    "\n"
+   ]
+  }
+ ],
+ "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.12"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/sphinx/using/examples/examples.rst b/docs/sphinx/using/examples/examples.rst
index 2c35b360a3..bf00e99ddc 100644
--- a/docs/sphinx/using/examples/examples.rst
+++ b/docs/sphinx/using/examples/examples.rst
@@ -8,14 +8,15 @@ Examples that illustrate how to use CUDA-Q for application development are avail
    :maxdepth: 1
 
       Introduction <introduction.rst>
+      Building Kernels <../../examples/python/tutorials/building_kernels.ipynb>
       Quantum Operations <quantum_operations.rst>
-      Visualization <../../examples/python/tutorials/visualization.ipynb>
+      Measuring Kernels <../../examples/python/tutorials/measuring_kernels.ipynb>
+      Visualising Kernels <../../examples/python/tutorials/visualization.ipynb>
+      Executing Kernels <../../examples/python/tutorials/executing_kernels.ipynb>
       Computing Expectation Values <expectation_values.rst>
-      Multi-Control Synthesis <multi_control.rst>
       Multi-GPU Workflows <multi_gpu_workflows.rst>
-      Bernstein-Vazirani <bernstein_vazirani.rst>
-      Variational Quantum Eigensolver <vqe.rst>
-      Quantum Approximate Optimization Algorithm <qaoa.rst>
-      Simulations with cuQuantum <cuquantum.rst>
-      Noisy Simulation <noisy_simulation.rst>
+      Optimizers & Gradients  <../../examples/python/tutorials/optimizers_gradients.ipynb>
+      Noisy Simulations <../../examples/python/tutorials/noisy_simulations.ipynb>
+      Constructing Operators <../../examples/python/tutorials/operators.ipynb>
+      Performance Optimizations <../../examples/python/tutorials/performance_optimizations.ipynb>
       Using Quantum Hardware Providers <hardware_providers.rst>
diff --git a/docs/sphinx/using/tutorials.rst b/docs/sphinx/using/tutorials.rst
index ad45c8b48f..da43ef5385 100644
--- a/docs/sphinx/using/tutorials.rst
+++ b/docs/sphinx/using/tutorials.rst
@@ -6,19 +6,22 @@ Tutorials that give an in depth view of CUDA-Q and its applications in Python.
 
 .. nbgallery::
 
-    /examples/python/tutorials/afqmc.ipynb
+    /examples/python/tutorials/cost_minimization.ipynb
+    /examples/python/tutorials/bernstein_vazirani.ipynb
     /examples/python/tutorials/deutschs_algorithm.ipynb
+    /examples/python/tutorials/shors.ipynb
     /examples/python/tutorials/quantum_fourier_transform.ipynb
-    /examples/python/tutorials/cost_minimization.ipynb
+    /examples/python/tutorials/quantum_teleportation.ipynb
+    /examples/python/tutorials/quantum_volume.ipynb
     /examples/python/tutorials/vqe.ipynb
+    /examples/python/tutorials/vqe_advanced.ipynb
+    /examples/python/tutorials/afqmc.ipynb
     /examples/python/tutorials/qaoa.ipynb
+    /examples/python/tutorials/digitized_counterdiabatic_qaoa.ipynb
+    /examples/python/tutorials/divisive_clustering_coresets.ipynb
     /examples/python/tutorials/hadamard_test.ipynb
     /examples/python/tutorials/hybrid_qnns.ipynb
-    /examples/python/tutorials/maximum_vertex_weight_clique.ipynb
-    /examples/python/tutorials/noisy_simulations.ipynb
+    /examples/python/tutorials/krylov.ipynb
+    /examples/python/tutorials/trotter.ipynb
+    /examples/python/tutorials/unitary_compilation_diffusion_models.ipynb
     /examples/python/tutorials/readout_error_mitigation.ipynb
-    /examples/python/tutorials/vqe_water_active_space.ipynb
-    /examples/python/tutorials/Divisive_clustering.ipynb
-    /examples/python/tutorials/H2-MRQKS.ipynb
-    /examples/python/tutorials/Shors.ipynb
-    /examples/python/tutorials/unitary_compilation.ipynb