--- a
+++ b/Code/All PennyLane QML Demos/14 Time Series 55% RM1 kkawchak.ipynb
@@ -0,0 +1,1772 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 57,
+      "metadata": {
+        "id": "0GKevPuPa5L_"
+      },
+      "outputs": [],
+      "source": [
+        "# This cell is added by sphinx-gallery\n",
+        "# It can be customized to whatever you like\n",
+        "%matplotlib inline\n",
+        "# !pip install pennylane\n",
+        "# !pip install covalent"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2OVQzmEGa5MA"
+      },
+      "source": [
+        "Quantum detection of time series anomalies\n",
+        "==========================================\n",
+        "\n",
+        "::: {.meta}\n",
+        ":property=\\\"og:description\\\": Learn how to quantumly detect anomalous\n",
+        "behaviour in time series data with the help of Covalent.\n",
+        ":property=\\\"og:image\\\":\n",
+        "<https://pennylane.ai/qml/_images/thumbnail_tutorial_univariate_qvr.jpg>\n",
+        ":::\n",
+        "\n",
+        "::: {.related}\n",
+        "tutorial\\_qaoa\\_intro Intro to QAOA\n",
+        ":::\n",
+        "\n",
+        "*Authors: Jack Stephen Baker, Santosh Kumar Radha --- Posted: 7 February\n",
+        "2023.*\n",
+        "\n",
+        "Systems producing observable characteristics which evolve with time are\n",
+        "almost everywhere we look. The temperature changes as day turns to\n",
+        "night, stock markets fluctuate and the bacteria colony living in the\n",
+        "coffee cup to your right, which you *promised* you would clean\n",
+        "yesterday, is slowly growing (seriously, clean it). In many situations,\n",
+        "it is important to know when these systems start behaving abnormally.\n",
+        "For example, if the pressure inside a nuclear fission reactor starts\n",
+        "violently fluctuating, you may wish to be alerted of that. The task of\n",
+        "identifying such temporally abnormal behaviour is known as time series\n",
+        "anomaly detection and is well known in machine learning circles.\n",
+        "\n",
+        "In this tutorial, we take a stab at time series anomaly detection using\n",
+        "the *Quantum Variational Rewinding* algorithm, or QVR, proposed by\n",
+        "[Baker, Horowitz, Radha et. al (2022)](https://arxiv.org/abs/2210.16438)\n",
+        "--- a quantum machine learning algorithm for gate model quantum\n",
+        "computers. QVR leverages the power of unitary time evolution/devolution\n",
+        "operators to learn a model of *normal* behaviour for time series data.\n",
+        "Given a new (i.e., unseen in training) time series, the normal model\n",
+        "produces a value that, beyond a threshold, defines anomalous behaviour.\n",
+        "In this tutorial, we'll be showing you how all of this works, combining\n",
+        "elements from [Covalent](https://www.covalent.xyz/),\n",
+        "[Pennylane](https://pennylane.ai/) and [PyTorch](https://pytorch.org/).\n",
+        "\n",
+        "Before getting into the technical details of the algorithm, let\\'s get a\n",
+        "high-level overview with the help of the cartoon below.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fAi-GyNpa5MB"
+      },
+      "source": [
+        "![](../demonstrations/univariate_qvr/cartoon_pennylane.png){.align-center\n",
+        "width=\"70.0%\"}\n",
+        "\n",
+        "Going left-to-right, a time series is sampled at three points in time,\n",
+        "corresponding to different stages in the life cycle of a butterfly: a\n",
+        "catepillar, a chrysalis and a butterfly. This information is then\n",
+        "encoded into quantum states and passed to a time machine which time\n",
+        "devolves the states as generated by a learnt Hamiltonian operator (in\n",
+        "practice, there is a distribution of such operators). After the devolved\n",
+        "state is measured, the time series is recognized as normal if the\n",
+        "average measurement is smaller than a given threshold and anomalous if\n",
+        "the threshold is exceeded. In the first case, the time series is\n",
+        "considered rewindable, correctly recovering the initial condition for\n",
+        "the life cycle of a butterfly: eggs on a leaf. In the second case, the\n",
+        "output is unrecognizable.\n",
+        "\n",
+        "This will all make more sense once we delve into the math a little.\n",
+        "Let\\'s do it!\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "q6D1SN3Ga5MB"
+      },
+      "source": [
+        "Background\n",
+        "==========\n",
+        "\n",
+        "To begin, let's quickly recount the data that QVR handles: time series.\n",
+        "A general time series $\\boldsymbol{y}$ can be described as a sequence of\n",
+        "$p$-many observations of a process/system arranged in chronological\n",
+        "order, where $p$ is a positive integer:\n",
+        "\n",
+        "$$\\boldsymbol{y} := (\\boldsymbol{y}_t: t \\in T), \\quad T := (t_l: l \\in \\mathbb{Z}^{+}_{\\leq p}).$$\n",
+        "\n",
+        "In the simple and didactic case treated in this tutorial,\n",
+        "$\\boldsymbol{y}$ is univariate (i.e, is a one-dimensional time series),\n",
+        "so bold-face for $\\boldsymbol{y}$ is dropped from this point onwards.\n",
+        "Also, we take $y_t \\in \\mathbb{R}$ and $t_l \\in \\mathbb{R}_{>0}$.\n",
+        "\n",
+        "The goal of QVR and many other (classical) machine learning algorithms\n",
+        "for time series anomaly detection is to determine a suitable *anomaly\n",
+        "score* function $a_{X}$, where $X$ is a training dataset of *normal*\n",
+        "time series instances $x \\in X$ ($x$ is defined analogously to $y$ in\n",
+        "the above), from which the anomaly score function was learnt. When\n",
+        "passed a general time series $y$, this function produces a real number:\n",
+        "$a_X(y) \\in \\mathbb{R}$. The goal is to have $a_X(x) \\approx 0$, for all\n",
+        "$x \\in X$. Then, for an unseen time series $y$ and a threshold\n",
+        "$\\zeta \\in \\mathbb{R}$, the series is said to be anomalous should\n",
+        "$a_X(y) > \\zeta,$ and normal otherwise. We show a strategy for setting\n",
+        "$\\zeta$ later in this tutorial.\n",
+        "\n",
+        "The first step for doing all of this *quantumly* is to generate a\n",
+        "sequence $\\mathcal{S} := (|x_{t} \\rangle: t \\in T)$ of $n$-qubit quantum\n",
+        "states corresponding to a classical time series instance in the training\n",
+        "set. Now, we suppose that each $|x_t \\rangle$ is a quantum state evolved\n",
+        "to a time $t$, as generated by an *unknown embedding Hamiltonian* $H_E$.\n",
+        "That is, each element of $\\mathcal{S}$ is defined by\n",
+        "$|x_t \\rangle = e^{-iH_E(x_t)}|0\\rangle^{\\otimes n} = U(x_t)|0\\rangle^{\\otimes n}$\n",
+        "for an embedding unitary operator $U(x_t)$ implementing a quantum\n",
+        "feature map (see the [Pennylane embedding\n",
+        "templates](https://docs.pennylane.ai/en/stable/introduction/templates.html#embedding-templates)\n",
+        "for efficient quantum circuits for doing so). Next, we operate on each\n",
+        "$|x_t\\rangle$ with a parameterized\n",
+        "$e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}$ operator to prepare\n",
+        "the states\n",
+        "\n",
+        "$$|x_t, \\boldsymbol{\\alpha}, \\boldsymbol{\\gamma}\\rangle := e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}|x_t\\rangle,$$\n",
+        "\n",
+        "where we write $e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}$ as\n",
+        "an eigendecomposition\n",
+        "\n",
+        "$$V_t(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma}) := W^{\\dagger}(\\boldsymbol{\\alpha})D(\\boldsymbol{\\gamma}, t)W(\\boldsymbol{\\alpha}) = e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}.$$\n",
+        "\n",
+        "Here, the unitary matrix of eigenvectors $W(\\boldsymbol{\\alpha})$ is\n",
+        "parametrized by $\\boldsymbol{\\alpha}$ and the unitary diagonalization\n",
+        "$D(\\boldsymbol{\\gamma}, t)$ is parametrized by $\\boldsymbol{\\gamma}.$\n",
+        "Both can be implemented efficiently using parameterized quantum\n",
+        "circuits. The above equality with\n",
+        "$e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}$ is a consequence of\n",
+        "Stone's theorem for strongly continuous one-parameter unitary groups.\n",
+        "\n",
+        "We now ask the question: *What condition is required for*\n",
+        "$|x_t, \\boldsymbol{\\alpha}, \\boldsymbol{\\gamma} \\rangle = |0 \\rangle^{\\otimes n}$\n",
+        "*for all time?* To answer this, we impose\n",
+        "$P(|0\\rangle^{\\otimes n}) = |\\langle 0|^{\\otimes n}|x_t, \\boldsymbol{\\alpha}, \\boldsymbol{\\gamma} \\rangle|^2 = 1.$\n",
+        "Playing with the algebra a little, we find that the following condition\n",
+        "must be satisfied for all $t$:\n",
+        "\n",
+        "$$\\langle 0|^{\\otimes n}e^{-iH(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t}e^{-iH_E(x_t)}|0\\rangle^{\\otimes n} = 1 \\iff  H(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})t = -H_E(x_t).$$\n",
+        "\n",
+        "In other words, for the above to be true, the parameterized unitary\n",
+        "operator $V_t(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma})$ should be able\n",
+        "to reverse or *rewind* $|x_t\\rangle$ to its initial state\n",
+        "$|0\\rangle^{\\otimes n}$ before the embedding unitary operator $U(x_t)$\n",
+        "was applied.\n",
+        "\n",
+        "We are nearly there! Because it is reasonable to expect that a single\n",
+        "Hamiltonian will not be able to successfully rewind every $x \\in X$ (in\n",
+        "fact, this is impossible to do if each $x$ is unique, which is usually\n",
+        "true), we consider the average effect of many Hamiltonians generated by\n",
+        "drawing $\\boldsymbol{\\gamma}$ from a normal distribution\n",
+        "$\\mathcal{N}(\\mu, \\sigma)$ with mean $\\mu$ and standard deviation\n",
+        "$\\sigma$:\n",
+        "\n",
+        "$$F(\\boldsymbol{\\phi}, x_t) := \\mathop{\\mathbb{E}_{\\boldsymbol{\\gamma} \\sim \\mathcal{N}(\\mu, \\sigma)}}\\left[\\langle 0|^{\\otimes n} |x_t, \\boldsymbol{\\alpha}, \\boldsymbol{\\gamma}\\rangle  \\right], \\quad \\boldsymbol{\\phi} = [\\boldsymbol{\\alpha}, \\mu, \\sigma].$$\n",
+        "\n",
+        "The goal is for the function $F$ defined above to be as close to $1$ as\n",
+        "possible, for all $x \\in X$ and $t \\in T.$ With this in mind, we can\n",
+        "define the loss function to minimize as the mean square error\n",
+        "regularized by a penalty function $P_{\\tau}(\\sigma)$ with a single\n",
+        "hyperparameter $\\tau$:\n",
+        "\n",
+        "$$\\mathcal{L(\\boldsymbol{\\phi})} = \\frac{1}{2|X||T|}\\sum_{x \\in X} \\sum_{t \\in T}[1 - F(\\boldsymbol{\\phi}, x_t)]^2 + P_{\\tau}(\\sigma).$$\n",
+        "\n",
+        "We will show the exact form of $P_{\\tau}(\\sigma)$ later. The general\n",
+        "purpose of the penalty function is to penalize large values of $\\sigma$\n",
+        "(justification for this is given in the Supplement of). After\n",
+        "approximately finding the argument $\\boldsymbol{\\phi}^{\\star}$ that\n",
+        "minimizes the loss function (found using a classical optimization\n",
+        "routine), we finally arrive at a definition for our anomaly score\n",
+        "function $a_X(y)$\n",
+        "\n",
+        "$$a_X(y) = \\frac{1}{|T|}\\sum_{t \\in T}[1 - F(\\boldsymbol{\\phi}^{\\star}, y_t)]^2.$$\n",
+        "\n",
+        "It may now be apparent that we have implemented a clustering algorithm!\n",
+        "That is, our model $F$ was trained such that normal time series\n",
+        "$x \\in X$ produce $F(\\boldsymbol{\\phi}^{\\star}, x_t)$ clustered about a\n",
+        "center at $1$. Given a new time series $y$, should\n",
+        "$F(\\boldsymbol{\\phi}^{\\star}, y_t)$ venture far from the normal center\n",
+        "at $1$, we are observing anomalous behaviour!\n",
+        "\n",
+        "Take the time now to have another look at the cartoon at the start of\n",
+        "this tutorial. Hopefully things should start making sense now.\n",
+        "\n",
+        "Now with our algorithm defined, let's stitch this all together: enter\n",
+        "[Covalent](https://www.covalent.xyz/).\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0Ecv2jQ7a5MB"
+      },
+      "source": [
+        "Covalent: heterogeneous workflow orchestration\n",
+        "==============================================\n",
+        "\n",
+        "Presently, many QML algorithms are *heterogeneous* in nature. This means\n",
+        "that they require computational resources from both classical and\n",
+        "quantum computing. Covalent is a tool that can be used to manage their\n",
+        "interaction by sending different tasks to different computational\n",
+        "resources and stitching them together as a workflow. While you will be\n",
+        "introduced to other concepts in Covalent throughout this tutorial, we\n",
+        "define two key components to begin with.\n",
+        "\n",
+        "1.  **Electrons**. Decorate regular Python functions with `@ct.electron`\n",
+        "    to desginate a *task*. These are the atoms of a computation.\n",
+        "\n",
+        "2.  **Lattices**. Decorate a regular Python function with `@ct.lattice`\n",
+        "    to designate a *workflow*. These contain electrons stitched together\n",
+        "    to do something useful.\n",
+        "\n",
+        "    Different electrons can be run remotely on different hardware and\n",
+        "    multiple computational paridigms (classical, quantum, etc.: see the\n",
+        "    [Covalent\n",
+        "    executors](https://covalent.readthedocs.io/en/stable/plugins.html)).\n",
+        "    In this tutorial, however, to keep things simple, tasks are run on a\n",
+        "    local Dask cluster, which provides (among other things)\n",
+        "    auto-parallelization.\n",
+        "\n",
+        "![\\| A schematic demonstrating the different platforms Covalent can\n",
+        "interact\n",
+        "with.](../demonstrations/univariate_qvr/covalent_platform.png){.align-center\n",
+        "width=\"70.0%\"}\n",
+        "\n",
+        "Now is a good time to import Covalent and launch the Covalent server!\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 58,
+      "metadata": {
+        "id": "HxukqHJ4a5MC"
+      },
+      "outputs": [],
+      "source": [
+        "import covalent as ct\n",
+        "import os\n",
+        "import time\n",
+        "\n",
+        "# Set up Covalent server\n",
+        "os.environ[\"COVALENT_SERVER_IFACE_ANY\"] = \"1\"\n",
+        "os.system(\"covalent start\")\n",
+        "# If you run into any out-of-memory issues with Dask when running this notebook,\n",
+        "# Try reducing the number of workers and making a specific memory request. I.e.:\n",
+        "# os.system(\"covalent start -m \"2GiB\" -n 2\")\n",
+        "# try covalent –help for more info\n",
+        "time.sleep(2)  # give the Dask cluster some time to launch"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hWn7V9Cba5MC"
+      },
+      "source": [
+        "Generating univariate synthetic time series\n",
+        "===========================================\n",
+        "\n",
+        "In this tutorial, we shall deal with a simple and didactic example.\n",
+        "Normal time series instances are chosen to be noisy low-amplitude\n",
+        "signals normally distributed about the origin. In our case,\n",
+        "$x_t \\sim \\mathcal{N}(0, 0.1)$. Series we deem to be anomalous are the\n",
+        "same but with randomly inserted spikes with random durations and\n",
+        "amplitudes.\n",
+        "\n",
+        "Let's make a `@ct.electron` to generate each of these synthetic time\n",
+        "series sets. For this, we\\'ll need to import Torch. We\\'ll also set the\n",
+        "default tensor type and pick a random seed for the whole tutorial for\n",
+        "reproducibility.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 59,
+      "metadata": {
+        "id": "EMKwGXA8a5MC"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "\n",
+        "# Seed Torch for reproducibility and set default tensor type\n",
+        "GLOBAL_SEED = 1989\n",
+        "torch.manual_seed(GLOBAL_SEED)\n",
+        "torch.set_default_tensor_type(torch.DoubleTensor)\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def generate_normal_time_series_set(\n",
+        "    p: int, num_series: int, noise_amp: float, t_init: float, t_end: float, seed: int = GLOBAL_SEED\n",
+        ") -> tuple:\n",
+        "    \"\"\"Generate a normal time series data set where each of the p elements\n",
+        "    is drawn from a normal distribution x_t ~ N(0, noise_amp).\n",
+        "    \"\"\"\n",
+        "    torch.manual_seed(seed)\n",
+        "    X = torch.normal(0, noise_amp, (num_series, p))\n",
+        "    T = torch.linspace(t_init, t_end, p)\n",
+        "    return X, T\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def generate_anomalous_time_series_set(\n",
+        "    p: int,\n",
+        "    num_series: int,\n",
+        "    noise_amp: float,\n",
+        "    spike_amp: float,\n",
+        "    max_duration: int,\n",
+        "    t_init: float,\n",
+        "    t_end: float,\n",
+        "    seed: int = GLOBAL_SEED,\n",
+        ") -> tuple:\n",
+        "    \"\"\"Generate an anomalous time series data set where the p elements of each sequence are\n",
+        "    from a normal distribution x_t ~ N(0, noise_amp). Then,\n",
+        "    anomalous spikes of random amplitudes and durations are inserted.\n",
+        "    \"\"\"\n",
+        "    torch.manual_seed(seed)\n",
+        "    Y = torch.normal(0, noise_amp, (num_series, p))\n",
+        "    for y in Y:\n",
+        "        # 5–10 spikes allowed\n",
+        "        spike_num = torch.randint(low=5, high=10, size=())\n",
+        "        durations = torch.randint(low=1, high=max_duration, size=(spike_num,))\n",
+        "        spike_start_idxs = torch.randperm(p - max_duration)[:spike_num]\n",
+        "        for start_idx, duration in zip(spike_start_idxs, durations):\n",
+        "            y[start_idx : start_idx + duration] += torch.normal(0.0, spike_amp, (duration,))\n",
+        "    T = torch.linspace(t_init, t_end, p)\n",
+        "    return Y, T"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ag9HApCFa5MC"
+      },
+      "source": [
+        "Let\\'s do a quick sanity check and plot a couple of these series.\n",
+        "Despite the above function\\'s `@ct.electron` decorators, these can still\n",
+        "be used as normal Python functions without using the Covalent server.\n",
+        "This is useful for quick checks like this:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 60,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "JMcxr3jga5MC",
+        "outputId": "c509c51b-3401-48d0-a852-b6ff15c718fe"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "X_norm, T_norm = generate_normal_time_series_set(25, 25, 0.1, 0.1, 2 * torch.pi)\n",
+        "Y_anom, T_anom = generate_anomalous_time_series_set(25, 25, 0.1, 0.4, 5, 0, 2 * torch.pi)\n",
+        "\n",
+        "plt.figure()\n",
+        "plt.plot(T_norm, X_norm[0], label=\"Normal\")\n",
+        "plt.plot(T_anom, Y_anom[1], label=\"Anomalous\")\n",
+        "plt.ylabel(\"$y(t)$\")\n",
+        "plt.xlabel(\"t\")\n",
+        "plt.grid()\n",
+        "leg = plt.legend()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "y_u4k0J1a5MC"
+      },
+      "source": [
+        "Taking a look at the above, the generated series are what we wanted. We\n",
+        "have a simple human-parsable notion of what it is for a time series to\n",
+        "be anomalous (big spikes). Of course, we don\\'t need a complicated\n",
+        "algorithm to be able to detect such anomalies but this is just a\n",
+        "didactic example remember!\n",
+        "\n",
+        "Like many machine learning algorithms, training is done in mini-batches.\n",
+        "Examining the form of the loss function\n",
+        "$\\mathcal{L}(\\boldsymbol{\\phi})$, we can see that time series are\n",
+        "atomized. In other words, each term in the mean square error is for a\n",
+        "given $x_t$ and not measured against the entire series $x$. This allows\n",
+        "us to break down the training set $X$ into time-series-independent\n",
+        "chunks. Here's an electron to do that:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 61,
+      "metadata": {
+        "id": "uAho8PSLa5MC"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def make_atomized_training_set(X: torch.Tensor, T: torch.Tensor) -> list:\n",
+        "    \"\"\"Convert input time series data provided in a two-dimensional tensor format\n",
+        "    to atomized tuple chunks: (xt, t).\n",
+        "    \"\"\"\n",
+        "    X_flat = torch.flatten(X)\n",
+        "    T_flat = T.repeat(X.size()[0])\n",
+        "    atomized = [(xt, t) for xt, t in zip(X_flat, T_flat)]\n",
+        "    return atomized"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yaG5czXla5MD"
+      },
+      "source": [
+        "We now wish to pass this to a cycled `torch.utils.data.DataLoader`.\n",
+        "However, this object is not\n",
+        "[pickleable](https://docs.python.org/3/library/pickle.html#:~:text=%E2%80%9CPickling%E2%80%9D%20is%20the%20process%20whereby,back%20into%20an%20object%20hierarchy.),\n",
+        "which is a requirement of electrons in Covalent. We therefore use the\n",
+        "below helper class to create a pickleable version.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 62,
+      "metadata": {
+        "id": "aN270Z0pa5MD"
+      },
+      "outputs": [],
+      "source": [
+        "from collections.abc import Iterator\n",
+        "\n",
+        "\n",
+        "class DataGetter:\n",
+        "    \"\"\"A pickleable mock-up of a Python iterator on a torch.utils.Dataloader.\n",
+        "    Provide a dataset X and the resulting object O will allow you to use next(O).\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def __init__(self, X: torch.Tensor, batch_size: int, seed: int = GLOBAL_SEED) -> None:\n",
+        "        \"\"\"Calls the _init_data method on intialization of a DataGetter object.\"\"\"\n",
+        "        torch.manual_seed(seed)\n",
+        "        self.X = X\n",
+        "        self.batch_size = batch_size\n",
+        "        self.data = []\n",
+        "        self._init_data(\n",
+        "            iter(torch.utils.data.DataLoader(self.X, batch_size=self.batch_size, shuffle=True))\n",
+        "        )\n",
+        "\n",
+        "    def _init_data(self, iterator: Iterator) -> None:\n",
+        "        \"\"\"Load all of the iterator into a list.\"\"\"\n",
+        "        x = next(iterator, None)\n",
+        "        while x is not None:\n",
+        "            self.data.append(x)\n",
+        "            x = next(iterator, None)\n",
+        "\n",
+        "    def __next__(self) -> tuple:\n",
+        "        \"\"\"Analogous behaviour to the native Python next() but calling the\n",
+        "        .pop() of the data attribute.\n",
+        "        \"\"\"\n",
+        "        try:\n",
+        "            return self.data.pop()\n",
+        "        except IndexError:  # Caught when the data set runs out of elements\n",
+        "            self._init_data(\n",
+        "                iter(torch.utils.data.DataLoader(self.X, batch_size=self.batch_size, shuffle=True))\n",
+        "            )\n",
+        "            return self.data.pop()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tP_VGMbLa5MD"
+      },
+      "source": [
+        "We call an instance of the above in an electron\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 63,
+      "metadata": {
+        "id": "ORHpMJ-qa5MD"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def get_training_cycler(Xtr: torch.Tensor, batch_size: int, seed: int = GLOBAL_SEED) -> DataGetter:\n",
+        "    \"\"\"Get an instance of the DataGetter class defined above, which behaves analogously to\n",
+        "    next(iterator) but is pickleable.\n",
+        "    \"\"\"\n",
+        "    return DataGetter(Xtr, batch_size, seed)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c67taJ9ba5MD"
+      },
+      "source": [
+        "We now have the means to create synthetic data and cycle through a\n",
+        "training set. Next, we need to build our loss function\n",
+        "$\\mathcal{L}(\\boldsymbol{\\phi})$ from electrons with the help of\n",
+        "`PennyLane`.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hov7fVBZa5MD"
+      },
+      "source": [
+        "Building the loss function\n",
+        "==========================\n",
+        "\n",
+        "Core to building the loss function is the quantum circuit implementing\n",
+        "$V_t(\\boldsymbol{\\alpha}, \\boldsymbol{\\gamma}) := W^{\\dagger}(\\boldsymbol{\\alpha})D(\\boldsymbol{\\gamma}, t)W(\\boldsymbol{\\alpha})$.\n",
+        "While there are existing templates in `PennyLane` for implementing\n",
+        "$W(\\boldsymbol{\\alpha})$, we use a custom circuit to implement\n",
+        "$D(\\boldsymbol{\\gamma}, t)$. Following the approach taken in (also\n",
+        "explained in and the appendix of), we create the electron:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 64,
+      "metadata": {
+        "id": "PtRU27Jca5MD"
+      },
+      "outputs": [],
+      "source": [
+        "import pennylane as qml\n",
+        "from itertools import combinations\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def D(gamma: torch.Tensor, n_qubits: int, k: int = None, get_probs: bool = False) -> None:\n",
+        "    \"\"\"Generates an n_qubit quantum circuit according to a k-local Walsh operator\n",
+        "    expansion. Here, k-local means that 1 <= k <= n of the n qubits can interact.\n",
+        "    See <https://doi.org/10.1088/1367-2630/16/3/033040> for more\n",
+        "    details. Optionally return probabilities of bit strings.\n",
+        "    \"\"\"\n",
+        "    if k is None:\n",
+        "        k = n_qubits\n",
+        "    cnt = 0\n",
+        "    for i in range(1, k + 1):\n",
+        "        for comb in combinations(range(n_qubits), i):\n",
+        "            if len(comb) == 1:\n",
+        "                qml.RZ(gamma[cnt], wires=[comb[0]])\n",
+        "                cnt += 1\n",
+        "            elif len(comb) > 1:\n",
+        "                cnots = [comb[i : i + 2] for i in range(len(comb) - 1)]\n",
+        "                for j in cnots:\n",
+        "                    qml.CNOT(wires=j)\n",
+        "                qml.RZ(gamma[cnt], wires=[comb[-1]])\n",
+        "                cnt += 1\n",
+        "                for j in cnots[::-1]:\n",
+        "                    qml.CNOT(wires=j)\n",
+        "    if get_probs:\n",
+        "        return qml.probs(wires=range(n_qubits))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tkaI_FJra5MD"
+      },
+      "source": [
+        "While the above may seem a little complicated, since we only use a\n",
+        "single qubit in this tutorial, the resulting circuit is merely a single\n",
+        "$R_z(\\theta)$ gate.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 65,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 237
+        },
+        "id": "uUbcEi6Wa5MD",
+        "outputId": "2fb6ff07-8cbf-46b5-d4db-89e27f7ed1d5"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 400x200 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "n_qubits = 2\n",
+        "dev = qml.device(\"default.qubit\", wires=n_qubits, shots=None)\n",
+        "D_one_qubit = qml.qnode(dev)(D)\n",
+        "_ = qml.draw_mpl(D_one_qubit, decimals=2)(torch.tensor([1, 0]), 1, 1, True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IDWWmn_7a5MD"
+      },
+      "source": [
+        "You may find the general function for $D$\\` useful in case you want to\n",
+        "experiment with more qubits and your own (possibly multi-dimensional)\n",
+        "data after this tutorial.\n",
+        "\n",
+        "Next, we define a circuit to calculate the probability of certain bit\n",
+        "strings being measured in the computational basis. In our simple\n",
+        "example, we work only with one qubit and use the `default.qubit` local\n",
+        "quantum circuit simulator.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 66,
+      "metadata": {
+        "id": "IbWRykxxa5MD"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "@qml.qnode(dev, interface=\"torch\", diff_method=\"backprop\")\n",
+        "def get_probs(\n",
+        "    xt: torch.Tensor,\n",
+        "    t: float,\n",
+        "    alpha: torch.Tensor,\n",
+        "    gamma: torch.Tensor,\n",
+        "    k: int,\n",
+        "    U: callable,\n",
+        "    W: callable,\n",
+        "    D: callable,\n",
+        "    n_qubits: int,\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Measure the probabilities for measuring each bitstring after applying a\n",
+        "    circuit of the form W†DWU to the |0⟩^(⊗n) state. This\n",
+        "    function is defined for individual sequence elements xt.\n",
+        "    \"\"\"\n",
+        "    U(xt, wires=range(n_qubits))\n",
+        "    W(alpha, wires=range(n_qubits))\n",
+        "    D(gamma * t, n_qubits, k)\n",
+        "    qml.adjoint(W)(alpha, wires=range(n_qubits))\n",
+        "    return qml.probs(range(n_qubits))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8UEO-z-Qa5MD"
+      },
+      "source": [
+        "To take the projector $|0\\rangle^{\\otimes n} \\langle 0 |^{\\otimes n}$,\n",
+        "we consider only the probability of measuring the bit string of all\n",
+        "zeroes, which is the 0th element of the probabilities (bit strings are\n",
+        "returned in lexicographic order).\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 67,
+      "metadata": {
+        "id": "1u3xoE3Sa5MD"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def get_callable_projector_func(\n",
+        "    k: int, U: callable, W: callable, D: callable, n_qubits: int, probs_func: callable\n",
+        ") -> callable:\n",
+        "    \"\"\"Using get_probs() above, take only the probability of measuring the\n",
+        "    bitstring of all zeroes (i.e, take the projector\n",
+        "    |0⟩^(⊗n)⟨0|^(⊗n)) on the time devolved state.\n",
+        "    \"\"\"\n",
+        "    callable_proj = lambda xt, t, alpha, gamma: probs_func(\n",
+        "        xt, t, alpha, gamma, k, U, W, D, n_qubits\n",
+        "    )[0]\n",
+        "    return callable_proj"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7CASnQNva5MD"
+      },
+      "source": [
+        "We now have the necessary ingredients to build\n",
+        "$F(\\boldsymbol{\\phi}, x_t)$.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 68,
+      "metadata": {
+        "id": "Un_xjqcxa5MD"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def F(\n",
+        "    callable_proj: callable,\n",
+        "    xt: torch.Tensor,\n",
+        "    t: float,\n",
+        "    alpha: torch.Tensor,\n",
+        "    mu: torch.Tensor,\n",
+        "    sigma: torch.Tensor,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Take the classical expecation value of of the projector on zero sampling\n",
+        "    the parameters of D from normal distributions. The expecation value is estimated\n",
+        "    with an average over n_samples.\n",
+        "    \"\"\"\n",
+        "    # length of gamma should not exceed 2^n - 1\n",
+        "    gammas = sigma.abs() * torch.randn((n_samples, gamma_length)) + mu\n",
+        "    expectation = torch.empty(n_samples)\n",
+        "    for i, gamma in enumerate(gammas):\n",
+        "        expectation[i] = callable_proj(xt, t, alpha, gamma)\n",
+        "    return expectation.mean()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KkaRe8d9a5MD"
+      },
+      "source": [
+        "We now return to the matter of the penalty function $P_{\\tau}$. We\n",
+        "choose\n",
+        "\n",
+        "$$P_{\\tau}(\\sigma) := \\frac{1}{\\pi} \\arctan(2 \\pi \\tau |\\sigma|).$$\n",
+        "\n",
+        "As an electron, we have\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 69,
+      "metadata": {
+        "id": "MijWXiBLa5ME"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def callable_arctan_penalty(tau: float) -> callable:\n",
+        "    \"\"\"Create a callable arctan function with a single hyperparameter\n",
+        "    tau to penalize large entries of sigma.\n",
+        "    \"\"\"\n",
+        "    prefac = 1 / (torch.pi)\n",
+        "    callable_pen = lambda sigma: prefac * torch.arctan(2 * torch.pi * tau * sigma.abs()).mean()\n",
+        "    return callable_pen"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Mrh5wkIRa5ME"
+      },
+      "source": [
+        "The above is a sigmoidal function chosen because it comes with the\n",
+        "useful property of being bounded. The prefactor of $1/\\pi$ is chosen\n",
+        "such that the final loss $\\mathcal{L}(\\boldsymbol{\\phi})$ is defined in\n",
+        "the range (0, 1), as defined in the below electron.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 70,
+      "metadata": {
+        "id": "veCMIMuwa5ME"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def get_loss(\n",
+        "    callable_proj: callable,\n",
+        "    batch: torch.Tensor,\n",
+        "    alpha: torch.Tensor,\n",
+        "    mu: torch.Tensor,\n",
+        "    sigma: torch.Tensor,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        "    callable_penalty: callable,\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Evaluate the loss function ℒ, defined in the background section\n",
+        "    for a certain set of parameters.\n",
+        "    \"\"\"\n",
+        "    X_batch, T_batch = batch\n",
+        "    loss = torch.empty(X_batch.size()[0])\n",
+        "    for i in range(X_batch.size()[0]):\n",
+        "        # unsqueeze required for tensor to have the correct dimension for PennyLane templates\n",
+        "        loss[i] = (\n",
+        "            1\n",
+        "            - F(\n",
+        "                callable_proj,\n",
+        "                X_batch[i].unsqueeze(0),\n",
+        "                T_batch[i].unsqueeze(0),\n",
+        "                alpha,\n",
+        "                mu,\n",
+        "                sigma,\n",
+        "                gamma_length,\n",
+        "                n_samples,\n",
+        "            )\n",
+        "        ).square()\n",
+        "    return 0.5 * loss.mean() + callable_penalty(sigma)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZxOb7d5ga5ME"
+      },
+      "source": [
+        "Training the normal model\n",
+        "=========================\n",
+        "\n",
+        "Now equipped with a loss function, we need to minimize it with a\n",
+        "classical optimization routine. To start this optimization, however, we\n",
+        "need some initial parameters. We can generate them with the below\n",
+        "electron.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 71,
+      "metadata": {
+        "id": "ZiirtuMva5ME"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def get_initial_parameters(\n",
+        "    W: callable, W_layers: int, n_qubits: int, seed: int = GLOBAL_SEED\n",
+        ") -> dict:\n",
+        "    \"\"\"Randomly generate initial parameters. We need initial parameters for the\n",
+        "    variational circuit ansatz implementing W(alpha) and the standard deviation\n",
+        "    and mean (sigma and mu) for the normal distribution we sample gamma from.\n",
+        "    \"\"\"\n",
+        "    torch.manual_seed(seed)\n",
+        "    init_alpha = torch.rand(W.shape(W_layers, n_qubits))\n",
+        "    init_mu = torch.rand(1)\n",
+        "    # Best to start sigma small and expand if needed\n",
+        "    init_sigma = torch.rand(1)\n",
+        "    init_params = {\n",
+        "        \"alpha\": (2 * torch.pi * init_alpha).clone().detach().requires_grad_(True),\n",
+        "        \"mu\": (2 * torch.pi * init_mu).clone().detach().requires_grad_(True),\n",
+        "        \"sigma\": (0.1 * init_sigma + 0.05).clone().detach().requires_grad_(True),\n",
+        "    }\n",
+        "    return init_params"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wfYxh6Fja5ME"
+      },
+      "source": [
+        "Using the `PyTorch` interface to `PennyLane`, we define our final\n",
+        "electron before running the training workflow.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 72,
+      "metadata": {
+        "id": "zt2IVHlWa5ME"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def train_model_gradients(\n",
+        "    lr: float,\n",
+        "    init_params: dict,\n",
+        "    pytorch_optimizer: callable,\n",
+        "    cycler: DataGetter,\n",
+        "    n_samples: int,\n",
+        "    callable_penalty: callable,\n",
+        "    batch_iterations: int,\n",
+        "    callable_proj: callable,\n",
+        "    gamma_length: int,\n",
+        "    seed=GLOBAL_SEED,\n",
+        "    print_intermediate=False,\n",
+        ") -> dict:\n",
+        "    \"\"\"Train the QVR model (minimize the loss function) with respect to the\n",
+        "    variational parameters using gradient-based training. You need to pass a\n",
+        "    PyTorch optimizer and a learning rate (lr).\n",
+        "    \"\"\"\n",
+        "    torch.manual_seed(seed)\n",
+        "    opt = pytorch_optimizer(init_params.values(), lr=lr)\n",
+        "    alpha = init_params[\"alpha\"]\n",
+        "    mu = init_params[\"mu\"]\n",
+        "    sigma = init_params[\"sigma\"]\n",
+        "\n",
+        "    def closure():\n",
+        "        opt.zero_grad()\n",
+        "        loss = get_loss(\n",
+        "            callable_proj, next(cycler), alpha, mu, sigma, gamma_length, n_samples, callable_penalty\n",
+        "        )\n",
+        "        loss.backward()\n",
+        "        return loss\n",
+        "\n",
+        "    loss_history = []\n",
+        "    for i in range(batch_iterations):\n",
+        "        loss = opt.step(closure)\n",
+        "        loss_history.append(loss.item())\n",
+        "        if batch_iterations % 10 == 0 and print_intermediate:\n",
+        "            print(f\"Iteration number {i}\\n Current loss {loss.item()}\\n\")\n",
+        "\n",
+        "    results_dict = {\n",
+        "        \"opt_params\": {\n",
+        "            \"alpha\": opt.param_groups[0][\"params\"][0],\n",
+        "            \"mu\": opt.param_groups[0][\"params\"][1],\n",
+        "            \"sigma\": opt.param_groups[0][\"params\"][2],\n",
+        "        },\n",
+        "        \"loss_history\": loss_history,\n",
+        "    }\n",
+        "    return results_dict"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Nio1PhXga5ME"
+      },
+      "source": [
+        "Now, enter our first `@ct.lattice`. This combines the above electrons,\n",
+        "eventually returning the optimal parameters $\\boldsymbol{\\phi}^{\\star}$\n",
+        "and the loss with batch iterations.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 73,
+      "metadata": {
+        "id": "K95eoEaLa5ME"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.lattice\n",
+        "def training_workflow(\n",
+        "    U: callable,\n",
+        "    W: callable,\n",
+        "    D: callable,\n",
+        "    n_qubits: int,\n",
+        "    k: int,\n",
+        "    probs_func: callable,\n",
+        "    W_layers: int,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        "    p: int,\n",
+        "    num_series: int,\n",
+        "    noise_amp: float,\n",
+        "    t_init: float,\n",
+        "    t_end: float,\n",
+        "    batch_size: int,\n",
+        "    tau: float,\n",
+        "    pytorch_optimizer: callable,\n",
+        "    lr: float,\n",
+        "    batch_iterations: int,\n",
+        "):\n",
+        "    \"\"\"\n",
+        "    Combine all of the previously defined electrons to do an entire training workflow,\n",
+        "    including (1) generating synthetic data, (2) packaging it into training cyclers\n",
+        "    (3) preparing the quantum functions and (4) optimizing the loss function with\n",
+        "    gradient based optimization. You can find definitions for all of the arguments\n",
+        "    by looking at the electrons and text cells above.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    X, T = generate_normal_time_series_set(p, num_series, noise_amp, t_init, t_end)\n",
+        "    Xtr = make_atomized_training_set(X, T)\n",
+        "    cycler = get_training_cycler(Xtr, batch_size)\n",
+        "    init_params = get_initial_parameters(W, W_layers, n_qubits)\n",
+        "    callable_penalty = callable_arctan_penalty(tau)\n",
+        "    callable_proj = get_callable_projector_func(k, U, W, D, n_qubits, probs_func)\n",
+        "    results_dict = train_model_gradients(\n",
+        "        lr,\n",
+        "        init_params,\n",
+        "        pytorch_optimizer,\n",
+        "        cycler,\n",
+        "        n_samples,\n",
+        "        callable_penalty,\n",
+        "        batch_iterations,\n",
+        "        callable_proj,\n",
+        "        gamma_length,\n",
+        "        print_intermediate=False,\n",
+        "    )\n",
+        "    return results_dict"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_cVnbMBQa5ME"
+      },
+      "source": [
+        "Before running this workflow, we define all of the input parameters.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 74,
+      "metadata": {
+        "id": "zrgDBKbCa5ME"
+      },
+      "outputs": [],
+      "source": [
+        "general_options = {\n",
+        "    \"U\": qml.AngleEmbedding,\n",
+        "    \"W\": qml.StronglyEntanglingLayers,\n",
+        "    \"D\": D,\n",
+        "    \"n_qubits\": 1,\n",
+        "    \"probs_func\": get_probs,\n",
+        "    \"gamma_length\": 1,\n",
+        "    \"n_samples\": 10,\n",
+        "    \"p\": 25,\n",
+        "    \"num_series\": 25,\n",
+        "    \"noise_amp\": 0.1,\n",
+        "    \"t_init\": 0.1,\n",
+        "    \"t_end\": 2 * torch.pi,\n",
+        "    \"k\": 1,\n",
+        "}\n",
+        "\n",
+        "training_options = {\n",
+        "    \"batch_size\": 10,\n",
+        "    \"tau\": 5,\n",
+        "    \"pytorch_optimizer\": torch.optim.Adam,\n",
+        "    \"lr\": 0.01,\n",
+        "    \"batch_iterations\": 100,\n",
+        "    \"W_layers\": 2,\n",
+        "}\n",
+        "\n",
+        "training_options.update(general_options)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lOYhgeYRa5MF"
+      },
+      "source": [
+        "We can now dispatch the lattice to the Covalent server.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 75,
+      "metadata": {
+        "id": "-QCVzIZya5MF"
+      },
+      "outputs": [],
+      "source": [
+        "tr_dispatch_id = ct.dispatch(training_workflow)(**training_options)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BRxajqpva5MF"
+      },
+      "source": [
+        "If you are running the notebook version of this tutorial, if you\n",
+        "navigate to <http://localhost:48008/> you can view the workflow on the\n",
+        "Covalent GUI. It will look like the screenshot below, showing nicely how\n",
+        "all of the electrons defined above interact with each other in the\n",
+        "workflow. You can also track the progress of the calculation here.\n",
+        "\n",
+        "![A screenshot of the Covalent GUI for the training\n",
+        "workflow.](../demonstrations/univariate_qvr/covalent_tutorial_screenshot.png){.align-center\n",
+        "width=\"85.0%\"}\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zakSI7tla5MF"
+      },
+      "source": [
+        "We now pull the results back from the Covalent server:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 76,
+      "metadata": {
+        "id": "KeMi_bN8a5MF"
+      },
+      "outputs": [],
+      "source": [
+        "ct_tr_results = ct.get_result(dispatch_id=tr_dispatch_id, wait=True)\n",
+        "results_dict = ct_tr_results.result"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bHd9avMWa5MF"
+      },
+      "source": [
+        "and take a look at the training loss history:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 77,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "z8PVX7W0a5MF",
+        "outputId": "d2ac1b3b-e91a-4e7e-bca4-61c7d4038f30"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure()\n",
+        "plt.plot(results_dict[\"loss_history\"], \".-\")\n",
+        "plt.ylabel(\"Loss [$\\mathcal{L}$]\")\n",
+        "plt.xlabel(\"Batch iterations\")\n",
+        "plt.title(\"Loss function versus batch iterations in training\")\n",
+        "plt.grid()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bYEqtP5ha5MF"
+      },
+      "source": [
+        "Tuning the threshold $\\zeta$\n",
+        "============================\n",
+        "\n",
+        "When we have access to labelled anomalous series (as we do in our toy\n",
+        "problem here, often not the case in reality), we can tune the threshold\n",
+        "$\\zeta$ to maximize some success metric. We choose to maximize the\n",
+        "accuracy score as defined using the three electrons below.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 78,
+      "metadata": {
+        "id": "v5VlKx0Xa5MF"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def get_preds_given_threshold(zeta: float, scores: torch.Tensor) -> torch.Tensor:\n",
+        "    \"\"\"For a given threshold, get the predicted labels (1 or -1), given the anomaly scores.\"\"\"\n",
+        "    return torch.tensor([-1 if score > zeta else 1 for score in scores])\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def get_truth_labels(\n",
+        "    normal_series_set: torch.Tensor, anomalous_series_set: torch.Tensor\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Get a 1D tensor containing the truth values (1 or -1) for a given set of\n",
+        "    time series.\n",
+        "    \"\"\"\n",
+        "    norm = torch.ones(normal_series_set.size()[0])\n",
+        "    anom = -torch.ones(anomalous_series_set.size()[0])\n",
+        "    return torch.cat([norm, anom])\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def get_accuracy_score(pred: torch.Tensor, truth: torch.Tensor) -> torch.Tensor:\n",
+        "    \"\"\"Given the predictions and truth values, return a number between 0 and 1\n",
+        "    indicating the accuracy of predictions.\n",
+        "    \"\"\"\n",
+        "    return torch.sum(pred == truth) / truth.size()[0]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AJShU6aya5MF"
+      },
+      "source": [
+        "Then, knowing the anomaly scores $a_X(y)$ for a validation data set, we\n",
+        "can scan through various values of $\\zeta$ on a fine 1D grid and\n",
+        "calcuate the accuracy score. Our goal is to pick the $\\zeta$ with the\n",
+        "largest accuracy score.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 79,
+      "metadata": {
+        "id": "aNI5zEbLa5MF"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.electron\n",
+        "def threshold_scan_acc_score(\n",
+        "    scores: torch.Tensor, truth_labels: torch.Tensor, zeta_min: float, zeta_max: float, steps: int\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Given the anomaly scores and truth values,\n",
+        "    scan over a range of thresholds = [zeta_min, zeta_max] with a\n",
+        "    fixed number of steps, calculating the accuracy score at each point.\n",
+        "    \"\"\"\n",
+        "    accs = torch.empty(steps)\n",
+        "    for i, zeta in enumerate(torch.linspace(zeta_min, zeta_max, steps)):\n",
+        "        preds = get_preds_given_threshold(zeta, scores)\n",
+        "        accs[i] = get_accuracy_score(preds, truth_labels)\n",
+        "    return accs\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def get_anomaly_score(\n",
+        "    callable_proj: callable,\n",
+        "    y: torch.Tensor,\n",
+        "    T: torch.Tensor,\n",
+        "    alpha_star: torch.Tensor,\n",
+        "    mu_star: torch.Tensor,\n",
+        "    sigma_star: torch.Tensor,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        "    get_time_resolved: bool = False,\n",
+        "):\n",
+        "    \"\"\"Get the anomaly score for an input time series y. We need to pass the\n",
+        "    optimal parameters (arguments with suffix _star). Optionally return the\n",
+        "    time-resolved score (the anomaly score contribution at a given t).\n",
+        "    \"\"\"\n",
+        "    scores = torch.empty(T.size()[0])\n",
+        "    for i in range(T.size()[0]):\n",
+        "        scores[i] = (\n",
+        "            1\n",
+        "            - F(\n",
+        "                callable_proj,\n",
+        "                y[i].unsqueeze(0),\n",
+        "                T[i].unsqueeze(0),\n",
+        "                alpha_star,\n",
+        "                mu_star,\n",
+        "                sigma_star,\n",
+        "                gamma_length,\n",
+        "                n_samples,\n",
+        "            )\n",
+        "        ).square()\n",
+        "    if get_time_resolved:\n",
+        "        return scores, scores.mean()\n",
+        "    else:\n",
+        "        return scores.mean()\n",
+        "\n",
+        "\n",
+        "@ct.electron\n",
+        "def get_norm_and_anom_scores(\n",
+        "    X_norm: torch.Tensor,\n",
+        "    X_anom: torch.Tensor,\n",
+        "    T: torch.Tensor,\n",
+        "    callable_proj: callable,\n",
+        "    model_params: dict,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        ") -> torch.Tensor:\n",
+        "    \"\"\"Get the anomaly scores assigned to input normal and anomalous time series instances.\n",
+        "    model_params is a dictionary containing the optimal model parameters.\n",
+        "    \"\"\"\n",
+        "    alpha = model_params[\"alpha\"]\n",
+        "    mu = model_params[\"mu\"]\n",
+        "    sigma = model_params[\"sigma\"]\n",
+        "    norm_scores = torch.tensor(\n",
+        "        [\n",
+        "            get_anomaly_score(callable_proj, xt, T, alpha, mu, sigma, gamma_length, n_samples)\n",
+        "            for xt in X_norm\n",
+        "        ]\n",
+        "    )\n",
+        "    anom_scores = torch.tensor(\n",
+        "        [\n",
+        "            get_anomaly_score(callable_proj, xt, T, alpha, mu, sigma, gamma_length, n_samples)\n",
+        "            for xt in X_anom\n",
+        "        ]\n",
+        "    )\n",
+        "    return torch.cat([norm_scores, anom_scores])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1ITCegXba5MF"
+      },
+      "source": [
+        "We now create our second `@ct.lattice`. We are to test the optimal model\n",
+        "against two random models. If our model is trainable, we should see that\n",
+        "the trained model is better.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 80,
+      "metadata": {
+        "id": "Y1AsPTlta5MG"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.lattice\n",
+        "def threshold_tuning_workflow(\n",
+        "    opt_params: dict,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        "    probs_func: callable,\n",
+        "    zeta_min: float,\n",
+        "    zeta_max: float,\n",
+        "    steps: int,\n",
+        "    p: int,\n",
+        "    num_series: int,\n",
+        "    noise_amp: float,\n",
+        "    spike_amp: float,\n",
+        "    max_duration: int,\n",
+        "    t_init: float,\n",
+        "    t_end: float,\n",
+        "    k: int,\n",
+        "    U: callable,\n",
+        "    W: callable,\n",
+        "    D: callable,\n",
+        "    n_qubits: int,\n",
+        "    random_model_seeds: torch.Tensor,\n",
+        "    W_layers: int,\n",
+        ") -> tuple:\n",
+        "    \"\"\"A workflow for tuning the threshold value zeta, in order to maximize the accuracy score\n",
+        "    for a validation data set. Results are tested against random models at their optimal zetas.\n",
+        "    \"\"\"\n",
+        "    # Generate datasets\n",
+        "    X_val_norm, T = generate_normal_time_series_set(p, num_series, noise_amp, t_init, t_end)\n",
+        "    X_val_anom, T = generate_anomalous_time_series_set(\n",
+        "        p, num_series, noise_amp, spike_amp, max_duration, t_init, t_end\n",
+        "    )\n",
+        "    truth_labels = get_truth_labels(X_val_norm, X_val_anom)\n",
+        "\n",
+        "    # Initialize quantum functions\n",
+        "    callable_proj = get_callable_projector_func(k, U, W, D, n_qubits, probs_func)\n",
+        "\n",
+        "    accs_list = []\n",
+        "    scores_list = []\n",
+        "    # Evaluate optimal model\n",
+        "    scores = get_norm_and_anom_scores(\n",
+        "        X_val_norm, X_val_anom, T, callable_proj, opt_params, gamma_length, n_samples\n",
+        "    )\n",
+        "    accs_opt = threshold_scan_acc_score(scores, truth_labels, zeta_min, zeta_max, steps)\n",
+        "    accs_list.append(accs_opt)\n",
+        "    scores_list.append(scores)\n",
+        "\n",
+        "    # Evaluate random models\n",
+        "    for seed in random_model_seeds:\n",
+        "        rand_params = get_initial_parameters(W, W_layers, n_qubits, seed)\n",
+        "        scores = get_norm_and_anom_scores(\n",
+        "            X_val_norm, X_val_anom, T, callable_proj, rand_params, gamma_length, n_samples\n",
+        "        )\n",
+        "        accs_list.append(threshold_scan_acc_score(scores, truth_labels, zeta_min, zeta_max, steps))\n",
+        "        scores_list.append(scores)\n",
+        "    return accs_list, scores_list"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5k6WBWBwa5MG"
+      },
+      "source": [
+        "We now set the input parameters.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 81,
+      "metadata": {
+        "id": "jrjCkf-ua5MG"
+      },
+      "outputs": [],
+      "source": [
+        "threshold_tuning_options = {\n",
+        "    \"spike_amp\": 0.4,\n",
+        "    \"max_duration\": 5,\n",
+        "    \"zeta_min\": 0,\n",
+        "    \"zeta_max\": 1,\n",
+        "    \"steps\": 100000,\n",
+        "    \"random_model_seeds\": [0, 1],\n",
+        "    \"W_layers\": 2,\n",
+        "    \"opt_params\": results_dict[\"opt_params\"],\n",
+        "}\n",
+        "\n",
+        "threshold_tuning_options.update(general_options)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "E94sE87_a5MG"
+      },
+      "source": [
+        "As before, we dispatch the lattice to the `Covalent` server.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 82,
+      "metadata": {
+        "id": "vgK3TbNGa5MG"
+      },
+      "outputs": [],
+      "source": [
+        "val_dispatch_id = ct.dispatch(threshold_tuning_workflow)(**threshold_tuning_options)\n",
+        "ct_val_results = ct.get_result(dispatch_id=val_dispatch_id, wait=True)\n",
+        "accs_list, scores_list = ct_val_results.result"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gMzyfZyga5MG"
+      },
+      "source": [
+        "Now, we can plot the results:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 83,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 486
+        },
+        "id": "6G62tWO-a5MG",
+        "outputId": "3867f251-8aeb-4584-d558-8467ad2c3def"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 6 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "zeta_xlims = [(0, 0.001), (0.25, 0.38), (0.25, 0.38)]\n",
+        "titles = [\"Trained model\", \"Random model 1\", \"Random model 2\"]\n",
+        "zetas = torch.linspace(\n",
+        "    threshold_tuning_options[\"zeta_min\"],\n",
+        "    threshold_tuning_options[\"zeta_max\"],\n",
+        "    threshold_tuning_options[\"steps\"],\n",
+        ")\n",
+        "fig, axs = plt.subplots(ncols=3, nrows=2, sharey=\"row\")\n",
+        "for i in range(3):\n",
+        "    axs[0, i].plot(zetas, accs_list[i])\n",
+        "    axs[0, i].set_xlim(zeta_xlims[i])\n",
+        "    axs[0, i].set_xlabel(\"Threshold [$\\zeta$]\")\n",
+        "    axs[0, i].set_title(titles[i])\n",
+        "    axs[1, i].boxplot(\n",
+        "        [\n",
+        "            scores_list[i][0 : general_options[\"num_series\"]],\n",
+        "            scores_list[i][general_options[\"num_series\"] : -1],\n",
+        "        ],\n",
+        "        labels=[\"Normal\", \"Anomalous\"],\n",
+        "    )\n",
+        "    axs[1, i].set_yscale(\"log\")\n",
+        "    axs[1, i].axhline(\n",
+        "        zetas[torch.argmax(accs_list[i])], color=\"k\", linestyle=\":\", label=\"Optimal $\\zeta$\"\n",
+        "    )\n",
+        "    axs[1, i].legend()\n",
+        "axs[0, 0].set_ylabel(\"Accuracy score\")\n",
+        "axs[1, 0].set_ylabel(\"Anomaly score [$a_X(y)$]\")\n",
+        "fig.tight_layout()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BFKn_NMWa5MG"
+      },
+      "source": [
+        "Parsing the above, we can see that the optimal model achieves high\n",
+        "accuracy when the threshold is tuned using the validation data. On the\n",
+        "other hand, the random models return mostly random results (sometimes\n",
+        "even worse than random guesses), regardless of how we set the threshold.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZyQ4_zyVa5MG"
+      },
+      "source": [
+        "Testing the model\n",
+        "=================\n",
+        "\n",
+        "Now with optimal thresholds for our optimized and random models, we can\n",
+        "perform testing. We already have all of the electrons to do this, so we\n",
+        "create the `@ct.lattice`\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 84,
+      "metadata": {
+        "id": "Ply0mPTka5MG"
+      },
+      "outputs": [],
+      "source": [
+        "@ct.lattice\n",
+        "def testing_workflow(\n",
+        "    opt_params: dict,\n",
+        "    gamma_length: int,\n",
+        "    n_samples: int,\n",
+        "    probs_func: callable,\n",
+        "    best_zetas: list,\n",
+        "    p: int,\n",
+        "    num_series: int,\n",
+        "    noise_amp: float,\n",
+        "    spike_amp: float,\n",
+        "    max_duration: int,\n",
+        "    t_init: float,\n",
+        "    t_end: float,\n",
+        "    k: int,\n",
+        "    U: callable,\n",
+        "    W: callable,\n",
+        "    D: callable,\n",
+        "    n_qubits: int,\n",
+        "    random_model_seeds: torch.Tensor,\n",
+        "    W_layers: int,\n",
+        ") -> list:\n",
+        "    \"\"\"A workflow for calculating anomaly scores for a set of testing time series\n",
+        "    given an optimal model and set of random models. We use the optimal zetas found in threshold tuning.\n",
+        "    \"\"\"\n",
+        "    # Generate time series\n",
+        "    X_val_norm, T = generate_normal_time_series_set(p, num_series, noise_amp, t_init, t_end)\n",
+        "    X_val_anom, T = generate_anomalous_time_series_set(\n",
+        "        p, num_series, noise_amp, spike_amp, max_duration, t_init, t_end\n",
+        "    )\n",
+        "    truth_labels = get_truth_labels(X_val_norm, X_val_anom)\n",
+        "\n",
+        "    # Prepare quantum functions\n",
+        "    callable_proj = get_callable_projector_func(k, U, W, D, n_qubits, probs_func)\n",
+        "\n",
+        "    accs_list = []\n",
+        "    # Evaluate optimal model\n",
+        "    scores = get_norm_and_anom_scores(\n",
+        "        X_val_norm, X_val_anom, T, callable_proj, opt_params, gamma_length, n_samples\n",
+        "    )\n",
+        "    preds = get_preds_given_threshold(best_zetas[0], scores)\n",
+        "    accs_list.append(get_accuracy_score(preds, truth_labels))\n",
+        "    # Evaluate random models\n",
+        "    for zeta, seed in zip(best_zetas[1:], random_model_seeds):\n",
+        "        rand_params = get_initial_parameters(W, W_layers, n_qubits, seed)\n",
+        "        scores = get_norm_and_anom_scores(\n",
+        "            X_val_norm, X_val_anom, T, callable_proj, rand_params, gamma_length, n_samples\n",
+        "        )\n",
+        "        preds = get_preds_given_threshold(zeta, scores)\n",
+        "        accs_list.append(get_accuracy_score(preds, truth_labels))\n",
+        "    return accs_list"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MEqrJNt0a5MG"
+      },
+      "source": [
+        "We dispatch it to the Covalent server with the appropriate parameters.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 85,
+      "metadata": {
+        "id": "sHjxzzIGa5MG"
+      },
+      "outputs": [],
+      "source": [
+        "testing_options = {\n",
+        "    \"spike_amp\": 0.4,\n",
+        "    \"max_duration\": 5,\n",
+        "    \"best_zetas\": [zetas[torch.argmax(accs)] for accs in accs_list],\n",
+        "    \"random_model_seeds\": [0, 1],\n",
+        "    \"W_layers\": 2,\n",
+        "    \"opt_params\": results_dict[\"opt_params\"],\n",
+        "}\n",
+        "\n",
+        "testing_options.update(general_options)\n",
+        "\n",
+        "test_dispatch_id = ct.dispatch(testing_workflow)(**testing_options)\n",
+        "ct_test_results = ct.get_result(dispatch_id=test_dispatch_id, wait=True)\n",
+        "accs_list = ct_test_results.result"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "S7QEHFdla5MG"
+      },
+      "source": [
+        "Finally, we plot the results below.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 86,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 452
+        },
+        "id": "n-9gbA0Ia5MG",
+        "outputId": "cd8522fe-daa9-4062-f70d-aa0fd70d2689"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure()\n",
+        "plt.bar([1, 2, 3], accs_list)\n",
+        "plt.axhline(0.5, color=\"k\", linestyle=\":\", label=\"Random accuracy\")\n",
+        "plt.xticks([1, 2, 3], [\"Trained model\", \"Random model 1\", \"Random model 2\"])\n",
+        "plt.ylabel(\"Accuracy score\")\n",
+        "plt.title(\"Accuracy scores for trained and random models\")\n",
+        "leg = plt.legend()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DKY1xKrYa5MH"
+      },
+      "source": [
+        "As can be seen, once more, the trained model is far more accurate than\n",
+        "the random models. Awesome! Now that we\\'re done with the calculations\n",
+        "in this tutorial, we just need to remember to shut down the Covalent\n",
+        "server\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 87,
+      "metadata": {
+        "id": "k0Wja1dHa5MH"
+      },
+      "outputs": [],
+      "source": [
+        "# Shut down the covalent server\n",
+        "stop = os.system(\"covalent stop\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wjgM9uhia5MH"
+      },
+      "source": [
+        "Conclusions\n",
+        "===========\n",
+        "\n",
+        "We\\'ve now reached the end of this tutorial! Quickly recounting what we\n",
+        "have learnt, we:\n",
+        "\n",
+        "1.  Learnt the background of how to detect anomalous time series\n",
+        "    instances, *quantumly*,\n",
+        "2.  Learnt how to build the code to achieve this using PennyLane and\n",
+        "    PyTorch, and,\n",
+        "3.  Learnt the basics of Covalent: a workflow orchestration tool for\n",
+        "    heterogeneous computation\n",
+        "\n",
+        "If you want to learn more about QVR, you should consult the paper where\n",
+        "we generalize the math a little and test the algorithm on less trivial\n",
+        "time series data than was dealt with in this tutorial. We also ran some\n",
+        "experiments on real quantum computers, enhancing our results using error\n",
+        "mitigation techniques. If you want to play some more with Covalent,\n",
+        "check us out on [GitHub](https://github.com/AgnostiqHQ/covalent/) and/or\n",
+        "engage with other tutorials in our\n",
+        "[documentation](https://covalent.readthedocs.io/en/stable/).\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MCpaNVlHa5MH"
+      },
+      "source": [
+        "References\n",
+        "==========\n",
+        "\n",
+        "About the authors \\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\--.. include::\n",
+        "../\\_static/authors/jack\\_stephen\\_baker.txt .. include::\n",
+        "../\\_static/authors/santosh\\_kumar\\_radha.txt\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.9.17"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}