Repository: infer-actively/pymdp (language: python)

Issue:
Typos in Tutorial 1
There are two instances which read *THe*, which should be changed to *The*

A heading is mislabeled:

3. The prior over observations: the D vector or P(s)

Should read:

4. The prior over hidden states: the D vector or P(s)
Polish tutorial 2
I really enjoyed this tutorial, overall. It shows the power of Agent. I think it's a little hard to read in some places, and I wanted to flag some of these issues:

1. It's a non-standard bandit task, because there's a third action, HINT. It would be nice to indicate this in the intro - or to refer to a version of the task which includes the hint action, because there's no indication in the only reference, which is the Wikipedia link.
2. Going from tutorial 1 to tutorial 2, there's an unexplained shift in the definition of A. In tutorial 1, it was a two-dimensional array p(o|s), but now it's a four-dimensional array. I realized a bit late in the process that this was all explained in the pymdp fundamentals part of the doc - a backlink would be nice.
3. Generally I find using raw arrays to define states difficult to read. I presume that this is an artifact of the history of the package (Matlab cell arrays). It would be helpful to remind people the definition of the axes as we go along. OTOH, I did find the diagrams very helpful.
4. I found the last part about manipulating the reward very confusing. I had to go back to definitions to figure out that the last manipulation changed the loss into a reward (+5) - if I just look at the output, it looks like the agent always picks the arm resulting in a loss. 

One thing that's not explained here is how the agent's inference mechanism differs from those of other, more well-known agents from the RL literature. Having read the first few chapters of Richard Sutton's book eons ago, I wondered whether the inference was equivalent to a finite horizon dynamic programming solution, or similar in spirit to an agent that uses a UCB heuristic or Thompson sampling. If you could have a few references in the tutorial about this, it would be great.


Discussion / hints:

Fix patch:
diff --git a/README.md b/README.md
index 706136ee..7ed8a78e 100644
--- a/README.md
+++ b/README.md
@@ -104,7 +104,9 @@ For new users to `pymdp`, we specifically recommend stepping through following t
 - [Active Inference from Scratch](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/active_inference_from_scratch.html)
 - [The `Agent` API](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/using_the_agent_class.html)
 
-Special thanks to [Beren Millidge](https://github.com/BerenMillidge) and [Daphne Demekas](https://github.com/daphnedemekas) for their help in constructing these tutorials, which were originally based on a set of tutorial notebooks written by [Alec Tschantz](https://github.com/alec-tschantz).
+Special thanks to [Beren Millidge](https://github.com/BerenMillidge) and [Daphne Demekas](https://github.com/daphnedemekas) for their help in prototyping earlier versions of the [Active Inference from Scratch](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/active_inference_from_scratch.html) tutorial, which were originally based on a grid world POMDP environment create by [Alec Tschantz](https://github.com/alec-tschantz).
+
+We also have (and are continuing to build) a series of notebooks that walk through active inference agents performing different types of tasks, such as the classic [T-Maze environment](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/tmaze_demo.html) and the newer [Epistemic Chaining](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/cue_chaining_demo.html) demo.
 
 ## Contributing
 
diff --git a/docs/agent.rst b/docs/agent.rst
new file mode 100644
index 00000000..017dca31
--- /dev/null
+++ b/docs/agent.rst
@@ -0,0 +1,5 @@
+Agent class
+=================================
+
+.. autoclass:: pymdp.agent.Agent
+    :members:
diff --git a/docs/conf.py b/docs/conf.py
index 35834cbe..bd862583 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -21,7 +21,7 @@
 author = 'infer-actively'
 
 # The full version, including alpha/beta/rc tags
-release = '0.0.3'
+release = '0.0.4'
 
 # -- General configuration ---------------------------------------------------
 
diff --git a/docs/env.rst b/docs/env.rst
new file mode 100644
index 00000000..93b1b5bd
--- /dev/null
+++ b/docs/env.rst
@@ -0,0 +1,24 @@
+Env
+========
+
+The OpenAIGym-inspired ``Env`` base class is the main API that represents the environmental dynamics or "generative process" with
+which agents exchange observations and actions
+
+Base class
+----------
+.. autoclass:: pymdp.envs.Env
+
+Specific environment implementations
+----------
+
+All of the following dynamics inherit from ``Env`` and have the
+same general usage as above.
+
+.. autosummary::
+   :nosignatures:
+
+    pymdp.envs.GridWorldEnv
+    pymdp.envs.DGridWorldEnv
+    pymdp.envs.VisualForagingEnv
+    pymdp.envs.TMazeEnv
+    pymdp.envs.TMazeEnvNullOutcome
diff --git a/docs/index.rst b/docs/index.rst
index 829c0fac..0b0b5286 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -12,6 +12,9 @@ discrete space and time, using partially-observed Markov Decision Processes
 enable users to design and simulate bespoke active inference models with varying levels of
 specificity to a given task.
 
+For a theoretical overview of active inference and the motivations for developing this package, 
+please see our companion paper_: "pymdp: A Python library for active inference in discrete state spaces".
+
 .. toctree::
    :maxdepth: 1
    :caption: Installation & Usage
@@ -37,6 +40,18 @@ specificity to a given task.
    learning
    algos/index
 
+.. toctree::
+   :maxdepth: 2
+   :caption: Agent and environment API
+
+   agent
+   env
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Additional learning materials
+
+   notebooks/free_energy_calculation.ipynb
 
 Indices and tables
 ==================
@@ -44,3 +59,5 @@ Indices and tables
 * :ref:`genindex`
 * :ref:`modindex`
 * :ref:`search`
+
+.. _paper: https://arxiv.org/abs/2201.03904
diff --git a/docs/inference.rst b/docs/inference.rst
index dd59325a..949f1fd8 100644
--- a/docs/inference.rst
+++ b/docs/inference.rst
@@ -1,7 +1,7 @@
 Inference
 =================================
 
-The ``inference.py`` module contains the functions for performing inference of discrete hidden states (Categorical distributions) in POMDP generative models.
+The ``inference.py`` module contains the functions for performing inference of discrete hidden states (categorical distributions) in POMDP generative models.
 
 .. automodule:: pymdp.inference
     :members:
\ No newline at end of file
diff --git a/docs/learning.rst b/docs/learning.rst
index 023fc62c..77f420b2 100644
--- a/docs/learning.rst
+++ b/docs/learning.rst
@@ -1,7 +1,7 @@
 Learning
 =================================
 
-The ``learning.py`` module contains the functionf for updating parameters of Dirichlet posteriors (that paramaterise Categorical priors and likelihoods) in POMDP generative models.
+The ``learning.py`` module contains the functions for updating parameters of Dirichlet posteriors (that paramaterise categorical priors and likelihoods) in POMDP generative models.
 
 .. automodule:: pymdp.learning
     :members:
\ No newline at end of file
diff --git a/docs/notebooks/active_inference_from_scratch.ipynb b/docs/notebooks/active_inference_from_scratch.ipynb
index 8afb530b..864aa0fc 100644
--- a/docs/notebooks/active_inference_from_scratch.ipynb
+++ b/docs/notebooks/active_inference_from_scratch.ipynb
@@ -954,7 +954,7 @@
         "\n",
         "---\n",
         "\n",
-        "THe (biased) generative model's prior preference for particular observations, encoded in terms of probabilities.\n"
+        "The (biased) generative model's prior preference for particular observations, encoded in terms of probabilities.\n"
       ]
     },
     {
@@ -995,11 +995,11 @@
         "id": "syuovouSRmQe"
       },
       "source": [
-        "### 3. The prior over observations: the $\\mathbf{D}$ vector or $P(s)$\n",
+        "### 3. The prior over hidden states: the $\\mathbf{D}$ vector or $P(s)$\n",
         "\n",
         "---\n",
         "\n",
-        "THe generative model's prior belief over hidden states at the first timestep.\n"
+        "The generative model's prior belief over hidden states at the first timestep.\n"
       ]
     },
     {
diff --git a/docs/notebooks/free_energy_calculation.ipynb b/docs/notebooks/free_energy_calculation.ipynb
new file mode 100644
index 00000000..ac5368a0
--- /dev/null
+++ b/docs/notebooks/free_energy_calculation.ipynb
@@ -0,0 +1,761 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Computing the variational free energy in categorical models\n",
+    "\n",
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/infer-actively/pymdp/blob/master/docs/notebooks/free_energy_calculation.ipynb)\n",
+    "\n",
+    "*Author: Conor Heins*\n",
+    "\n",
+    "This notebook walks the user through the computation of the variational free energy (or *VFE*) for discrete generative models, composed of categorical distributions. We can represent these sorts of generative models easily in array-focused programming languages like `NumPy` and `MATLAB` using matrices and vectors.\n",
+    "\n",
+    "In the discrete state-space formulation, the variational free energy is very straightforward to compute when we take advantage of the NDarray representation of probability distributions. The highly-optimized matrix algebra built into today's numerical computing paradigms can be exploited to write simple, one-line expressions for information-theoretic terms (like Kullback-Leibler divergences, cross-entropies, log-likelihoods, etc.). All these terms end up being variants of things like inner products, matrix-vector products or matrix-matrix multiplications.\n",
+    "\n",
+    "This notebook is inspired by the supplementary MATLAB script for the paper [\"A Step-by-Step Tutorial on Active Inference Modelling and its Application to Empirical Data\"](https://www.sciencedirect.com/science/article/pii/S0022249621000973) by Ryan Smith, Karl Friston, and Christopher Whyte. The original MATLAB script is called `VFE_calculation_example.m`, and can be found on [Ryan Smith's GitHub repository](https://github.com/rssmith33/Active-Inference-Tutorial-Scripts), which also contains a set of tutorial scripts that are supplementary to their paper."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Note*: When running this notebook in Google Colab, you may have to run `!pip install inferactively-pymdp` at the top of the notebook, before you can `import pymdp`. That cell is left commented out below, in case you are running this notebook from Google Colab."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ! pip install inferactively-pymdp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports\n",
+    "\n",
+    "First, import `pymdp` and the modules we'll need."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from IPython.display import display, Latex\n",
+    "\n",
+    "from pymdp import utils, maths"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A simple generative model composed of a likelihood and a prior\n",
+    "\n",
+    "We begin by constructing a simple generative model composed of two sets of categorical distributions: a likelihood distribution $P(o|s)$ and a prior distribution $P(s)$. \n",
+    "\n",
+    "Because both of these distributions are categorical distributions, we can represent them easily in code using matrices and vectors. The likelihood distribution is a conditional distribution that tells the probability that the generative model assigns to different observations, given different hidden states. Since observations and hidden states are both discrete, this can be efficiently represented as a matrix, each of whose **columns** store the conditional probabilities of all the observations (the **rows**), given a particular hidden state. Each hidden state setting is thus indexed by a column. For this reason, each column of this matrix is a categorical probability distributions and its entries must sum to one. \n",
+    "\n",
+    "The prior is represented as a 1-D vector and stores the prior probabilities that the generative model assigns to each hidden state. \n",
+    "\n",
+    "Finally, to set ourselves up later for showing model inversion and free energy calculations, we initialize an observation that we assume the agent or generative model has \"gathered\" or \"seen.\" In `pymdp` we can represent these observations either as one-hot vectors (a `1` in one entry, and `0`'s everywhere else) or more sparsely as simple indices (integers) that represent *which* of the observations was observed. Because observations are not distributions (or technically, they are Dirac distributions), you don't need to store a whole vector of elements, you can just store a particular index.\n",
+    "\n",
+    "Below we create 3 main variables: \n",
+    "\n",
+    "- An `observation` that represents a real observation that the agent or generative model \"sees\". \n",
+    "- The `prior` distribution that represents the agent's prior beliefs about the hidden states\n",
+    "- the `likliheood_dist` that represents the agent's beliefs about how hidden states probabilistically relate to observations.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Define a quick helper function for printing arrays nicely (see https://gist.github.com/braingineer/d801735dac07ff3ac4d746e1f218ab75)\n",
+    "def matprint(mat, fmt=\"g\"):\n",
+    "    col_maxes = [max([len((\"{:\"+fmt+\"}\").format(x)) for x in col]) for col in mat.T]\n",
+    "    for x in mat:\n",
+    "        for i, y in enumerate(x):\n",
+    "            print((\"{:\"+str(col_maxes[i])+fmt+\"}\").format(y), end=\"  \")\n",
+    "        print(\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Observation: 0\n",
+      "\n",
+      "Prior:[0.5 0.5]\n",
+      "\n",
+      "Likelihood:\n",
+      "0.8  0.2  \n",
+      "0.2  0.8  \n"
+     ]
+    }
+   ],
+   "source": [
+    "num_obs = 2 # dimensionality of observations (2 possible observation levels)\n",
+    "num_states = 2 # dimensionality of observations (2 possible hidden state levels)\n",
+    "\n",
+    "observation = 0 # index representation\n",
+    "# observation = np.array([1, 0]) # one hot representation\n",
+    "# observation = utils.onehot(0, num_obs) # one hot representation, but use one of pymdp's utility functions to create a one-hot\n",
+    "\n",
+    "prior = np.array([0.5, 0.5]) # simply set it by hand\n",
+    "# prior = np.ones(num_states) / num_states # create a uniform prior distribution by creating a vector of ones and dividing each by the number of states\n",
+    "# prior = utils.norm_dist(np.ones(num_states)) # use one of pymdp's utility functions to normalize any vector into a probability distribution\n",
+    "\n",
+    "likelihood_dist = np.array([ [0.8, 0.2],\n",
+    "                        [0.2, 0.8] ])\n",
+    "\n",
+    "if isinstance(observation, np.ndarray):\n",
+    "    print(f'Observation:{observation}\\n')\n",
+    "else:\n",
+    "    print(f'Observation: {observation}\\n')\n",
+    "print(f'Prior:{prior}\\n')\n",
+    "print('Likelihood:')\n",
+    "matprint(likelihood_dist)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bayesian inference\n",
+    "\n",
+    "Before we define variational free energy for this generative model, let's step through the computations involved in inverting this model using Bayes' rule, i.e. computing the optimal Bayesian posterior over hidden states, given our sensory observation (which we will formally refer to as $o_t$). By performing exact Bayesian inference first, we can directly compares its results to that of variational free energy minimization. This will help us better understand the meaning of the free energy calculations that come later.\n",
+    "\n",
+    "#### 1. Compute the likelihood over hidden states, given the observation \n",
+    "\n",
+    "Now that we have a generative model and have fixed a particular observatio $o_t$ (`observation`), we have to perform Bayes' rule to compute the posterior. Mathematically, this can be expressed as follows:\n",
+    "\n",
+    "### $ \\hspace{60mm} P(s | o _t) = \\frac{P(o = o_t | s)P(s)}{P(o = o_t)} $\n",
+    "\n",
+    "Computing the posterior via Bayes' rule (also known as \"model inversion\") is the essence of optimal statistical inference, when one has a generative model of how one's data is caused, and some data. \n",
+    "\n",
+    "To start with, let's computing the likelihood term $P(o = o_t | s)$. We can represent the computation of the likelihood with this line of `NumPy`: ``likelihood_dist[observation,:]``. By doing so, we are providing a numerical answer to the question: \"What is the likelihood that State 1 vs State 2 caused the actual sensory data $o_t$ that I've observed?\".\n",
+    "\n",
+    " Mathematically, our likelihood function $P(o = o_t | s)$ (in the statistics literature also referred to as $L(\\theta)$) is a *function of the hidden states*. The particular function over hidden states we use is *defined* by the observation $o_t$. So you can think of the likelihood as a multi-dimensional function or simply a space of functions, where the particular function you use for inference is determined by your data.\n",
+    "\n",
+    "This act of computing the likelihood via an indexing  operation ``likelihood_dist[observation,:]``, is similar in spirit to the operation of *conditioning*. We are, in some sense, \"conditioning\" on a particular observation (slicing out a \"row\" of our ``likelihood_dist`` matrix), and then looking at the *induced* likelihood over possible causes (hidden states) that could've have been the latent source of that observation. This operation captures the essence of what we mean when we speak of \"inverting\" generative models. Generative models are referred to as *generative* because they can be used to generate fictive observations, given some fixed setting of latent parameters. *Inversion* is thus moving in the opposite direction -- given some sensory data, what is the consequent likelihood over the *causes* or hidden states that might have generated that data?\n",
+    "\n",
+    "**Note**: We can also compute the likelihood using a matrix-vector product, if the observation is represented as a one-hot vector.\n",
+    "\n",
+    "```\n",
+    "likelihood_s = likelihood_dist.T @ observation\n",
+    "```\n",
+    "\n",
+    "You can see think of this as a weighted average of the rows of the likelihood matrix, where the weights are provided by the observations. Since we have insisted that the observations are a one-hot vector, this is equivalent to just selecting a single row of the likelihood matrix (the one indexed by the entry of the observation that is `1.0`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(o=o_t|s):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.8 0.2]\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "if isinstance(observation, np.ndarray): # use the matrix-vector version if your observation is a one-hot vector\n",
+    "    likelihood_s = likelihood_dist.T @ observation\n",
+    "elif isinstance(observation, int): # use the index version if your observation is an integer index\n",
+    "    likelihood_s = likelihood_dist[observation,:] \n",
+    "display(Latex(f'$P(o=o_t|s):$'))\n",
+    "print(f'{likelihood_s}')\n",
+    "print('==================\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. The joint distribution $P(o = o_t, s) = P(o = o_t|s)P(s)$ \n",
+    "\n",
+    "To compute the full numerator on the right-hand side of the Bayes' rule equation, we need to compute the joint distribution $P(o = o_t|s)P(s)$.\n",
+    "\n",
+    "The joint distribution, which also fully defines the generative model, is the product of the likelihood and prior distributions. The joint distribution expresses the joint probability of observations and hidden states, given the likelihood distribution and the prior over hidden states. If we condition on an actual observation $o_t$, as we have done here, then this joint distribution is, like the likelihood, a function of hidden states. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(o = o_t,s) = P(o = o_t|s)P(s):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.4 0.1]\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "joint_prob = likelihood_s * prior # element-wise product of the likelihood of each hidden state, given the observation, with the prior probability assigned to each hidden state\n",
+    "display(Latex(f'$P(o = o_t,s) = P(o = o_t|s)P(s):$'))\n",
+    "print(f'{joint_prob}')\n",
+    "print('==================\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Marginal probability or marginal likelihood: $\\sum_s P(o = o_t, s) = P(o = o_t)$\n",
+    "\n",
+    "Let's remind ourselves of Bayes' rule below:\n",
+    "\n",
+    "#### $ \\hspace{60mm} P(s | o _t) = \\frac{P(o = o_t | s)P(s)}{P(o = o_t)} $\n",
+    "\n",
+    "So far, using the likelihood, the observation, and the prior, we have computed the numerator of this term: the unnormalized joint distribution $P(o = o_t,s)$. All that's left is to do is then divide this term by the denominator $P(o=o_t)$. This term is also referred to as the model evidence or the marginal likelihood. \n",
+    "\n",
+    "This can be thought of as the probability of having seen the particular observation you saw, under all possible settings of the hidden states. This can be computed by marginalizing the joint distribution, using the prior probabilities of the hidden states:\n",
+    "\n",
+    "#### $ \\hspace{60mm}P(o) = \\sum_s P(o|s)P(s)$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p_o = joint_prob.sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Compute the posterior $P(s|o=o_t)$\n",
+    "\n",
+    "Now to compute the Bayes-optimal posterior, simply divide the numerator by the denominator!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(s|o = o_t) = \\frac{P(o = o_t,s)}{P(o=o_t)}$:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Posterior over hidden states: [0.8 0.2]\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "posterior = joint_prob / p_o # divide the joint by the marginal\n",
+    "display(Latex('$P(s|o = o_t) = \\\\frac{P(o = o_t,s)}{P(o=o_t)}$:'))\n",
+    "print(f'Posterior over hidden states: {posterior}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### The variational free energy\n",
+    "\n",
+    "The variational free energy is an upper bound on **surprise**: surprise is define as $ - \\ln p(o)$, and is also known as the negative (log) evidence. By minimizing free energy, we are **minimizing** surprise and thus **maximizing** log evidence.  This evidence is simply the (log of the) term we computed in the previous step, the normalizing denominator used in Bayes' rule. We can thus first compute the surprise associated with the observation we saw earlier:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$- \\ln P(o=o_t)$:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Surprise: 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "surprise = - np.log(p_o)\n",
+    "\n",
+    "display(Latex('$- \\ln P(o=o_t)$:'))\n",
+    "print(f'Surprise: {surprise.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By minimizing variational free energy with respect to the parameters of an arbitrary, parametrized distribution, also known as the approximate or variational posterior $Q(s)$, we are forcing the surprise to go down, and the model evidence to go up. In doing so, the approximate posterior distribution will get \"closer\" to the true posterior distribution (the $P(s|o)$ we computed above), $Q(s) \\approx P(s|o)$.\n",
+    "\n",
+    "This idea of minimizing a bound on surprise, is the core principle underlying the variational free energy principle, active inference, and the statistical methodology of variational principles more generally. This comes in handy because in many realistic scenarios where agents or systems need to make inferences about the hidden causes of sensory perturbations, performing Bayesian inference exactly becomes intractable (due mostly to the computation of the $P(o)$ denominator term, also known as the normalizing constant). Variational inference turns this intractable marginalization problem into a tractable optimization problem, where one only needs to change the approximate posterior $Q(s)$ in order to minimize a bound on surprise.\n",
+    "\n",
+    "But what is the variational free energy exactly, mathematically? It is commonly written as the expectation, under the approximate posterior, of the log ratio between the approximate posterior and the generative model:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] $\n",
+    "\n",
+    "Because of the rules of logarithms, we can also express this as an expected difference between the log posterior and the log generative model:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)] $\n",
+    "\n",
+    "By doing taking advantage of some more mathematical relationships (the factorization of the joint, rules for logarithms of products, and the definition of the conditional expectation), we can re-write this as an upper bound on surprise:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)] - \\ln P(o) $\n",
+    "\n",
+    "By re-arranging this equality and taking advantage of the fact that the quantity $\\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)]$ (also known as the Kullback-Leibler divergence) is greater than or equal to 0, we can easily show that the VFE is an upper bound on surprise:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} \\geq - \\ln P(o) $\n",
+    "\n",
+    "Let's now compute the VFE numerically for our generative model and fixed observation. Given we already defined those two things ($o_t$ and $P(o,s)$), the last thing we need to do, is to define an initial setting of our approximate posterior $Q(s)$, and compute the variational free energy using one of the formulas above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Variational free energy (F) = 0.916\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# to begin with, set our initial Q(s) equal to our prior distribution -- i.e. a flat/uninformative belief about hidden states\n",
+    "initial_qs = np.array([0.5, 0.5])\n",
+    "\n",
+    "# redefine generative model and observation, for ease\n",
+    "observation = 0\n",
+    "likelihood_dist = np.array([[0.8, 0.2], [0.2, 0.8]])\n",
+    "prior = utils.norm_dist(np.ones(2))\n",
+    "\n",
+    "# compute the joint or generative model using the factorization: P(o=o|s)P(s)\n",
+    "joint_prob = likelihood_dist[observation,:] * prior\n",
+    "\n",
+    "# compute the variational free energy using the expected log difference formulation\n",
+    "initial_F = initial_qs.dot(np.log(initial_qs) - np.log(joint_prob))\n",
+    "## @NOTE: because of log-rules, `initial_F` can also be computed using the division inside the logarithm:\n",
+    "# initial_F = initial_qs.dot(np.log(initial_qs/joint_prob))\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'Variational free energy (F) = {initial_F.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's then change the approximate posterior $Q(s)$ and see what happens to the variational free energy.\n",
+    "\n",
+    "By definition, optimal inference (and 'perfect' VFE minimization) obtains when we set the approximate posterior $Q(s)$ to be equal to the true posterior, $Q(s) = P(s|o)$. \n",
+    "\n",
+    "As an extreme case, let's do this and then measure the variational free energy. We can see that it has decreased, relative to it's initial setting when the approximate posterior was equal to the prior $P(s)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F = 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "final_qs = posterior.copy() # now we just assert that the approximate posterior is equal to the true posterior\n",
+    "final_F = final_qs.dot(np.log(final_qs) - np.log(joint_prob))\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'F = {final_F.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that the free energy is 0.693 -- if you recall, this is exactly the **surprise** or negative log marginal likelihood $-\\ln P(o = o_t)$, related to the marginal likelihood quantity $P(o=o_t)$ that we had to compute when performing exact Bayesian inference earlier. \n",
+    "\n",
+    "It is easy to see why this equality should hold, when we consider the VFE in terms of the surprise bound:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)] - \\ln P(o) $\n",
+    "\n",
+    "When $Q(s) = P(s|o)$, as we have enforced with the line ``final_qs = posterior.copy()`` above, the first term $\\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)]$ will become 0. This is a property of the Kullback-Leibler divergence between two distributions $\\operatorname{D}_{KL}(Q \\parallel P) = \\mathbb{E}_{Q}[\\ln Q - \\ln P]$. \n",
+    "\n",
+    "So since that KL divergence is 0, this is a case when the bound on surprise is exact:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = 0 - \\ln P(o) = - \\ln P(o)$\n",
+    "\n",
+    "In other words, minimizing free energy \"as much as possible\" in the case of this generative model, means that the approximate posterior equals the true posterior, and the free energy bound becomes \"tight\", i.e. the free energy simply IS the negative log evidence!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$-\\ln P(o):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.693\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compute the surprise (which we can do analytically for this simple generative model)\n",
+    "p_o = joint_prob.sum()\n",
+    "surprise = - np.log(p_o)\n",
+    "display(Latex('$-\\ln P(o):$'))\n",
+    "print(f'{surprise.round(3)}')\n",
+    "print('==================\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bonus material: auto-differentiation to perform gradient descent on the variational free energy\n",
+    "\n",
+    "In this section, we are going to numerically differentiate the variational free energy with respect to the parameters of the approximate posterior. We can take advantage of modern autodifferentiation software, that can calculate the derivatives of arbitrary computer programs, to compute these derivatives without doing any analytic differentiation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import autograd.numpy as np_auto   # Thinly-wrapped version of Numpy that is auto-differentiable\n",
+    "from autograd import grad          # this is the function that we use to evaluate derivatives\n",
+    "from functools import partial"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, let's create a variational free energy function, that takes as input the variational posterior `qs`, an observation `obs`, the likelihood matrix `likelihood` and a prior distribution `prior`.\n",
+    "\n",
+    "By defining this computation as a function, we can calculate its derivatives automatically using the autodifferentiation package `autograd`, which allows users to pass gradients through arbitrary Python code. It includes a special version of `numpy` (`autograd.numpy`) that has a differentiable back-end. We will thus use this \"special\" verison of `numpy` when we instantiate our arrays and perform numerical operations on them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define the variational free energy as a function of the approximate posterior, an observation, and the generative model\n",
+    "def vfe(qs, obs, likelihood, prior):\n",
+    "    \"\"\"\n",
+    "    Quick docstring below on inputs\n",
+    "    Arguments:\n",
+    "    =========\n",
+    "    `qs` [1D np_auto.ndarray]: variational posterior over hidden states\n",
+    "    `obs` [int]: index of the observation\n",
+    "    `likelihood` [2D np_auto.ndarray]: likelihood distribution P(o|s), relating hidden states probabilistically to observations\n",
+    "    `prior` [1D np_auto.ndarray]: prior over hidden states\n",
+    "    \"\"\"\n",
+    "\n",
+    "    likelihood_s = likelihood[obs,:]\n",
+    "\n",
+    "    joint = likelihood_s * prior\n",
+    "\n",
+    "    vfe = qs @ (np_auto.log(qs) - np_auto.log(joint))\n",
+    "\n",
+    "    return vfe\n",
+    "\n",
+    "# initialize an observation, an initial variational posterior, a prior, and a likelihood matrix\n",
+    "obs = 0\n",
+    "init_qs = np_auto.array([0.5, 0.5])\n",
+    "prior = np_auto.array([0.5, 0.5])\n",
+    "likelihood_dist = np_auto.array([ [0.8, 0.2],\n",
+    "                        [0.2, 0.8] ])\n",
+    "\n",
+    "# this use of `partial` creates a version of the vfe function that is a function of Qs only, \n",
+    "# with the other parameters (the observation, the generative model) fixed as constant parameters\n",
+    "vfe_qs = partial(vfe, obs = obs, likelihood = likelihood_dist, prior = prior)\n",
+    "\n",
+    "# By calling `grad` on a function, we get out a function that can be used to compute the gradients of the VFE with respect to its input (in our case, `qs`)\n",
+    "grad_vfe_qs = grad(vfe_qs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have a variational free energy function, and a derivative function that will give us the gradients of the VFE, with respect $Q(s)$, we can use it to perform a gradient descent on VFE, with respect to the parameters of $Q(s)$. In other words, we will implement this discretized differential equation to update the approximate posterior:\n",
+    "\n",
+    "#### $ \\hspace{60mm} Q(s)_{t+1} =Q(s)_{t} - \\frac{\\partial \\mathcal{F}}{\\partial Q(s)_{t}} $\n",
+    "\n",
+    "Where the gradient term $\\frac{\\partial \\mathcal{F}}{\\partial Q(s)_{t}}$ will simply be the output of the gradient function `grad_vfe_qs` we've defined above.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# number of iterations of gradient descent to perform\n",
+    "n_iter = 40\n",
+    "\n",
+    "qs_hist = np_auto.zeros((n_iter, 2))\n",
+    "qs_hist[0,:] = init_qs\n",
+    "\n",
+    "vfe_hist = np_auto.zeros(n_iter)\n",
+    "vfe_hist[0] = vfe_qs(qs = init_qs)\n",
+    "\n",
+    "learning_rate = 0.1 # learning rate to prevent gradient steps that are too big (overshooting)\n",
+    "for i in range(n_iter-1):   \n",
+    "\n",
+    "    dFdqs = grad_vfe_qs(qs_hist[i,:])\n",
+    "\n",
+    "    ln_qs = np_auto.log(qs_hist[i,:]) - learning_rate * dFdqs # transform qs to log-space to perform gradient descent\n",
+    "    qs_hist[i+1,:] = maths.softmax(ln_qs) # re-normalize to make it a proper, categorical Q(s) again\n",
+    "\n",
+    "    vfe_hist[i+1] = vfe_qs(qs = qs_hist[i+1,:]) # measure final variational free energy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since we were storing the history of the variational free energy over the course of the gradient descent, we can plot its trajectory below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Gradient descent on VFE')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg4AAAGWCAYAAAAQZguKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABFp0lEQVR4nO3deZxcVZn/8c9TvaTTSzpbp7OShGwQAgnQBAmOBBAIjBhgdARn2FwQBQXHDZ1xZH46iuIuKIMOioggCghq2IZNAYEEyB5CQhJIJyELnaSz9vr8/ri3kkpR1Xv3reX7fr3qdesu59Zz63ZXPXXOueeauyMiIiLSEbGoAxAREZHsocRBREREOkyJg4iIiHSYEgcRERHpMCUOIiIi0mFKHERERKTDlDiIhMzsKTNzM7ssafnscPm6aCKLjpmtC499dtSxiEhmUOIgPcLMSszs42Z2r5mtNbPdZtZgZm+Z2RNm9nUzOybqOHOFmV1mZteb2YyoY5FDheflejMbGHUsPcHMTg2TRzezmR0sMyj8/3czuzJh+bqEfbX1mJG0v46UiT8G9uw7IMkKow5Asp+ZnQv8DzAiYfF+YA9QBZwaPv7DzB4DPuzu2/o80K7bC6wENkQdSILLgFOAdcDCKAORd/haOP0VsCO6MHrMU8AbwFjgEuDFDpS5ECgGGoDfpVi/B9jdRvmmNMvrgX3tvHZru9FJt6jGQbrFzD4K/JEgaVgJfAQY6e793X0wwYfH8cBXgY3AGcDoaKLtGnd/0d2PcPfTo45FpK95MLzwr8PZC82sqAPFLgmnD7r79hTrv+vuw9t4LEuz32vaKTfc3es7e4zSOUocpMvM7DjgpwR/Rw8AM9z9l+6+Kb6Nu7e4+8vu/g1gPPAN0v+aEJHMFE8chgDntLWhmU0C3hXO3t6bQUk0lDhId3yDoEbhDeBf3X1/Wxu7e6O7fzX510Ry50MzO9vMHjKzLWbWambXJmx7opl9y8yeN7MNZtYYbvewmX2gvYDNbE7Y52KnmdWH+7m4nTLtdo40s3Fm9hMzW2lme81sl5m9ZGZfMrOyNGXibbLjzOwwM/u5mdWGbcNrzey7ZjYgqcxlZuYEzRQAv0xq300bYxux/0v4Puw2s7rw/fnHDpYtN7OvmNn88D3db2arzOzHZjYmTZlYeBxPmtnbZtZkZlvNbJmZ3WZmc9KUMzP7kJn9xYK+Mw3h38BfzeyzZjYkTbl3m9ndCe/t22b2f2Z2kZlZiu2T/x5PNrM/m9k2M9tnZovM7Orksmb2q/DcxK1NOje/6sh7mvQ+fdTMng7Py/7w7+JWM5uYpkyXYm+Pu68Gng1nL2lr24T1m4FHOvM6kiXcXQ89Ov0AxgAePj7bzX3NDvezDvhc+LwV2A40A9eG25UnvKYDjQRtnonL/qeN1/lCwnbx/beE898jaMt14LJ08aXZ7wUE7a7xfe8laNuNzy8GqlOUi6+fC7wdPq8nqJGJr5sPFCWU+RDwVnjsDuwM5+OP+Z18729KeK2W8D1pDec/E54TB2anKHtkwnoP496dMF8HnJyi3J1J52xH0vv1fIoylcBjbZy/d5y3sNy3k16rPqnMXUCsjb/Hywj+BlvDOBP39cOkcj8Kz0F8/dakc/OjTpyXUoIv3cS/9cTX3wfMbed/qcOxdzCmj4dlG4BBabYxYG243fdSrI//vVzfyddOe4716PtH5AHokZ0P4F8T/pknd3Nf8Q+7feEH3c2EX7RACTA6fF4K/IWg49XI+Ac+MBC4GtgV7ueDKV7j3Rz8QrwDGJ5QNv7lEv9wvSxNfOtS7PeE8EO9GbgBOCz88CwATgSeD8s+kqJs/P3bDjwOTAuX9yPoK7I/XP+pFGWf6u4HKfAvCTHcCAwMl1cTVDE3EnRie0fiQPBFHv+CuB84FigM140jqNp2gi/MgQnl3sPBJOVaoCJcbgT9ZC4laP9OjvXPHEzKPpMQazEwDfgvkr5IgWvCMluATyaUKQE+SNDnxoEvpznfewi+JH/Cwb/HgcCPOZi8HNXGeR3XjXNzS7iP/cAngH7h8snAkwnxTe7J2NuJqZKDCfKVabY5JeH4p6dYvw4lDln/iDwAPbLzAfw3B7/srZv7mp3wwfDbbuzn4nAfT6ZY93i47olU8QK/SPfhRNuJwzO0UesCDCK4GsOBmqR18ddbGv9iSFr/k3jMKdY91Z0PUoIv6lXhPn6VZn3iL/zZSeu/ES7/Y7rzT5DkOfD5hGVfDJc91IlYz0n4spvTwTIDCRLJJmBmmm3eFe6zDihO8/f48zRlF4fr/zPFum4lDgRXL8RrRT6RYn0psDpc/+s2/pc6HXsHYrsrLPtcmvX/G65/Jc36deH63RxaG5P4+Hgb72lyDVvy45ddec/16NxDfRykqwaH0x0e/mcnM7N/D9uikx8/amO/N3Yjpj+F03eZWUFCHIMJLgcF+HaaeL/Z2RczswnAyQTJ0y2ptvGgR/lD4ewZaXb1fXdvSLH8j+F0Wmdj64AZQLyd/FvJK8P3qK335NJw+oN055/gSwYOPe54j/dhZtbRz594m/kj7v5wB8v8E0HT1jPunvLyQXd/HlhDkNwdn2Y/73hvQg+E0944NxcQ9D97iyChPYS77wW+E9828W89SW/EHu/seFJyPwsz6w98IGm7dMoIarZSPVL2CQoNaKNcNcG5lF6mcRykN1UQ/DMnq0yz/T5gUVs7NLNCgi+tDwLTCRKY4qTNSgg+QOJjRRxL8Au6laCG4B3cfY2ZrSfou9FRs8JpMUFHuHTblYfTdPuen2Z5fNyI3vgwPC6cbnH3lWm2eY6gCeaQz4mw02P8ktrfm1m66+bj5yXxuP+PoAnkOOApM7uVoEZlYxuxxnvoz2tjm2Txc3Oimb3VxnbxBHgM8PekdXXuviZNub44N39z95Y02zwRTsuAKcDypPW9FftjBE08Iwlq+L6WsO48gi/2ZuC37eznv9z9+i68/uXu/qsulJMepBoH6aq6cDowXQ9td7/O3S3+IOgU15a33T3t4C1mVg48TfAr7CxgOEGV7laCHtybEzZP/NVSFU53uvueNl6/swM8xQe8KqDtX0HxWErT7GdXmuXxq1R6I8GPvydpjzmsBUk1UFfiQF9VtP/r78Bxe9A7/5MESeI/EPQ32RBeLfAzMzs2xevFk8832zmmVDH2byO+aiA+JkGqc5PuvMDBc9ORMQ06q91zA9Sm2D5Rr8QeJjK/CWcvTvrfj9cMPezuWzq7b8keShykq1aE0xJgUg/tM92vq7ivEvyS3EZQ61Dt7qXuPszdhwOjErbt1OVmXSwT//95JTFBauNxWRdiilqq9yTxc6OyA8c9LrGwu99GMKbHtQTV5m8TdKi8EnjJzL7SA3HHY/xBB8/Nr3rgNXtavzbWpWse6gvxZojxBJ2OMbPhHGyS0tgNOU6Jg3TV0wnPO3TNfw/4YDj9tLv/OsWvmlTNIhDUSABUmlm6X/1w6C/pjojXcEwKm1CySfw9GZluAzMrJhjwJ1lizc7Urry4u2929x+5+3kEv5hnElydYUDyfU3irze2Ey8RL9Ol+CIWPzdtHW9i88/WtFv1AndfDiwIZ+NjoPwLQc3bdg72NZIcpcRBusTd13Ow0981YTNCb4u3q7+SZv170yx/heAXWozwF1IyMxtPcCllZ8TbxMuBMztZtrviTTpdqVkBeDmcVpvZ5DTbzCJFM4m7r+XgF/MFXXz9xP25u88nSAxreed5ej6ctjliYZL4uTkl3cBQvSheG9Ddc3NiG4nuaeF0D8FQ730tXqvwz2ZWwsFmirvTdPSVHKLEQbrjPwg6uo0FfhN+gPSmneH06OQVYeLy76kKuXsdBzuTfTFNn4zrOhuMu7/KwS+1b1uaESLD+PqbWVtVz50VvzphYBfLLyS4pA/gS8krw/eorffkV+H0U2Z2ZLqNwtEeKxPmkzuyHhC2n8eHI098r+LDHZ+ZblTJFH5P8KVaQjtX6phZT3dw7O65uY8gMRwCXJG8MkwmvhDfto0OlL3pLoL//UqCz4F4DZGaKfKAEgfpMnd/GfgUwYfcXGChmX3EzA5U+YdfHBPM7AsEHRq747Fw+n0zOyWeAJjZCQTjNAxto+z1BL8ETwd+ZWbVYdlKM/smwQd0V26O82mCgXamAX8zs/fGmy3CIYOPMrP/AF6n800hbYkP231B4hdzR4WXUF4fzn7EzL5t4e2Iw/fmNoJftXvT7OIGgksZy4CnzezSxFonMxtjZh8HXgLOTyj3TTP7g5mdF14mG9++2sx+TNBu7hw81xDUbD1E8Av+XjP7dEKsxWZ2tJl9z8zOSzi+t4Evh7OXm9k9Znbg8kMLbgP/bjO7mYNDKfeU+Lm5pI1LJdNy9zeAW8PZG8zsinjSGdYO/YXgUtq9BONp9Lnw/f1LOBt/n1e6+wtRxCN9LOqBJPTI/gdwLrCJQ4e03UfQ9ro/afk8YEpS+dmkGWApabvDw30mvkZ8iOO9BM0FaQff4Z1DTtcRXDrmdG/I6bM5dEjf+NUIjRx67GOTyrU5UBBBh0En/J5PWncEB4dpbiLogb+OYNyCzpy7xCGnm8P3pKNDTk8kuAwwXr6FoKPj3qTjvjShzA+T1u3kncOGfyXFaw1MOD/x16qj/SGn/yPheJygFiK53NrO/j0SDOfswFMp1l2esO99BPdyWUeKETHb2H8p8GjCfhoJ+g/E5/fTzpDTXYm9k387c5PO25c7UCb+93R9J1+rowNAvQXM6s5x6dH+QzUO0m3u/ieCL/UrCDq4vUHwYT2A4MPuaYLBhI5y93M8/bgB7b3OGoJOdL8hGEa4gOAL+07gBHd/tJ3yNxJ8yT9JkHAUEnTyusTdP9eVmML9PkQwFPA3CNqn9xN80dUTjIXwn8CRHvyS7BEeNJOcATxM8GE6nKDJqFO3LHf3qwmGD3+BIBExgvP1Pnf/cTtlVxOMkfEpgve0joPX8S8mGPnyFIJLLuN+QJCQPAC8Fr5eP2A98DvgPe7+joGn3H0HQQ3IpQRjQdQR9C3ZFMZ7LfBginLfIBjv41aCkTKNoJZkE0EtxicJhgbvMe7+S4L7OrxI8F6MITg3bdWIJe9jL8Hf6seAvxEkY6UE/1u/AI529wfS76FPzONgx8xWDl6m2ZvaGwCqmneO6yI9zMJsTkRERKRdqnEQERGRDlPiICIiIh2mxEFEREQ6TImDiIiIdJgSBxEREemwbBtfv1cVlVX69CN76n5NIiIime2ll17a5u6p7rCalhKHBLEBw3jm7y9QUtTpwd5ERESyjpl1enwZNVUkeX3r7qhDEBERyVhKHJKs2qzEQUREJB0lDgkMeG3zrqjDEBERyVhKHBIUF8Z4TTUOIiIiaSlxSFBSVMCqLapxEBERSUeJQ4J+hTHerNvLvsaWqEMRERHJSEocEpQUFeCuKytERETSUeKQoKQwGL9BzRUiIiKpKXFIUFwUo6jA1EFSREQkDSUOCQwYP7SMVbokU0REJCUlDkkmVVeoxkFERCQNJQ5JJg+rYP12XVkhIiKSihKHJJOry3GH1VtU6yAiIpJMiUOSSdUVgIaeFhERSUWJQ5JxQ0qDKyt0SaaIiMg7KHFIUlgQ4/Ch5axWB0kREZF3UOKQwqTqctU4iIiIpKDEIYXJ1RWsr9vH3sbmqEMRERHJKBmROJjZHDNbaWarzey6FOsHmdn9ZrbYzF40s2ntlTWzwWb2mJmtCqeDOhrP5OpyQFdWiIiIJIs8cTCzAuBm4GxgKnCRmU1N2uwrwEJ3Pwa4BPhRB8peBzzu7pOAx8P5Djl4ZYUSBxERkUSRJw7ATGC1u69x90bgbmBu0jZTCb78cfdXgXFmVt1O2bnA7eHz24HzOhrQ2MGlFBfENPS0iIhIkkxIHEYB6xPma8NliRYBFwCY2UxgLDC6nbLV7r4JIJwOS/XiZnaFmS0wswVbt24Fwisrqso0loOIiEiSTEgcLMUyT5q/ARhkZguBTwOvAM0dLNsmd7/V3WvcvaaqqurA8sm6Z4WIiMg7FEYdAEEtwZiE+dHAxsQN3L0euBzAzAxYGz5K2yi72cxGuPsmMxsBbOlMUJOGlfPgoo3saWimrF8mvE0iIiLRy4Qah/nAJDMbb2bFwIXAg4kbmNnAcB3Ax4C/hslEW2UfBC4Nn18KPNCZoOIdJHVlhYiIyEGRJw7u3gxcDTwCrADucfdlZnalmV0ZbnYksMzMXiW4guKatsqGZW4AzjCzVcAZ4XyHxS/JVD8HERGRgzKiDt7d5wHzkpbdkvD878CkjpYNl78NnN7VmMYOKaO4MMYq1TiIiIgcEHmNQ6YqiBkTqspV4yAiIpJAiUMbJleXs0pXVoiIiBygxKENk6sr2LBjH7sbdM8KERERUOLQpknDgg6SGkFSREQkoMShDfFLMtVcISIiElDi0IbDBpfSrzCmDpIiIiIhJQ5tiF9ZoUsyRUREAkoc2hFcWaEaBxEREVDi0K5J1RVs3LmfXfubog5FREQkckoc2jE53kFSzRUiIiJKHNoTv2eFmitERESUOLRr9KBSSopivKZLMkVERJQ4tEf3rBARETlIiUMHTK6u0CBQIiIiKHHokEnV5bxVv5+d+3RlhYiI5DclDh0weVhwZcVqXVkhIiJ5TolDBxy4JFP9HEREJM8pceiA0YP607+oQFdWiIhI3lPi0AGxmDFxWDmrtqjGQURE8psShw6aVK1LMkVERJQ4dNCkYRVsrm/QlRUiIpLXlDh0kIaeFhERUeLQYfErK9RBUkRE8pkShw4aNTB+ZYVqHEREJH8pceigWMyYVF2uQaBERCSvKXHohEnDKlTjICIieU2JQydMri5ny64Gdu7VlRUiIpKflDh0woEOkhoISkRE8lRGJA5mNsfMVprZajO7LsX6SjP7k5ktMrNlZnZ5uHyKmS1MeNSb2bXhuuvNbEPCunO6G+fEYcElmWquEBGRfFUYdQBmVgDcDJwB1ALzzexBd1+esNlVwHJ3P9fMqoCVZnanu68EZiTsZwNwf0K5H7j7d3sq1lED+1NaXMAqXZIpIiJ5KhNqHGYCq919jbs3AncDc5O2caDCzAwoB+qA5qRtTgded/c3eivQWMyYNExDT4uISP7KhMRhFLA+Yb42XJboJuBIYCOwBLjG3VuTtrkQuCtp2dVmttjMbjOzQale3MyuMLMFZrZg69at7QY7qbpCg0CJiEjeyoTEwVIs86T5s4CFwEiCpombzGzAgR2YFQPvB36fUOZnwIRw+03A91K9uLvf6u417l5TVVXVbrCTq8vZtruB7Xsa291WREQk12RC4lALjEmYH01Qs5DocuA+D6wG1gJHJKw/G3jZ3TfHF7j7ZndvCWsmfk7QJNJtk8IrK1ZpICgREclDmZA4zAcmmdn4sObgQuDBpG3eJOjDgJlVA1OANQnrLyKpmcLMRiTMng8s7YlgD96zQv0cREQk/0R+VYW7N5vZ1cAjQAFwm7svM7Mrw/W3AF8HfmVmSwiaNr7k7tsAzKyU4IqMTyTt+jtmNoOg2WNdivVdMrKyhLLiAt0lU0RE8lLkiQOAu88D5iUtuyXh+UbgzDRl9wJDUiy/uIfDBMDMmKgOkiIikqcyoaki6xxRXcGKt+pxT+7DKSIiktuUOHTBMWMq2bG3ifV1+6IORUREpE8pceiC6aMHArCwdkekcYiIiPQ1JQ5dMGV4BcWFMRav3xF1KCIiIn1KiUMXFBXEOGrkABbX7ow6FBERkT6lxKGLpo8eyJINO2luSR75WkREJHcpceii6WMq2dfUwuqtuixTRETyhxKHLjom7CC5SP0cREQkjyhx6KLxQ8qoKClkkfo5iIhIHlHi0EWxmHHM6EoW65JMERHJI0ocumH66IG8umkX+5taog5FRESkTyhx6IZjRg+kudVZvqk+6lBERET6hBKHbpg+phJQB0kREckfShy6YfiAEoZV9NNAUCIikjeUOHSDmXHM6IEsUgdJERHJE0ocumnGmErWbN3Dzn1NUYciIiLS65Q4dFN8IKilG9RcISIiuU+JQzcdMzroILlQHSRFRCQPKHHopoGlxYwbUqqBoEREJC8ocegBx4weqCsrREQkLyhx6AHTxwxk0879bKnfH3UoIiIivUqJQw+YHvZz0A2vREQk1ylx6AFHjaykIGYaQVJERHKeEoce0L+4gMnVFRoISkREcp4Shx4yfXQli2t34u5RhyIiItJrlDj0kOljBrJzXxNvvL036lBERER6jRKHHnLMgQ6SO6INREREpBdlROJgZnPMbKWZrTaz61KsrzSzP5nZIjNbZmaXJ6xbZ2ZLzGyhmS1IWD7YzB4zs1XhdFBvHsPk6gpKimIsWq8rK0REJHdFnjiYWQFwM3A2MBW4yMymJm12FbDc3acDs4HvmVlxwvpT3X2Gu9ckLLsOeNzdJwGPh/O9pqggxlEjKzWCpIiI5LTIEwdgJrDa3de4eyNwNzA3aRsHKszMgHKgDmhuZ79zgdvD57cD5/VYxGkcM7qSpRt30tzS2tsvJSIiEolMSBxGAesT5mvDZYluAo4ENgJLgGvcPf7t7MCjZvaSmV2RUKba3TcBhNNhvRF8ohljBrK/qZXXNu/u7ZcSERGJRCYkDpZiWfI1jWcBC4GRwAzgJjMbEK472d2PI2jquMrM3tOpFze7wswWmNmCrVu3dirwZPFbbKu5QkREclUmJA61wJiE+dEENQuJLgfu88BqYC1wBIC7bwynW4D7CZo+ADab2QiAcLol1Yu7+63uXuPuNVVVVd06kHFDShlQUqgrK0REJGdlQuIwH5hkZuPDDo8XAg8mbfMmcDqAmVUDU4A1ZlZmZhXh8jLgTGBpWOZB4NLw+aXAA716FEEMTB8zUFdWiIhIzoo8cXD3ZuBq4BFgBXCPuy8zsyvN7Mpws68Ds8xsCcEVEl9y921ANfCMmS0CXgT+4u4Ph2VuAM4ws1XAGeF8rztmdCUrN+9iX2NLX7yciIhInyqMOgAAd58HzEtadkvC840EtQnJ5dYA09Ps823CWoq+NH30QFpaneWbdnL82MF9/fIiIiK9KvIah1wzfcxAADVXiIhITlLi0MOqB5QwfECJOkiKiEhOUuLQC44J75QpIiKSa5Q49ILpYwaydtsedu5tijoUERGRHqXEoRdMjw8EtWFHpHGIiIj0NCUOveDo8Bbbaq4QEZFco8ShF1T2L+LwoWUsXL8j6lBERER6lBKHXhJ0kNwRdRgiIiI9SolDL5k+ZiCb6xt4a+f+qEMRERHpMUocekn8Tpkaz0FERHKJEodectTIARTGTM0VIiKSU5Q49JKSogKmDK/Q0NMiIpJTlDj0omNGD2Rx7Q5aWz3qUERERHqEEodeNGNMJfX7m1n39p6oQxEREekRShx6UbyDpAaCEhGRXKHEoRdNGlZOSVFMV1aIiEjOUOLQiwoLYhw9qpJFGkFSRERyhBKHXnbM6IEs21hPY3Nr1KGIiIh0mxKHXnbCuME0NLfqvhUiIpITlDj0spMOH0LM4NnV26IORUREpNuUOPSyytIipo2q5LnXlTiIiEj2U+LQB2ZNGMorb+5gT0Nz1KGIiIh0ixKHPnDyxCE0tzovrquLOhQREZFuUeLQB2rGDqa4IMZz6ucgIiJZTolDH+hfXMBxYwfy7Oq3ow5FRESkW5Q49JGTJwxl+aZ66vY0Rh2KiIhIlylx6COzJg4F4O+vq9ZBRESylxKHPjJ9dCXl/Qp5VpdliohIFsuIxMHM5pjZSjNbbWbXpVhfaWZ/MrNFZrbMzC4Pl48xsyfNbEW4/JqEMteb2QYzWxg+zunLY0pWWBDjxPGD1UFSRESyWuSJg5kVADcDZwNTgYvMbGrSZlcBy919OjAb+J6ZFQPNwOfc/UjgXcBVSWV/4O4zwse83j6W9syaOJR1b+9lw459UYciIiLSJZEnDsBMYLW7r3H3RuBuYG7SNg5UmJkB5UAd0Ozum9z9ZQB33wWsAEb1Xeidc/LEIQCqdRARkayVCYnDKGB9wnwt7/zyvwk4EtgILAGucfdDbjdpZuOAY4EXEhZfbWaLzew2MxuU6sXN7AozW2BmC7Zu3dq9I2nHlOoKhpYX85w6SIqISJbKhMTBUizzpPmzgIXASGAGcJOZDTiwA7Ny4F7gWnevDxf/DJgQbr8J+F6qF3f3W929xt1rqqqqun4UHWBmnDRhKM+u3oZ78iGKiIhkvkxIHGqBMQnzowlqFhJdDtzngdXAWuAIADMrIkga7nT3++IF3H2zu7eENRM/J2gSidysCUPYsquB17fujjoUERGRTsuExGE+MMnMxocdHi8EHkza5k3gdAAzqwamAGvCPg//C6xw9+8nFjCzEQmz5wNLeyn+Tjl5QjCeg0aRFBGRbBR54uDuzcDVwCMEnRvvcfdlZnalmV0ZbvZ1YJaZLQEeB77k7tuAk4GLgdNSXHb5HTNbYmaLgVOBz/blcaVz2JBSRg/qz7PqICkiIlmoMOoAAMJLJeclLbsl4flG4MwU5Z4hdR8J3P3iHg6zx5w8YSgPLd1ES6tTEEsZvoiISEaKvMYhH82aOIT6/c0s3bAz6lBEREQ6RYlDBGbF+zlo+GkREckyShwiUFXRjynVFTynDpIiIpJllDhEZNbEIcxfV8f+ppaoQxEREekwJQ4ROXnCUBqaW3n5ze1RhyIiItJhShwicuLhgymImZorREQkqyhxiEhFSRHHjK5UB0kREckqShwidPKEoSyu3cmu/U1RhyIiItIhShwiNGviEFpanRfX1kUdioiISIcocYjQcYcNol9hTPetEBGRrKHEIUIlRQWcMG4wz6mfg4iIZAklDhGbNXEIr761i227G6IORUREpF1KHCIWv832c6+ruUJERDKfEoeITRtVyYCSQp7TbbZFRCQLKHGIWEHMeNfhQzSeg4iIZAUlDhlg1oQhrK/bx/q6vVGHIiIi0iYlDhng5InhbbbVXCEiIhmu3cTBzIaZ2bfM7L/NbERfBJVvJg4rZ1hFP55VB0kREclwhW2tNLMY8ChwDODACcCZfRBXXjEzZk0YwjOrt+HumFnUIYmIiKTUXo3DKcDrwKcBA97s9Yjy1KyJQ9m2u5GVm3dFHYqIiEha7SUOJwK/cPebgUHAx3s/pPx0sJ+DmitERCRztZc4HAEsAnD3ne7u8RVm9mxvBpZvRg3sz7ghpRrPQUREMlp7icMEIN032WE9HEvemzVxKC+sraO5pTXqUERERFJqL3GoBErSrPM0y6WL3j1xKLsbmnnpje1RhyIiIpJSe4lDCfCwmX3EzMb2RUD57D2Tq+hXGOOhpW9FHYqIiEhK7SUOMYIOkj8H1pjZajO7xcw+1Puh5Z/yfoWcMrmKh5ZuorVVFToiIpJ52kscdhJchkk4PZzgyorfAqPM7AUz+4qZHdWLMeaVfzxmBJvrG3hlvZorREQk87SXONQCXwdKgdOB7wIrCJIIIxgQ6uvAYjNbYWafN7OyzgZhZnPMbGVYo3FdivWVZvYnM1tkZsvM7PL2yprZYDN7zMxWhdNBnY0rCqcdMYzighjzlqi5QkREMk97icOzwHZ3b3D3J939i+4+DRgLfBL4E7CXIImYAnwbWGJm4zoagJkVADcDZwNTgYvMbGrSZlcBy919OjAb+J6ZFbdT9jrgcXefBDwezme8ipIi3jN5KA8t2UTC1a8iIiIZob3E4ffAzOSF7r7e3f/H3ecCgwmGof4hsAYYB3y/EzHMBFa7+xp3bwTuBuYmvyRQYcFYzOVAHdDcTtm5wO3h89uB8zoRU6TOnjaCjTv3s3D9jqhDEREROUSbiYO7rwXeTFEDkLhNk7v/n7v/W/jrfi7wrk7EMApYnzBfGy5LdBNwJLARWAJc4+6t7ZStdvdNYYybgGGdiClS751aTVGB6eoKERHJOB25rfZXgausg3decvc/Af/diRhS7Te5jv4sYCEwEpgB3GRmAzpYtu0XN7vCzBaY2YKtW7d2pmivqexfxLsnDmWemitERCTDtJs4hDUKV3knvsHCe1t0VC0wJmF+NEHNQqLLgfs8sBpYSzAcdltlN8dvAx5Ot6SJ9VZ3r3H3mqqqqk6E3bvOPnoEtdv3sWTDzqhDEREROaAjNQ69bT4wyczGm1kxcCHwYNI2bxJc1YGZVRN0xFzTTtkHgUvD55cCD/TqUfSwM6dWUxgzXV0hIiIZJfLEwd2bgauBRwgu9bzH3ZeZ2ZVmdmW42deBWWa2hOAKiS+5+7Z0ZcMyNwBnmNkq4IxwPmsMLC1m1sShPLRUzRUiIpI5CqMOAMDd5wHzkpbdkvB8I8GVGx0qGy5/m7CWIludM2041923hOWb6jlqZGXU4YiIiERf4yDpnXnUcApixrwlm6IORUREBFDikNEGlxVz0uFDmLfkLTVXiIhIRlDikOHOPno4a7ftYeXmXVGHIiIiosQh0505dTgxQ1dXiIhIRlDikOGqKvoxc/xg9XMQEZGMoMQhC/zj0SNYvWU3q9RcISIiEVPikAXOOmo4puYKERHJAEocssCwASWcMFbNFSIiEj0lDlninKOHs3LzLlZv2R11KCIikseUOGSJOdNGAPDwUtU6iIhIdJQ4ZInhlSUcP3aQ+jmIiEiklDhkkbOnDWf5pnrWbdsTdSgiIpKnlDhkkbOPDpor5qm5QkREIqLEIYuMGtifGWMG8pCaK0REJCJKHLLMOUcPZ8mGnbz59t6oQxERkTykxCHLnB1eXfGQmitERCQCShyyzJjBpRwzupJ5S9VcISIifU+JQxY6e9oIFq3fQe12NVeIiEjfUuKQhc45ejgAD6vWQURE+pgShyw0dkgZR40coHtXiIhIn1PikKXOOXoEL7+5g00790UdioiI5BElDlnqnHAwqPte3hBxJCIikk+UOGSp8UPLOOnwIfz2hTdpafWowxERkTyhxCGLXXLSWDbs2MeTr26JOhQREckTShyy2HunVlM9oB93PP9G1KGIiEieUOKQxYoKYnx45liefm2r7pgpIiJ9QolDlrtw5hgKY8adL6jWQUREep8ShyxXPaCEs44azj0Latnf1BJ1OCIikuMyInEwszlmttLMVpvZdSnWf8HMFoaPpWbWYmaDzWxKwvKFZlZvZteGZa43sw0J687p8wPrIxefNJad+5p4cNHGqEMREZEcF3niYGYFwM3A2cBU4CIzm5q4jbvf6O4z3H0G8GXgaXevc/eVCcuPB/YC9ycU/UF8vbvP64vjicKJ4wczubqc36iTpIiI9LLIEwdgJrDa3de4eyNwNzC3je0vAu5Ksfx04HV3z7tvTzPj4neNZXHtThau3xF1OCIiksMyIXEYBaxPmK8Nl72DmZUCc4B7U6y+kHcmFFeb2WIzu83MBqXZ5xVmtsDMFmzdurXz0WeI844dRVlxAXf8Pe/yJhER6UOZkDhYimXphkI8F3jW3esO2YFZMfB+4PcJi38GTABmAJuA76Xaobvf6u417l5TVVXVydAzR0VJEecfN4o/Ld5I3Z7GqMMREZEclQmJQy0wJmF+NJCul1+qWgUI+ke87O6b4wvcfbO7t7h7K/BzgiaRnHbxu8bR2NzK7xesb39jERGRLsiExGE+MMnMxoc1BxcCDyZvZGaVwCnAAyn28Y5+D2Y2ImH2fGBpj0WcoaYMr2Dm+MH85oU3aNX9K0REpBdEnji4ezNwNfAIsAK4x92XmdmVZnZlwqbnA4+6+yFDJIb9Hs4A7kva9XfMbImZLQZOBT7baweRQS45aSzr6/bx9GvZ219DREQyl7nrl2lcTU2NL1iwIOowuqWxuZWTv/0ER4+q5LbLTog6HBERyWBm9pK713SmTOQ1DtKzigtjXHTCGJ5cuYX1dXujDkdERHKMEoccdNGJhxEz4ze6f4WIiPQwJQ45aERlf844spp75q/X/StERKRHKXHIUZecNJbte5v4y+JNUYciIiI5RIlDjjppwhAOryrjDt2/QkREepAShxwVv3/FwvU7WFK7M+pwREQkRyhxyGH/dPxo+hcVcMfz66IORUREcoQShxw2oKSI844dxQMLN7Jzb1PU4YiISA5Q4pDjLn7XWBqaW/n9S7p/hYiIdJ8Shxw3deQAasYO4jfP6/4VIiLSfUoc8sDFJ41l3dt7+dvqbVGHIiIiWU6JQx6YM204wyr6cdMTq9C9SUREpDuUOOSBfoUFfPr0Scxft52ndNdMERHpBiUOeeJDNWM4bHApNz68Un0dRESky5Q45IniwhifPWMSyzfVM2+phqEWEZGuUeKQR94/fRRTqiv4/qOv0dzSGnU4IiKShZQ45JGCmPG5MyezZtse7n25NupwREQkCylxyDNnTK1mxpiB/PD/VumW2yIi0mlKHPKMmfHFs6awaed+7nzhzajDERGRLKPEIQ/NmjiUkycO4eYnV7O7oTnqcEREJIsocchTXzjrCOr2NHLbM2ujDkVERLKIEoc8NWPMQM6cWs3P/7qG7Xsaow5HRESyhBKHPPb5s6awu7GZW55+PepQREQkSyhxyGOTqys4f8YofvXcOjbX7486HBERyQJKHPLcZ8+YTKs7P358VdShiIhIFlDikOfGDC7lwhMO43fz1/PG23uiDkdERDKcEgfh06dNpLDA+MFjr0UdioiIZLiMSBzMbI6ZrTSz1WZ2XYr1XzCzheFjqZm1mNngcN06M1sSrluQUGawmT1mZqvC6aC+PKZsMmxACZfNGs8Dizby6lv1UYcjIiIZLPLEwcwKgJuBs4GpwEVmNjVxG3e/0d1nuPsM4MvA0+5el7DJqeH6moRl1wGPu/sk4PFwXtK48pTDKe9XyHcfUa2DiIikF3niAMwEVrv7GndvBO4G5rax/UXAXR3Y71zg9vD57cB53Qky1w0sLeYT7zmc/1uxmZff3B51OCIikqEyIXEYBaxPmK8Nl72DmZUCc4B7ExY78KiZvWRmVyQsr3b3TQDhdFiPRp2DLj95PEPLi7nx4ZW4e9ThiIhIBsqExMFSLEv3rXUu8GxSM8XJ7n4cQVPHVWb2nk69uNkVZrbAzBZs3bq1M0VzTlm/Qq46dSJ/X/M2z65+O+pwREQkA2VC4lALjEmYHw1sTLPthSQ1U7j7xnC6BbifoOkDYLOZjQAIp1tS7dDdb3X3Gnevqaqq6vJB5IoPn3gYowb257/+tIyGZt12W0REDpUJicN8YJKZjTezYoLk4MHkjcysEjgFeCBhWZmZVcSfA2cCS8PVDwKXhs8vTSwn6fUrLOAb509j1ZbdGhRKRETeIfLEwd2bgauBR4AVwD3uvszMrjSzKxM2PR941N0TRymqBp4xs0XAi8Bf3P3hcN0NwBlmtgo4I5yXDjh1yjA+ePxobnl6DYtrd0QdjoiIZBBTJ7iDampqfMGCBe1vmAd27mvirB/8lcr+RTz46ZPpV1gQdUgiItLDzOylpKEM2hV5jYNkpsr+RXzrgqNZuXkXNz2xOupwREQkQyhxkLROPWIYHzh+ND996nWW1O6MOhwREckAShykTV/9x6kMLS/m879fRGNza9ThiIhIxJQ4SJsqSxObLHSVhYhIvlPiIO067YhqLjhuFDc/9TpLN6jJQkQknylxkA752vuOYkiZmixERPKdEgfpkMrSIr55/tG8+tYubnpSV1mIiOQrJQ7SYe+dWs0Fx47ip0+uVpOFiEieUuIgnfKf505lUFkxX/jDYjVZiIjkISUO0ikDS4v55vlHs2JTPT99Sk0WIiL5RomDdNoZU6s5b8ZIbnpiNcs31kcdjoiI9CElDtIlXzv3KAaWBldZNLWoyUJEJF8ocZAuGVRWzDfPn8byTfW6l4WISB5R4iBdduZRwzn/2FH8+IlVPL5ic9ThiIhIH1DiIN3y3+dPY9rISj5z1yus2KT+DiIiuU6Jg3RLaXEhP7+khvKSQj52+wK27mqIOiQREelFShyk24ZXlvCLS07g7T0NXHHHAvY3tUQdkoiI9BIlDtIjjh5dyQ8/NINX3tzBF/+wGHePOiQREekFShykx8yZNoIvnDWFBxdt5Ce60kJEJCcVRh2A5JZPzZ7A61t38/3HXuPwqjLed8zIqEMSEZEepBoH6VFmxrcuOJqasYP43D2LWLh+R9QhiYhID1LiID2uX2EB/3Px8VRV9OPjv17Axh37og5JRER6iBIH6RVDyvtx22UnsK+xhY/dvoA9Dc1RhyQiIj1AiYP0msnVFdz04WN59a16Pvu7hbS26koLEZFsp8RBetXsKcP46vum8ujyzXznkZVRhyMiIt2kqyqk1102axyrt+zmlqdf5/CqMv65ZkzUIYmISBcpcZBeZ2Zc//6jeOPtvXz5viX0K4wxd8aoqMMSEZEuUFOF9Imighg/+9fjqBk7iGt/t5A7X3gj6pBERKQLMiJxMLM5ZrbSzFab2XUp1n/BzBaGj6Vm1mJmg81sjJk9aWYrzGyZmV2TUOZ6M9uQUO6cvj0qSVZRUsTtH5nJqVOG8e/3L+WWp1+POiQREemkyBMHMysAbgbOBqYCF5nZ1MRt3P1Gd5/h7jOALwNPu3sd0Ax8zt2PBN4FXJVU9gfxcu4+ry+OR9pWUlTALf96PO87ZgQ3PPQqNz7yqu5rISKSRTKhj8NMYLW7rwEws7uBucDyNNtfBNwF4O6bgE3h811mtgIY1UZZyQDFhTF+dOGxlPcr5OYnX2f3/ma+du5RxGIWdWgiItKOyGscCL7o1yfM14bL3sHMSoE5wL0p1o0DjgVeSFh8tZktNrPbzGxQmn1eYWYLzGzB1q1bu3gI0lkFsWBo6o//w3hu//sbfP4Pi2huaY06LBERaUcmJA6pfmamq7s+F3g2bKY4uAOzcoJk4lp3rw8X/wyYAMwgqJX4Xqoduvut7l7j7jVVVVVdCF+6ysz4yjlH8m9nTOa+lzdw1W9fpqG5JeqwRESkDZmQONQCiRf2jwY2ptn2QsJmijgzKyJIGu509/viy919s7u3uHsr8HOCJhHJMGbGZ06fxH++byqPLNvMx25fwN5GDU8tIpKpMiFxmA9MMrPxZlZMkBw8mLyRmVUCpwAPJCwz4H+BFe7+/aTtRyTMng8s7YXYpYd85N3jufEDx/Ds6m1c/L8vsnNfU9QhiYhICpEnDu7eDFwNPAKsAO5x92VmdqWZXZmw6fnAo+6+J2HZycDFwGkpLrv8jpktMbPFwKnAZ3v/aKQ7Plgzhps/fByLa3dw0a3Ps213Q9QhiYhIEtOlcAfV1NT4ggULog4j7z392lY+cccCRlb259ZLapg4rDzqkEREcpKZveTuNZ0pE3mNg0iyUyZXccdHT2THvibO/ckz3PtSbdQhiYhISImDZKQTxg1m3mf+gaNHV/K53y/i879fpE6TIiIZQImDZKzhlSX89mMn8unTJnLvy7XMvelZXtu8K+qwRETymhIHyWiFBTE+d+YU7vjIiWzf28T7b3qGe+av1zDVIiIRUeIgWeHdk4Yy75p3c9xhg/jivYv57O8WsqdBTRciIn1NiYNkjWEVJdzx0RP5tzMm8+CijZz7k2dYvrG+/YIiItJjlDhIVimIBSNN3vmxd7G7oZnzfvosd77whpouRET6iBIHyUonTRjCvGv+gRPHD+bf71/Kp+96hR17G6MOS0Qk5ylxkKw1tLwft18+ky/OmcJDS99i9nef4jfPv0FLq2ofRER6ixIHyWqxmPGp2RP5y2fezZTqCv7jj0t5/03PsGBdXfuFRUSk05Q4SE44YvgA7r7iXfzkomOp29PIB275O//2u4Vsqd8fdWgiIjlFiYPkDDPj3Okjefxzp3DVqRP48+JNnPa9p7n1r6/T2NwadXgiIjlBiYPknNLiQr5w1hE8+tn3MHP8YL4571Xm/Oiv/PW1rVGHJiKS9ZQ4SM4aN7SM2y47gdsuq6Gl1bnkthe54tcLWF+3N+rQRESylhIHyXmnHVHNI9e+hy+cNYW/rdrGe7//NF//83I27dwXdWgiIlnHNHDOQTU1Nb5gwYKow5BetHHHPr77yEoeWLSRmMF5M0bxiVMmMHFYedShiYj0OTN7yd1rOlVGicNBShzyx/q6vfzib2u4e/56GltaOWvqcD45ewLTxwyMOjQRkT6jxKGblDjkn227G7j9uXXc/tw66vc3M2vCED45ewLvnjgUM4s6PBGRXqXEoZuUOOSv3Q3N3PXCm/zimTVsrm9g2qgBfPKUicyZNpyCmBIIEclNShy6SYmDNDS38MdXNnDL02tYu20P44eWcclJY5k7YxSDy4qjDk9EpEcpcegmJQ4S19LqPLrsLW55+nUW1e6kqMA4dcowPnD8aGZPGUZxoS5IEpHs15XEobC3ghHJZgUx4+yjR3D20SN49a167n2plvtf2cijyzczuKyY908fyQeOH81RIweoL4SI5BXVOCRQjYO0pbmllb+u2sq9L23gseWbaWxp5YjhFfzTcaOZe+xIhlWURB2iiEinqKmim5Q4SEft2NvInxZv4g8v1bJo/Q4KYsYpk6uYO2MksycPo7K0KOoQRUTapcShm5Q4SFes3rKLP7y0gftfqWVzfQMFMeP4sYM4/YhhnH7kMCZUlas5Q0QykhKHblLiIN3R0uosqt3BEyu28PirW1ixqR6AwwaXclqYRMwcP5h+hQURRyoiElDi0E1KHKQnbdixjydf3cITr27h2dXbaGhupay4gH+YVMVpRwxj9pQqhg1QvwgRiU7WJg5mNgf4EVAA/MLdb0ha/wXgX8LZQuBIoMrd69KVNbPBwO+AccA64J/dfXtbcShxkN6yr7GF517fxuOvbuGJFVt4q34/AOOGlHLCuMHBY/xgxg0pVbOGiPSZrEwczKwAeA04A6gF5gMXufvyNNufC3zW3U9rq6yZfQeoc/cbzOw6YJC7f6mtWJQ4SF9wd5ZtrOe517fx4trtLHijjh17mwAYWt6PE8YNombcYGaOG8yRIyooLNCYESLSO7J1HIeZwGp3XwNgZncDc4GUiQNwEXBXB8rOBWaH290OPAW0mTiI9AUzY9qoSqaNquSK90Brq/P61t3MX7ed+evqmL+ujoeWvgVAWXEBx40dxHGHDWLaqEqOGjmAEZUlqpUQkchkQuIwClifMF8LnJhqQzMrBeYAV3egbLW7bwJw901mNqwngxbpKbGYMam6gknVFXz4xMMA2LRzH/PXbWfBujpeXFvHj59YRbxycGBpEVNHDGDqiAEcNWoAU0dUcnhVGUWqmRCRPpAJiUOqn07p2k/OBZ5197oulE394mZXAFcAHHbYYZ0pKtJrRlT25/3T+/P+6SMB2NPQzKtv1bN8Yz3LNwXTO55/g4bmVgCKC2NMqa7gqJEDOHLEACYOK2f80DKGDyghppt0iUgPyoTEoRYYkzA/GtiYZtsLOdhM0V7ZzWY2IqxtGAFsSbVDd78VuBWCPg6dD1+k95X1K+T4sYM5fuzgA8uaW1pZs20PyzfWs2zjTpZvqufhZW9x9/yDlXD9iwoYP7SM8VVlTAinhw8tZ3xVGQNKNEiViHReJnSOLCTo4Hg6sIGgg+OH3X1Z0naVwFpgjLvvaa+smd0IvJ3QOXKwu3+xrVjUOVKynbuzub6BNVt3s2bbHtZs3cPabcHz9XV7aU34dx9a3o/Dq8oYM6iUUQNLGDWoP6MGljJqUH9GVJZQUqTxJkRyXVZ2jnT3ZjO7GniE4JLK28Iv/ivD9beEm54PPBpPGtoqG66+AbjHzD4KvAl8sG+OSCQ6ZsbwyhKGV5Ywa+LQQ9Y1NrfyZt0eXt+6h7Xb9rBm627WbtvDc69vY3P9/kOSCggSi1GD+jN6YH9GDerPyMoShlf2p6qiH8Mq+lFV0U/JhUgeirzGIZOoxkHyVVNLK2/t3M+GHfvYsH3fodPw0Rj2p0g0oKSQYQNKDiQSwyr6MayihKqKfgwt78egsiIGlxUzqLRYSYZIBsrKGgcRiV5RQYwxg0sZM7g05Xp3Z9vuRjbX72frrga27IpPG9hSH8y//OZ2ttQ3HOiwmay0uIBBpcUMKitiUGnxgYQivmxASRED+heG02C+oqSQ0uICXX4qkkGUOIhIu8yMqrBWoS3uTv3+Zrbu2s/buxvZvreRuj1NbN/byPY9jdSF0+17m3izbi91exrZtb+5zX0WxIwBJYWHJBNl/QopKy6grF8h5f2C+dLiggPPy8P5+PL+xQX0LyqgpKiAfoUxJSIi3aDEQUR6jJlR2b+Iyv5FTOzgyCmNza3s3NfErv1N1O9vDqb7mqnf30T9vqZwGszv2t9M/b4m6vbsZW9jC3samtnd0Jy2liOVmAVXm/QvDhKJ/kUFlIbP+xUVUFIYo1+YYPQrjB1INvoVFtCvKHZgfXFBjKLCGMUFwXZFBTGKC4NHUYEdsqyoIEZRLEZRoVEYC9YreZFspcRBRCJVXBjrUG1GW5paWtnb0MLuxmb2hsnEnoaWMKloYW9jC/saW9jX1ML+pnC+qYX94XRfuGznvia2NLXQ0NxKQ3za3EpDcwtNLT3bH6wwZhQWWJBUFMQojMWfGwXh84KYURgL5gvDbZLXxeLbWLCuIGFZzA6Wj4XbHJhaMPhYQcLymAU1PDELHgWxIBmMP49ZkPDEy1v4mjEL1hFO4/NGvDwH9g+GJawP9knwwIjFgmmwzcHtD9mWhDIHXidheVDs0HneuS3hPsLND1kfvvKB5ySWO/D84H4P7uPQZblIiYOIZL2ighiVpTEqS3tvbIrmllYaW1ppaGplf3MLjc2tNLUEiUXw3A9d1tJKU3zaEqxvammlOfF5q4frWmlucRrDaUur09zaSkur05Qw39TSyt7G+LzT3NJKizut4fyBqR/cJnlZ8tUz0jcSE5Rg3rAU64NtDplJ9fSQ5CZ5WXm/Ql789/d2N+S0dFVFAjPbBayMOo5eNBTYFnUQvSiXjy+Xjw10fNlOx5e9prh7RWcKqMbhUCs7e1lKNjGzBTq+7JTLxwY6vmyn48teZtbpMQh0VxwRERHpMCUOIiIi0mFKHA51a9QB9DIdX/bK5WMDHV+20/Flr04fmzpHioiISIepxkFEREQ6TIkDYGZzzGylma0Ob8GdU8xsnZktMbOFXelBm2nM7DYz22JmSxOWDTazx8xsVTgdFGWM3ZHm+K43sw3hOVxoZudEGWN3mNkYM3vSzFaY2TIzuyZcnvXnsI1jy4nzZ2YlZvaimS0Kj++/wuVZf+6gzePLifMHYGYFZvaKmf05nO/0ucv7pgozKwBeA84AaoH5wEXuvjzSwHqQma0Datw9J65DNrP3ALuBX7v7tHDZd4A6d78hTP4GufuXooyzq9Ic3/XAbnf/bpSx9QQzGwGMcPeXzawCeAk4D7iMLD+HbRzbP5MD58+C4RDL3H23mRUBzwDXABeQ5ecO2jy+OeTA+QMws38DaoAB7v6+rnx2qsYBZgKr3X2NuzcCdwNzI45J2uDufwXqkhbPBW4Pn99O8GGdldIcX85w903u/nL4fBewAhhFDpzDNo4tJ3hgdzhbFD6cHDh30Obx5QQzGw38I/CLhMWdPndKHIJ/6vUJ87Xk0D96yIFHzewlM7si6mB6SbW7b4Lgwxvo4C2WssrVZrY4bMrIyqrgZGY2DjgWeIEcO4dJxwY5cv7Cqu6FwBbgMXfPqXOX5vggN87fD4EvAol3hev0uVPicOjw33E5k2GGTnb344CzgavCqnDJLj8DJgAzgE3A9yKNpgeYWTlwL3Ctu9dHHU9PSnFsOXP+3L3F3WcAo4GZZjYt4pB6VJrjy/rzZ2bvA7a4+0vd3ZcSh6CGYUzC/GhgY0Sx9Ap33xhOtwD3EzTP5JrNYftyvJ15S8Tx9Ch33xx+oLUCPyfLz2HYfnwvcKe73xcuzolzmOrYcu38Abj7DuApgvb/nDh3iRKPL0fO38nA+8M+b3cDp5nZb+jCuVPiEHSGnGRm482sGLgQeDDimHqMmZWFnbQwszLgTGBp26Wy0oPApeHzS4EHIoylx8X/sUPnk8XnMOyA9r/ACnf/fsKqrD+H6Y4tV86fmVWZ2cDweX/gvcCr5MC5g/THlwvnz92/7O6j3X0cwffcE+7+r3Th3OX9Ta7cvdnMrgYeAQqA29x9WcRh9aRq4P7g84xC4Lfu/nC0IXWPmd0FzAaGmlkt8DXgBuAeM/so8Cbwwegi7J40xzfbzGYQNKOtAz4RVXw94GTgYmBJ2JYM8BVy4xymO7aLcuT8jQBuD69GiwH3uPufzezvZP+5g/THd0eOnL9UOv1/l/eXY4qIiEjHqalCREREOkyJg4iIiHSYEgcRERHpMCUOIiIi0mFKHERERKTDlDiI5CAL7ojqZjY76lh6k5mNC49zXdSxiOQLJQ4ieSK8NbCHd9rMCmb2VD4kQCLZJO8HgBKRrLYBOBJoijoQkXyhxEFEspa7NxEMeSwifURNFSJ5wMycYOhqgK+F1f+equkivL/JF81svpnVm9k+M1sWNnWUp9j3gSYQMxtrZr80s1ozazazH4bbFJnZxWZ2l5mtNLNdZrbXzJab2bfNbHDSPmeHMZ8SLnoyKebZ4XZt9nEI4/mpma0xswYz225mT5rZh9Nsn3gs1Wb2P+GxNJjZWjO7wcxKOvi2i+Qk1TiI5IfbCW4JPB1YBCxMWHfguZmNJrhvy1RgK/B3YD9wAkHicb6ZzXb37SleYxLwSrj9swSfLzvCddXAr4HtBDUEC4EBQA3wReADZnaiu28Lt38rjHlOWPaRcBkJ69tkZicCDwMDgbUEd4YdQpCMzDazOcClnnrc/THAS4ABz4Wxvhv4UvjevL+91xfJWe6uhx565NiD4EY8DsxOWHZ9uOz6NGXiX5IO/AQoTVjXH7gjXPerpHLx/TrwS6A4xb4rgHOBoqTl/YHbwrI/S1HuqeTjSFo/Lly/Lml5CcENexz4AVCQsG4asDlc94k2juXnicdC0JdiV7ju5KjPsR56RPVQU4WIxM0BTgKeB65x973xFe6+D7gS2AL8i5kNSlG+DviMuzcmr3D3Xe7+Jw/6JCQu3wdcDTQD/9RjRxLc4W8M8AbwRXdvSXjNpQQJAsDn05RfT9KxuPsKguQJ4PQejFUkq6ipQkTizgmn97p7a/JKd99jZgvC7U4AHk3a5DF339XWC5jZsQRfuuOAMoJaDoBGoMrMBnnqZpDOiveNuDM5WQn9ErgZmGhmo9x9Q9L6J8KkJlm8I+bIHohRJCspcRCRuMPD6Y1mdmM721alWPZGuo3DTpV30n7fgAEE/SC6a1Q4XZtqpbvvN7ON4XajCC7rTPRmmv3Wh1N1kJS8pcRBROIKwunTBH0k2pIqSUj1Cz3uWwRJw3LgOmABsC1eGxB+iY/gYA1Ed8X3k6rjY/I2qbyjxkVEAkocRCRufTj9vbvf3MP7/mA4/VDYx+AAMysDhvfw69WG08NTrQwvqRwRzibXNohIG9Q5UiR/xDv6pfvB8FA4/WCa9d0RH6dhfYp1Hyb9r//2Yk7n6XB6kZmlKntp+JqrU/RvEJE2KHEQyR/xL8gj06z/I8HYBaeY2S3JgzIBmNnhZnZVF1473qnwkLJmVkPQjJFOezGn83uCJGU88C0zO/BZZ2ZTgf8KZ7/byf2K5D0lDiL54xFgL3CBmf01HOHxF2b2foDwSorzgCXAJ4B1Zva3cLTHx8xsJfA68NUuvPb/C6f/bWYLw30+DbwQxpWuY+X94fRGM3swjPcXZjalrRdz9/3APxMMQPV54LXwNR8hGKSqmuDSylu7cCwieU2Jg0iecPe3gPcRDKp0DEF1/UeB4xK2qQVmEoyt8ApwFMH4CtMIBj/6LnBBF177D8CpwJME4yucS3AFxbXAxW2UexD4FEGNxXvDeD/Kwf4Jbb3m8wSjZd5C0PHzAuBEgnEq/pX0o0aKSBtM/zciIiLSUapxEBERkQ5T4iAiIiIdpsRBREREOkyJg4iIiHSYEgcRERHpMCUOIiIi0mFKHERERKTDlDiIiIhIhylxEBERkQ5T4iAiIiId9v8B2x4QpoJhQcAAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(8,6))\n",
+    "plt.plot(vfe_hist)\n",
+    "plt.ylabel('$\\\\mathcal{F}$', fontsize = 22)\n",
+    "plt.xlabel(\"Iteration\", fontsize = 22)\n",
+    "plt.xlim(0, n_iter)\n",
+    "plt.ylim(vfe_hist[-1], vfe_hist[0])\n",
+    "plt.title('Gradient descent on VFE', fontsize = 24)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial F = 0.916\n",
+      "==================\n",
+      "Final posterior:\n",
+      "[0.8 0.2]\n",
+      "==================\n",
+      "Final F = 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "final_qs, initial_F, final_F = qs_hist[-1,:], vfe_hist[0], vfe_hist[-1]\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'Initial F = {initial_F.round(3)}')\n",
+    "print('==================')\n",
+    "\n",
+    "print('Final posterior:')\n",
+    "print(f'{final_qs.round(1)}') # note that because of numerical imprecision in the gradient descent (constant learning rate, etc.), the approximate posterior will not exactly be the optimal posterior\n",
+    "print('==================')\n",
+    "print(f'Final F = {vfe_qs(final_qs).round(3)}')\n",
+    "print('==================')\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "24ee14d9f6452059a99d44b6cbd71d1bb479b0539b0360a6a17428ecea9f0810"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.10 64-bit ('pymdp_env2': conda)",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/notebooks/global.db b/docs/notebooks/global.db
index 646c9abe..a9210459 100644
Binary files a/docs/notebooks/global.db and b/docs/notebooks/global.db differ
diff --git a/docs/notebooks/pymdp_fundamentals.ipynb b/docs/notebooks/pymdp_fundamentals.ipynb
index 43549d44..a3e70994 100644
--- a/docs/notebooks/pymdp_fundamentals.ipynb
+++ b/docs/notebooks/pymdp_fundamentals.ipynb
@@ -37,7 +37,11 @@
       "source": [
         "## *Very brief* `pymdp` and active inference background\n",
         "\n",
-        "`pymdp` is a Python library, written primarily in [NumPy](https://numpy.org/), for solving **P**artially-**O**bserved **M**arkov **D**ecision *P*rocesses (POMDPs) using active inference, a modelling framework for perception, learning and action, originally derived from the Free Energy Principle and its application to modelling human and animal behavior. The mathematics underlying applying active inference to POMDPs is comprehensively summarized in the following two papers: [*Active Inference: A Process Theory*](https://direct.mit.edu/neco/article-abstract/29/1/1/8207/Active-Inference-A-Process-Theory) and [*Active Inference in Discrete State Spaces: A Synthesis*](https://www.sciencedirect.com/science/article/pii/S0022249620300857)\n",
+        "`pymdp` is a Python library, written primarily in [NumPy](https://numpy.org/), for solving **P**artially-**O**bserved **M**arkov **D**ecision *P*rocesses (POMDPs) using active inference, a modelling framework for perception, learning and action, originally derived from the Free Energy Principle. POMDP models have traditionally been used in disciplines ranging from control theory and robotics, to biological fields concerned with empirically modelling human and animal behavior. \n",
+        "\n",
+        "For a theoretical overview of active inference and the motivations for developing this package, please see our companion paper: [\"pymdp: A Python library for active inference in discrete state spaces\"](https://arxiv.org/abs/2201.03904).\n",
+        "\n",
+        "More in-depth coverage of applying active inference to POMDPs can be found in the following two papers: [*Active Inference: A Process Theory*](https://direct.mit.edu/neco/article-abstract/29/1/1/8207/Active-Inference-A-Process-Theory) and [*Active Inference in Discrete State Spaces: A Synthesis*](https://www.sciencedirect.com/science/article/pii/S0022249620300857)\n",
         "\n",
         "Below are links to a few useful papers, talks, and blog posts that concern active inference and the free energy principle more broadly:\n",
         "\n",
@@ -49,7 +53,7 @@
         "*   Paper: [*A free energy principle for the brain*](https://www.fil.ion.ucl.ac.uk/~karl/A%20free%20energy%20principle%20for%20the%20brain.pdf) by Karl Friston\n",
         "* Paper: [*A Step-by-Step Tutorial on Active Inference and its Application to Empirical Data*](https://psyarxiv.com/b4jm6/) by Ryan Smith and Christopher Whyte\n",
         "\n",
-        "Also see [Jared Tumiel's blog post](https://jaredtumiel.github.io/blog/2020/10/14/spinning-up-in-ai.html) and [Beren Millidge's github repository](https://github.com/BerenMillidge/FEP_Active_Inference_Papers) for a more exhaustive collection of materials related to active inference and the free energy principle.\n"
+        "Also see [Jared Tumiel's blog post](https://jaredtumiel.github.io/blog/2020/10/14/spinning-up-in-ai.html) and [Beren Millidge's github repository](https://github.com/BerenMillidge/FEP_Active_Inference_Papers) for more literature and pedagogical materials related to active inference and the free energy principle.\n"
       ]
     },
     {
diff --git a/docs/notebooks/using_the_agent_class.ipynb b/docs/notebooks/using_the_agent_class.ipynb
index 6d4d280c..74edc257 100644
--- a/docs/notebooks/using_the_agent_class.ipynb
+++ b/docs/notebooks/using_the_agent_class.ipynb
@@ -12,7 +12,7 @@
         "\n",
         "This tutorial introduces the `Agent` class, the main API offered by `pymdp` that allows you to abstract away all the mathematical nuances involved in running active inference processes. All you have to do is build a generative model in terms of `A`, `B`, `C`, and `D` arrays, plug them into the `Agent()` constructor, and then start running active inference processes using the desired functions of the `Agent` class, like `self.infer_states()` and `self.infer_policies()`. \n",
         "\n",
-        "We demonstrate the use of the `Agent` class by building an active inference agent to play a simple explore/exploit task, what we call the \"epistemic 2-armed bandit\""
+        "We demonstrate the use of the `Agent` class by building an active inference agent to play a simple explore/exploit task, what we call the \"epistemic 2-armed bandit\". The task structure is identical to the \"explore/exploit\" task described in Smith et al. (2022): [\"A Step-by-Step Tutorial on Active Inference Modelling and its Application to Empirical Data\"](https://www.sciencedirect.com/science/article/pii/S0022249621000973). The task is a modified version of a classic multi-armed bandit problem, with particular changes that make it well suited to demonstrating the information-availing nature of active inference in discrete state spaces."
       ]
     },
     {
@@ -24,7 +24,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 1,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -40,7 +40,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": 2,
       "metadata": {
         "id": "hk0kXw1RRmTf"
       },
@@ -64,7 +64,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 2,
+      "execution_count": 3,
       "metadata": {
         "id": "Y0QiIF8SWxot"
       },
@@ -135,7 +135,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": 4,
       "metadata": {
         "id": "LE3k-jsQKAt3"
       },
@@ -153,13 +153,22 @@
       "source": [
         "## **Explore/exploit task with a epistemic two-armed bandit**\n",
         "\n",
-        "Now we're going to build a generative model for an active inference agent playing a two-armed bandit task. The [multi-armed bandit](https://en.wikipedia.org/wiki/Multi-armed_bandit) is a classic decision-making task that captures the core features of the the \"explore/exploit tradeoff\". This problem formulation is ubiqutious across various disciplines that study decision-making under uncertainty, including economics, neuroscience, machine learning, and engineering.\n",
+        "Now we're going to build a generative model for an active inference agent playing a two-armed bandit task. The [multi-armed bandit](https://en.wikipedia.org/wiki/Multi-armed_bandit) (or MAB) is a classic decision-making task that captures the core features of the the \"explore/exploit tradeoff\". The multi-armed bandit formulation is ubiquitous across problem spaces that require sequential decision-making under uncertainty -- this includes disciplines ranging from economics, neuroscience, machine learning, engineering all the way to advertising.\n",
+        "\n",
+        "In the standard MAB problem formulation, an agent has must choose between mutually-exclusive alternatives (also known as 'arms') in order to maximize reward over time. The probability of reward depends on which arm the agent chooses. A common real-world analogy for a MAB problem is imagining a special slot machine with three possible levers to pull (rather than the usual one), where playing each lever has different probabilities of payoff (e.g. getting a winning combination of symbols or bonus). In fact, the 'standard' slot machine, which usually only only one lever, was historically referred to as a 'one-armed bandit' -- this was the direct ancestor of the name for the generic machine learning / decision-making problem class, the MAB. \n",
         "\n",
-        "The agent has to make choices among mutually exclusive alternatives or 'arms' in order maximize rewards, which issue probabilistically from each arm. However, the reward statistics of each arm are in general unknown or only partially known. The agent must entertain _beliefs_ about the reward statistics. \n",
+        "Crucially, MAB problems are interesting and difficult because in general, the reward statistics of each arm are unknown or only partially known. In a probabilistic or Bayesian context, an agent must therefore act based on _beliefs_ about the reward statistics, since they don't have perfect access to this information. \n",
         "\n",
         "The inherent partial-observability  of the ask creates a conflict between **exploitation** or choosing the arm that is _currently believed_ to be most rewarding, and **exploration** or gathering information about the remaining arms, in the hopes of discovering a potentially more rewarding option.\n",
         "\n",
-        "The fact that expected reward or utility is contextualized by _beliefs_ -- i.e. which arm is currently thought to be the most rewarding -- motivates the use of active inference in this context. This is because the key objective function for action-selection, the expected free energy $\\mathbf{G}$, depends on the agent's beliefs about the world. And not only that, but expected free energy balances the desire to maximize rewards with the drive to resolve uncertainty about unknown parts of the agent's model. The more accurate the agent's beliefs are, the more faithfully decision-making can be guided by maximizing expected utility or rewards.\n"
+        "The fact that expected reward or utility is contextualized by _beliefs_ -- i.e. which arm is currently thought to be the most rewarding -- motivates the use of active inference in this context. This is because the key objective function for action-selection, the expected free energy $\\mathbf{G}$, depends on the agent's beliefs about the world. And not only that, but expected free energy balances the desire to maximize rewards with the drive to resolve uncertainty about unknown parts of the agent's model. The more accurate the agent's beliefs are, the more faithfully decision-making can be guided by maximizing expected utility or rewards.\n",
+        "\n",
+        "#### **MAB with an epistemic twist**\n",
+        "\n",
+        "In the MAB formulation we'll be exploring in this tutorial, the agent must choose to play among two possible arms, each of which has unknown reward statistics. These reward statistics take the form of Bernoulli distributions over two possible reward outcomes: \"Loss\" and \"Reward\". However, one of the arms has probability $p$ of yielding \"Reward\"\" and probabiliity $(1-p)$ of yielding \"Loss\". The other arm has swapped statistics. In this example, agent knows that the bandit has this general reward structure, except they don't know *which* of the two arms is the rewarding one (the arm where reward probability is $p$, assuming $p \\in [0.5, 1]$).\n",
+        "\n",
+        "However, we introduce an additional feature in the environment, that induces an explicit trade-off in decision-making between exploration (information-seeking) and exploitation (reward-seeking). In this special \"epistemic bandit\" problem, there is an additional action available to the agent, besides playing the two arms. We call this third action \"Get Hint\", and allows the agent to acquire information reveals (potentially probabilistically) which arm is the more rewarding one. There is a trade-off here, because by choosing to acquire the hint, the agent forgoes the possibility of playing an arm and thus the possibility of getting a reward at that moment. The mutual exclusivity of hint-acquisition and arm-playing imbues the system with an explore/exploit trade-off, which active inference is particularly equipped to handle, when compared to simple reinforcement learning schemes (e.g. epsilon-greedy reward maximization).\n",
+        "\n"
       ]
     },
     {
@@ -175,7 +184,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": 5,
       "metadata": {
         "id": "vOEYkFPt4gbC"
       },
@@ -209,12 +218,15 @@
         "id": "k4Tca2bJ4o0z"
       },
       "source": [
-        "### The `A` array"
+        "### The `A` array\n",
+        "---\n",
+        "\n",
+        "**Note**: Unlike in [Tutorial 1: Active inference from scratch](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/active_inference_from_scratch.html), here we we will be building a more complex generative model more than one hidden state factor and observation modality. This leads to accordingly higher-dimensional `A` and `B` arrays. See [pymdp fundamentals](https://pymdp-rtd.readthedocs.io/en/latest/notebooks/pymdp_fundamentals.html) for more details on how we specify these high-dimensional arrays in `NumPy`."
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": 6,
       "metadata": {
         "id": "zQsDxB8v6bvF"
       },
@@ -238,7 +250,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 6,
+      "execution_count": 7,
       "metadata": {
         "id": "daovgh4A6m5c"
       },
@@ -271,14 +283,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 7,
+      "execution_count": 8,
       "metadata": {
         "id": "zIWcFelA7RqY"
       },
       "outputs": [
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAF1CAYAAAAa4wqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAVFklEQVR4nO3cebQkZXmA8ecdhkFwBpDFZdgGwaASDAgCnrggmghGBTFxBcSFxR1X1MRkUMQliZoTxQAuKCigRCKQE3cdQFFAReMICALjAAPIJowDYfvyx/ddqGm6+/a9cy+XeXl+58zxdld111ddVU9XVzdGKQVJ0upt1kwPQJK06oy5JCVgzCUpAWMuSQkYc0lKwJhLUgIP6phHRImIrSf52Csi4jkDpj09Ii7uN29EvC8iPju5EU94jC+KiKURsTwidhhh/t0i4soHYmxTJSKOi4gjhkxfHhGPfSDHNJOi+kJE3BQR507TMg6IiLOn47n14DXlMW9hvK0dpNe2g3nuVC9nVZRSziqlbDNg2pGllNcBRMSC9oYye5qG8i/Am0opc0spv+iduCpvZuN5sBzwbd0vG2Xe8V6PB8s6jeNpwF8Bm5ZSdl7VJ5vufTQiFkbECdPx3KuzyZxYTefxDNN3Zv6CUspc4MnATsA/9M4wjYFcnWwBLJ7pQegBtQVwRSnlTxN9oMeMhiqlTOk/4ArgOZ3b/wyc0f4uwBuBS4DL230HApcCNwKnAfM7jy3AW4DLgOvbc81q07YCvg/c0KZ9GVi/ZxzvBX4D3AR8AXhYm7YbcGW/MQMLgRPa379vY1je/j2zjXO7zmMfCawANu7zWsyivpEtAa4DvgSsB6zVnq8AfwJ+1+exZ3amLwdeOjZu4B3t+ZYBr+48Zi3q2f7vgWuB/wDW7vPcTwBuB+5uz30zsGX737HX91jgus5jjgcObX/Pb9vqxrbtDhyyPxwHfBr4b+BW4KfAVj3beOvx5u33eoywTk9pr8Manfn2AX7Z2danACe35f0c+IvOvPOB/wT+AFwOvKUzbWfgfOCWtoyPj3BsvLZnjIePeAysdMz0PGfvPvpU4ADg7LYv3NTGvmfnMesBn2v7z1XAEd3XqDPfHsAdwJ3tuX8JPAv438483wHO69w+C9i7s01+2LbFYuCFQ16bLds2vhX4btsPTuhM/xpwDfDHNt+2PfvYUcD/tHH+CHg08Mm2/hcBO4yyXfuM63nUhtzaXqt3Ag8HbgPu6bzu89s+cU5b32XAp4A5w/Zf4PnABe0xPwae1Fn2YW2ZtwIXA88eun+tarz7rPwV3BfGzdpG/GBnx/wOsAGwNrA7NcRPpobo34Eze3bkH7T5Nwd+C7yuTdua+nF1LWDj9mJ9smccv25j2KBt4CPKxGK+oI1hdmfeo4CPdm6/FTh9wGvxGupB+lhgLvB14Ph+IRvw+JWmt3HfBXwAWLPtaCuAR7Tpn6DGYANgHnA68OEBz30AcHafMOzY/r6Y+ib6hM60HTo75lHAw4DtqQfF7gOWcxz1DXdnYDb1Tfekfus4kXknsE6/YeWQnQq8o7Ot7wT+tr2e76Qe3GtS34h/BvwjMKdtw8uA57bHngPs1/6eC+w64vGx0hgZ7Ri495jp83wLuP8+ekBbrwOBNYDXA1cD0XkNjqZG6ZHAucDBA8a7kJWjujb1DWmj9jpdSw3OvDbtNmDDNu1S4H3t9dudGqVtBiznHOqbzxzqpahbepb7mraMtaiRvqBnH7se2JG6T36/bcf92/ofAfygzTt0u/YZ1zLg6e3vRwBP7teQdt+OwK7UfXcBcCHtBGjA8bwD9aRslzbOV1FbtBawDbCU9sbenm+rfmO89/lG2QEn8q8NZuzMaAn1oF+7szK7d+b9HPCxzu25bSdc0Jl/j870NwDfG7DcvYFf9IzjkM7t59HOgHs3BBOL+S7UsI0dGOcDLxkwpu8Bb+jc3qat3+wR49Qv5rf1jOe6tgMF9V2/e9b7VPqczfWLSrvveODt1LOai4GPAYfQOWunvjneDczrPO7DwHEDlnMc8Nme7XBRv3WcyLwTWKfDgC+3vzegvvk9prOtf9KZdxbt4B3bzj3P9V7gC+3vM4HDgY0meHysNEZGOwb6vlEO2UcPAC7t3F6nzfNo4FHA/9F5YwBeTotdn+dfSCeq7b6zqJ9wdgW+DXyVehb/LOBXbZ6nU8+kZ3UedyKwsM8yNqeepKzTue+E3uV2pq3f1me9zn5zbGf6m4ELO7e3A27uHr+DtmufZf0eOBhYt+f+3eiJeZ/HHgqcOmj/BT5DO9Ht3Hcx9QrA1tRj+znAmqPsW9N1DW7vUsp3B0xb2vl7PvWjLQCllOURcQOwCTWwvfMvaY8hIh4F/Bt1p5lHPRBvGrKsex+7KkopP42IFcBuEbGM+qKfNmD2+W253THMph5QV01yCDeUUu7q3F5BDcDG1IP2ZxExNi2o7/ijWgS8kHop50zqR+T9qGdiZ5VS7omI+cCNpZRbO49bQv1uZJBr+ox3KuYdxQnAhRHxcOAl1PVY1pl+7z7S1u9K6nYrwPyIuLkz7xrUkEG9ZPIB4KKIuJx6yeSMSYxvosfAqO59HUspK9o+MZf6hrYmsKyzn8ya4DIWcd8lv0XU4+6Z1DeJRW2e+cDSUso9ncctoa5Xr7F9akXnvqXUEwciYg3gQ8DfUffzsefciHrZBeonhDG39bk9th9twfDt2uvF1EulH4mIXwHvKaWc02/GiPgz4OPUY2Ed6rH+swHPOzaWV0XEmzv3zaGejS+KiEOpb6bbRsS3gLeXUq4e9GQz8dPE0vn7auoKAdAOuA1ZOXSbdf7evD0G4Mj2XNuVUtYF9qXGixEeO5mxdn2xLW8/4JRSyu0D5ltp/bjvDOTa/rOvkuupO+22pZT127/1Sv0iup9+67aI+ua4W/v7bOAvqQfq2EF6NbBBRMzrPG5zJv/mNJXut06llKuoH+H3oW6v43tmuXcfiYhZwKbUdVxK/VSzfuffvFLK89rzXlJKeTn1MsVHgVPa/jtRoxwDg/bD8ab1s5Qa3Y0667VuKWXbCTz/WMyf0f5eRN1HeveTzdprOmbQfrKMuk+t07mve+y+AtiLepa6HvXTCNz/eB/F0O3aq5RyXillL+p2/i/qpxDo/7p8hnp9/nGtSe8bZ4xLgQ/1jGWdUsqJbdlfKaU8jbp/FOp+NtBM/878RODVEbF9RKxFDfRPSylXdOZ5V0Q8IiI2o16fPrndP496OeePEbEJ8K4+z//GiNg0IjYA/r7z2FH9gXoW0Ps76BOAF1GD/qUhjz8ReFtEbNl+nnkkcHLPmfUw1/ZZdl/tDOhY4BMR8UiAiNgkIp475Lk3jYg5nee4hPqGsC+wqJQy9uXei2kHaSllKfWLmg9HxMMi4knUs9QH4udr470e91un5kvAu6kft7/eM23HiNin/VLkUGrofkK9jnxrRBwWEWtHxBoR8ecR8RSAiNg3IjZur/vN7bnuadOuiIgDRlynUY6BYQbto321TyXfBv41ItaNiFkRsVVEPHPAQ64FFvRE+cfUS4Y7A+eWUhZTg7ML9RMd1C+vVwDvjog1I2I34AXASX3GtIR6uXJhRMyJiKe2ecfMo26XG6hnvEeOsq4DDN2uXW0sr4yI9Uopd1Kv4499KrgW2DAi1usZ5y3A8oh4PPW7iq7e/fdY4JCI2KX99wcPj4i/iYh5EbFNROze9onbue8L14FmNObtUsz7qd8sL6P+QuVlPbN9g/pR5QLqrxw+1+4/nPql0R/b/b0HKcBXqDvuZcDvqF+ETGR8K6gf734UETdHxK7t/qXUj8aFwR/PAD5PPRM8k/qFzO3U63mjWgh8sS37JSPMfxj1S6efRMQt1F8F9P09PfVLosXANRFxfef+RdRLOUs7t4POpQDqNdYF1LOvU4F/GnJZbSotZPjrMWidTqXG5tSej/JQ96+XUi8V7AfsU0q5s5RyN/WXBttTt931wGepZ4ZQrxEvjojl1Mt9Lyul3NbeSDakviGMa8RjYNjj++6j49if+nF+7JdepwCPGTDv19r/3hARP2/L/BN1f1hcSrmjTT8HWFJKua7Ncwc1yHtSX7ujgP1LKRcNWM4rqd/x3EA9Tk+mBhzqm/ES6ln9bxjxte1nhO3aaz/ginY8HdLGSVuPE4HL2us+n/oF+iuoX/Qey/1PHhfS2X9LKedTv6T+FHU7XEr9vgPql6AfaeO7hvrJ4L3D1m3sSzxNUER8Hri6lHK/39DrwScifkf9xcZ3O/ctpH4hte8ULudpwBvbJRhNUkScTP3y+59meiyrC/8jhEmIiAXUa7Dj/if4mnkR8WLqp6jvT/eySilnU79r0AS0yxw3Us+W/5p6jfwjMzqo1Ywxn6CI+CDwNurvty+f6fFouIj4IfBE6m/Ch15z1Ix6NPVS6YbUX8m8vvT5v7jQYF5mkaQEZvrXLJKkKWDMJSmBab9mHhFex5GkCSqlTOg/ivLMXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEZo83Q0Q8HtgL2KTddRVwWinlwukcmCRpdEPPzCPiMOAkIIBz278AToyI90z/8CRJo4hSyuCJEb8Fti2l3Nlz/xxgcSnlcQMedxBwULu54xSNVZIeMkopMZH5x7tmfg8wv8/9j2nTBg3imFLKTqWUnSYyGEnS5Ix3zfxQ4HsRcQmwtN23ObA18KZpHJckaQKGXmYBiIhZwM6s/AXoeaWUu0daQMTwBUiS7meil1nGjfmqMuaSNHFTfc1ckrQaMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISmD3dCzj99NOnexHSpBx99NEzPQRpynhmLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpTApGMeEa+eyoFIkiZvVc7MDx80ISIOiojzI+L8b37zm6uwCEnSKGYPmxgRvxo0CXjUoMeVUo4BjgE444wzyqRHJ0kaydCYU4P9XOCmnvsD+PG0jEiSNGHjxfwMYG4p5YLeCRHxw+kYkCRp4obGvJTy2iHTXjH1w5EkTYY/TZSkBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBGZP9wKOPvro6V6ENCkHH3zwTA9BmjKemUtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUwLgxj4jHR8SzI2Juz/17TN+wJEkTMTTmEfEW4BvAm4FfR8RenclHTufAJEmjG+/M/EBgx1LK3sBuwPsj4q1tWgx6UEQcFBHnR8T5S5YsmZKBSpIGGy/ms0opywFKKVdQg75nRHycITEvpRxTStmplLLTFltsMVVjlSQNMF7Mr42I7cdutLA/H9gI2G4axyVJmoDxYr4/cE33jlLKXaWU/YFnTNuoJEkTMnvYxFLKlUOm/WjqhyNJmgx/Zy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUrAmEtSAsZckhIw5pKUgDGXpASMuSQlYMwlKQFjLkkJGHNJSsCYS1ICxlySEjDmkpSAMZekBIy5JCVgzCUpAWMuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSkBYy5JCRhzSUogSikzPQZNQEQcVEo5ZqbHIfVy35xZnpmvfg6a6QFIA7hvziBjLkkJGHNJSsCYr368JqkHK/fNGeQXoJKUgGfmkpSAMV9NRMQeEXFxRFwaEe+Z6fFIYyLi8xFxXUT8eqbH8lBmzFcDEbEG8GlgT+CJwMsj4okzOyrpXscBe8z0IB7qjPnqYWfg0lLKZaWUO4CTgL1meEwSAKWUM4EbZ3ocD3XGfPWwCbC0c/vKdp8kAcZcklIw5quHq4DNOrc3bfdJEmDMVxfnAY+LiC0jYg7wMuC0GR6TpAcRY74aKKXcBbwJ+BZwIfDVUsrimR2VVEXEicA5wDYRcWVEvHamx/RQ5H8BKkkJeGYuSQkYc0lKwJhLUgLGXJISMOaSlIAxl6QEjLkkJWDMJSmB/weBXINl7rt9pgAAAABJRU5ErkJggg==",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x432 with 1 Axes>"
             ]
@@ -306,7 +318,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": 9,
       "metadata": {
         "id": "fVnKm0zU8Ng3"
       },
@@ -340,14 +352,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": 10,
       "metadata": {
         "id": "CWKQSusN9Jzk"
       },
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x432 with 1 Axes>"
             ]
@@ -375,7 +387,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": 11,
       "metadata": {
         "id": "VHdgBVSm-mOL"
       },
@@ -392,14 +404,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": 12,
       "metadata": {
         "id": "2O5QpoC8Uc8j"
       },
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x432 with 1 Axes>"
             ]
@@ -427,7 +439,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": 13,
       "metadata": {
         "id": "JSiiIJdu4n9b"
       },
@@ -449,7 +461,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 13,
+      "execution_count": 14,
       "metadata": {
         "id": "lVtIXiyq6EHo"
       },
@@ -475,7 +487,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 14,
+      "execution_count": 15,
       "metadata": {
         "id": "--5HyEYt42Q8"
       },
@@ -501,7 +513,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": 16,
       "metadata": {
         "id": "ib54P_VFvjk0"
       },
@@ -513,14 +525,14 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 16,
+      "execution_count": 17,
       "metadata": {
         "id": "4JlKcepO_KgA"
       },
       "outputs": [
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -554,7 +566,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 17,
+      "execution_count": 18,
       "metadata": {
         "id": "MJTKm27fv_Rf"
       },
@@ -596,7 +608,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 18,
+      "execution_count": 19,
       "metadata": {
         "id": "ls9VoZX__0Vp"
       },
@@ -618,7 +630,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 19,
+      "execution_count": 20,
       "metadata": {
         "id": "LjxoLs67AXwR"
       },
@@ -686,7 +698,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 20,
+      "execution_count": 21,
       "metadata": {
         "id": "In-AoaGQDdQH"
       },
@@ -733,14 +745,21 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 21,
+      "execution_count": 22,
       "metadata": {
         "id": "Vy7OXyo8wvY0"
       },
       "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context: Right-Better\n"
+          ]
+        },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -760,7 +779,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -780,7 +799,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -800,7 +819,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -820,7 +839,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -835,12 +854,12 @@
           "output_type": "stream",
           "text": [
             "Action at time 4: Play-right\n",
-            "Reward at time 4: Reward\n"
+            "Reward at time 4: Loss\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -855,12 +874,12 @@
           "output_type": "stream",
           "text": [
             "Action at time 5: Play-right\n",
-            "Reward at time 5: Loss\n"
+            "Reward at time 5: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAATcklEQVR4nO3dfbQcdX3H8ffXhAd5tkZvJYkJhZQShIpeQaut9yjWgEr01Ado9QilRk9Nq8dHVEopVVttLWqlYkQOKpoUbeuJNZqeU1lpi1jgoJSQxnNBMAkoCAS5iIXIt3/MpJ1sdu9uwt679/7yfp2z5+7M/Hbmu7Mzn5n97ezeyEwkSbPf44ZdgCRpMAx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOizTESMRcSWxvCGiBjr87GviIjNETEREScMqJ7FEZERMXcQ83us2tePBi8i3hsRlwy7Du3KQB+CiLgtIh6qg/W+iPhaRCzck3ll5rGZ2eqz+V8DKzPzoMy8YU+WN50i4rKIeH+PNhkRR01XTYMwyJof67zqbfHkSabvcoDMzA9m5h/s6TJ3R0TMiYj3R8QdEfFARNwQEYdNx7JnIwN9eF6WmQcBTwF+DPztNCxzEbBhGpYjDcqfAb8BPAc4BHgd8POhVjSTZaa3ab4BtwEnN4ZPBb7fGN6P6mz6h1RhfzHw+HraGLCl07yoDtDnALcA9wBXAL9Uz28CSOBB4Ja6/buBrcADwCbghV3qfQlwA/BTYDNwfmPa4nq+K4A7gDuBd7Q9l4/W0+6o7+9XTzsT+Pe2ZSVwVD2/R4CH69q/2qGuqxrPaQJ4zY71A7wduKuu56x+1m2X5/4GYGO9jm4GnlGPPwZoAduoDpKnNR5zGXAR8LX6cd8BjuxWcz3+pcB36/ldDRxfj38N8APgkHr4FOBHwJO6zaut/iOBb9bbw0+ALwCH1dM+DzwKPFQ//l1tjz2wnvZoPX0COBw4H7i87fU/q9427gPeBDwLuLF+Pp9om+/v1+v0PmA9sKjLun9Cvcwjh73Pzpbb0AvYG2/sHMIHAJ8FPteYfiGwliqMDwa+CvxFPW2M7oH+FuAaYEEdXJ8CVjfaJnBUff/oegc8vB5e3G3HqZd5HNUB43iqIHx543EJrK4D4Djg7kZNF9Q1PbkOoauBP6+nnUmXQK/vXwa8v8e6/L/2jVq318vdh+pg+TPgCb3WbYd5v4rqgPcsIKgONIvq+Y4D7wX2BV5AFdxHN+q+BzgRmEsVomsmqfkEqoPPScAc4PX167rjwPeFep5PpDoovrTbvDo8h6OAF9Xbw46DwEc7bT+TvPZb2sadz66BfjGwP/DbVGfQX6lf8/n1c3t+3X55ve6OqdfNucDVXZb9W1QHhHdTHcS+D7x52PvvTL4NvYC98VbvRBP1xvpIvZMeV08LqjOuIxvtnwP8oL6/0w7GzoG+kcZZNlV3ziPA3Hq4GZZH1TvaycA+u1n/R4EL6/s7duhfa0z/MPCZ+v4twKmNaS8Gbqvvn8nUBPpDO55zPe4u4Nm91m2Hea8H3tJh/G/WAfO4xrjV1O9c6rovaUw7FfjvSWr+JPVBrjFuUyMED6N6R/FfwKcme/59vHYvB27otP10ab/T9laPO59dA31+Y/o9NN4tAP8AvLW+/3Xg7Ma0x1EdcBd1WPbv1vP+DPB4qpOJu4EXDWI/LPFmH/rwvDwzD6M6q1kJfCsifpnqLOoA4PqI2BYR24Bv1ON7WQT8U+NxG4FfACPtDTNzHHgr1c55V0SsiYjDO800Ik6KiCsj4u6IuJ/qLfW8tmabG/dvp3prTv339i7Tpso9mbm9Mfwz4CB2f90upDogtTsc2JyZjzbG3U51NrrDjzosv5tFwNt31FTXtbBeDpm5DfgS8DTgI5PMZxcRMVK/tlsj4qfA5ez62g3Cjxv3H+owvOP5LwI+1nie91IdaJvrrvk4gAsy86HMvBFYQ3WAVAcG+pBl5i8y8x+pgvd5VP2cDwHHZuZh9e3QrD5A7WUzcErjcYdl5v6ZubXLsr+Ymc+j2skS+FCX+X6RqptiYWYeSvX2OtraNK/SeSrVuw7qv4u6THuQKmABqA9oO5XYpZ49tbvrdjNVH3S7O4CFEdHcf55K1T2zJzYDH2h73Q7IzNUAEfF0qn7n1cDHd3PeH6Raj8dl5iHAa9n5teu1jgf9GmwG3tj2XB+fmVd3aHtjhxoGXU9RDPQhi8pyqg+ANtZnfZ8GLoyIJ9dt5kfEi/uY3cXAByJiUf24J9Xz7rTcoyPiBRGxH1Wf544Pvzo5GLg3M38eESdSvRVu9ycRcUBEHEv1Adnf1+NXA+fWtcwDzqM6SwT4HnBsRDw9IvanerfQ9GPgV3o8537aALAH6/YS4B0R8cz6dTqqXrffoTrrfldE7FN/D+BlVGeP/Wiv+dPAm+p3QhERB0bESyLi4Hq9XE7VX38WMD8i/nCSebU7mKp77/6ImA+8s0ctnWp9YkQc2tcz6+1i4D31dkJEHBoRr+rUMDNvAf4NeF9E7BcRxwCnA/88oFrKM+w+n73xRtVvuePKggeAm4Dfa0zfn+rM6laqK0s2An9cTxtj8qtc3kbV//oAVXfBBxttm/3TxwP/Wbe7l2onObxLva+k6lJ4oG73CXbtQ91xlcuPaFwtUT+Xj1NdbXJnfX//xvT3UZ05b6Y6e2zWuIT/v/LjK11qe1M9323Aq9vXT4d11HXdTjL/TfVrdRNwQj3+WOBbwP1UV7+8ovGYy2j0/Xd4zXaquR63DLi2HncnVRfLwVQf4n698dhfr1+vJd3m1Vb/scD1df3fpbr6p1nLcqr++W00rk5qm8elVP3i2+h+lUvzM4stwFhj+HLg3Mbw66g+D9hx1dSlk6z/+VTdYhP1a/bGYe+/M/kW9UqTJM1ydrlIUiEMdEkqhIEuSYUw0CWpEEP7ydN58+bl4sWLh7X4ojz44IMceOCBwy5D6sptdHCuv/76n2Rmxy/DDS3QFy9ezHXXXTesxRel1WoxNjY27DKkrtxGBycibu82zS4XSSqEgS5JhTDQJakQPQM9Ii6NiLsi4qYu0yMiPh4R4xFxY0Q8Y/BlSpJ66ecM/TKq35no5hSq39xYQvV7Hp987GVJknZXz0DPzKuofgyom+VU/20nM/Ma4LCIeMqgCpQk9WcQly3OZ+d/brClHndne8OIWEF1Fs/IyAitVmsAi9fExITrUjOa2+j0mNbr0DNzFbAKYHR0NL0udTC8xlczndvo9BjEVS5b2fm/1Sxgz/9ziyRpDw3iDH0tsDIi1lD91/L7M3OX7hZprxLt/6Fv7zY27AJmmin6PxQ9Az0iVlO9HvMiYgvwp8A+VU15MbCO6p+2jlP9W66zpqRSSdKkegZ6Zp7RY3oCbx5YRZKkPeI3RSWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRB9BXpELIuITRExHhHndJj+1Ii4MiJuiIgbI+LUwZcqSZpMz0CPiDnARcApwFLgjIhY2tbsXOCKzDwBOB34u0EXKkmaXD9n6CcC45l5a2Y+DKwBlre1SeCQ+v6hwB2DK1GS1I+5fbSZD2xuDG8BTmprcz7wLxHxR8CBwMmdZhQRK4AVACMjI7Rard0sV51MTEy4LmeYsWEXoBltqvbXfgK9H2cAl2XmRyLiOcDnI+Jpmflos1FmrgJWAYyOjubY2NiAFr93a7VauC6l2WOq9td+uly2AgsbwwvqcU1nA1cAZOa3gf2BeYMoUJLUn34C/VpgSUQcERH7Un3oubatzQ+BFwJExDFUgX73IAuVJE2uZ6Bn5nZgJbAe2Eh1NcuGiLggIk6rm70deENEfA9YDZyZmTlVRUuSdtVXH3pmrgPWtY07r3H/ZuC5gy1NkrQ7/KaoJBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVoq9Aj4hlEbEpIsYj4pwubV4dETdHxIaI+OJgy5Qk9TK3V4OImANcBLwI2AJcGxFrM/PmRpslwHuA52bmfRHx5KkqWJLUWT9n6CcC45l5a2Y+DKwBlre1eQNwUWbeB5CZdw22TElSLz3P0IH5wObG8BbgpLY2vwoQEf8BzAHOz8xvtM8oIlYAKwBGRkZotVp7ULLaTUxMuC5nmLFhF6AZbar2134Cvd/5LKHajhcAV0XEcZm5rdkoM1cBqwBGR0dzbGxsQIvfu7VaLVyX0uwxVftrP10uW4GFjeEF9bimLcDazHwkM38AfJ8q4CVJ06SfQL8WWBIRR0TEvsDpwNq2Nl+hfpcZEfOoumBuHVyZkqReegZ6Zm4HVgLrgY3AFZm5ISIuiIjT6mbrgXsi4mbgSuCdmXnPVBUtSdpVX33ombkOWNc27rzG/QTeVt8kSUPgN0UlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQfQV6RCyLiE0RMR4R50zS7nciIiNidHAlSpL60TPQI2IOcBFwCrAUOCMilnZodzDwFuA7gy5SktRbP2foJwLjmXlrZj4MrAGWd2j358CHgJ8PsD5JUp/m9tFmPrC5MbwFOKnZICKeASzMzK9FxDu7zSgiVgArAEZGRmi1WrtdsHY1MTHhupxhxoZdgGa0qdpf+wn0SUXE44C/Ac7s1TYzVwGrAEZHR3NsbOyxLl5UG4frUpo9pmp/7afLZSuwsDG8oB63w8HA04BWRNwGPBtY6wejkjS9+gn0a4ElEXFEROwLnA6s3TExM+/PzHmZuTgzFwPXAKdl5nVTUrEkqaOegZ6Z24GVwHpgI3BFZm6IiAsi4rSpLlCS1J+++tAzcx2wrm3ceV3ajj32siRJu8tvikpSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiH6CvSIWBYRmyJiPCLO6TD9bRFxc0TcGBH/GhGLBl+qJGkyPQM9IuYAFwGnAEuBMyJiaVuzG4DRzDwe+DLw4UEXKkmaXD9n6CcC45l5a2Y+DKwBljcbZOaVmfmzevAaYMFgy5Qk9TK3jzbzgc2N4S3ASZO0Pxv4eqcJEbECWAEwMjJCq9Xqr0pNamJiwnU5w4wNuwDNaFO1v/YT6H2LiNcCo8DzO03PzFXAKoDR0dEcGxsb5OL3Wq1WC9elNHtM1f7aT6BvBRY2hhfU43YSEScD7wOen5n/M5jyJEn96qcP/VpgSUQcERH7AqcDa5sNIuIE4FPAaZl51+DLlCT10jPQM3M7sBJYD2wErsjMDRFxQUScVjf7K+Ag4EsR8d2IWNtldpKkKdJXH3pmrgPWtY07r3H/5AHXJUnaTX5TVJIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCjG3n0YRsQz4GDAHuCQz/7Jt+n7A54BnAvcAr8nM2wZb6k4LnLJZz0Zjwy5gpskcdgXSUPQ8Q4+IOcBFwCnAUuCMiFja1uxs4L7MPAq4EPjQoAuVJE2uny6XE4HxzLw1Mx8G1gDL29osBz5b3/8y8MIIT6MlaTr10+UyH9jcGN4CnNStTWZuj4j7gScCP2k2iogVwIp6cCIiNu1J0drFPNrW9V7Nc4mZyG206bFto4u6TeirD31QMnMVsGo6l7k3iIjrMnN02HVI3biNTo9+uly2AgsbwwvqcR3bRMRc4FCqD0clSdOkn0C/FlgSEUdExL7A6cDatjZrgdfX918JfDPTSw0kaTr17HKp+8RXAuupLlu8NDM3RMQFwHWZuRb4DPD5iBgH7qUKfU0fu7E007mNToPwRFqSyuA3RSWpEAa6JBXCQJ/FImJZRGyKiPGIOGfY9UjtIuLSiLgrIm4adi17AwN9lurzJxmkYbsMWDbsIvYWBvrs1c9PMkhDlZlXUV35pmlgoM9enX6SYf6QapE0AxjoklQIA3326ucnGSTtRQz02aufn2SQtBcx0GepzNwO7PhJho3AFZm5YbhVSTuLiNXAt4GjI2JLRJw97JpK5lf/JakQnqFLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklSI/wVGuRyD0IXcMwAAAABJRU5ErkJggg==",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -875,12 +894,12 @@
           "output_type": "stream",
           "text": [
             "Action at time 6: Play-right\n",
-            "Reward at time 6: Reward\n"
+            "Reward at time 6: Loss\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -900,7 +919,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -915,12 +934,12 @@
           "output_type": "stream",
           "text": [
             "Action at time 8: Play-right\n",
-            "Reward at time 8: Loss\n"
+            "Reward at time 8: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAATcElEQVR4nO3dfbBcdX3H8feXhAd5ECzRW0liQiVFw0PFXkFHO95RrAGV6NQHaG2FUlOnTavjU1GRMvjQ0dZiLVSIytCKJqJtnWuJpjOVK2MRCgxKCTHOFcEkqFEgyEUsRL7945yrJ5vdu5uw9+69v7xfMzt3zzm/Pee7vz3ns2d/dx8iM5EkzX37DboASVJ/GOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0OeYiBiJiK2N6Y0RMdLjbV8VEVsiYiIiTupTPUsjIiNifj/W93i19o/6LyLeHRGfHHQd2p2BPgARcVdEPFwH6/0RcU1ELN6bdWXmcZk51mPzvwNWZ+ahmXnr3mxvJkXElRHx/i5tMiKOmama+qGfNT/eddX74qlTLN/tCTIzP5iZf7K329wTEfGKiLi9Plauj4jlM7HducpAH5xXZOahwFOBHwH/OAPbXAJsnIHtSI9bRCwDPgO8CTgC+BIwOlteDc5Kmellhi/AXcCpjenTge80pg+kOpv+PlXYXwY8oV42Amxtty6qJ+jzgO8C9wJXA79Wr28CSOAh4Lt1+78CtgEPApuBF3eo92XArcBPgS3AhY1lS+v1rgLuAX4AvL3lvny0XnZPff3AetnZwNdbtpXAMfX6HgUeqWv/Upu6rmvcpwngdZP9A7wN2F7Xc04vfdvhvr8R2FT30R3As+v5zwTGgB1UT5JnNG5zJXApcE19uxuBp3equZ7/cuCb9fquB06s578O+B7wxHr6NOCHwJM7raul/qcDX633h59QBeQR9bJPA48BD9e3f2fLbQ+plz1WL58AjgIuBK5qefzPqfeN+6kC+DnAbfX9uaRlvX9c9+n9wAZgSYe+Xw1c05jer66n7X7qJQ30gXT6riF8MPDPwL80ll8MjFKF8WFUZyZ/Uy8boXOgvxm4AVhEFVyXA2sbbRM4pr5+bH0AHlVPL50MnTb1jgAn1AfUiVRB+MrG7RJYWwfACcCPGzVdVNf0lDqErgfeVy87mw6BXl+/Enh/l778ZftGrTvr7e5P9WT5M+BJ3fq2zbpfQ/WE9xwgqJ5oltTrHQfeDRwAvIgquI9t1H0vcDIwnypE101R80lUTz6nAPOAN9SP6+QT32fqdR5J9aT48k7ranMfjgFeUu8Pk08CH223/0zx2G9tmXchuwf6ZcBBwO8CPwe+WD/mC+v79sK6/cq6755Z9835wPUdtr0aWN+Ynlev+82DPoZn62XgBeyLl/ogmqA6e3m0PkhPqJcF1RnX0xvtnwd8r76+ywHGroG+icbZC9VwzqPA/Hq6GZbH1AfaqcD+e1j/R4GL6+uTB/QzGss/DHyqvv5d4PTGspcCd9XXz2Z6Av3hyftcz9sOPLdb37ZZ94Z24QH8DtVZ8n6NeWupX7nUdX+ysex04NtT1Pxx6ie5xrzNjRA8guoVxf8Cl091/3t47F4J3Npu/+nQfpf9rZ53IbsH+sLG8ntpvFoA/hV4S339y8C5jWX7UT3hLmmz7WfUj9cI1RPne6leLbyrH8dhiRfH0AfnlZl5BNVZzWrgaxHx61RnUQcDt0TEjojYAXylnt/NEuDfG7fbBPwCGGptmJnjwFuoDs7tEbEuIo5qt9KIOCUiro2IH0fEA1QvqRe0NNvSuH431Utz6r93d1g2Xe7NzJ2N6Z8Bh7LnfbuY6gmp1VHAlsx8rDHvbqqz0Uk/bLP9TpYAb5usqa5rcb0dMnMH8HngeOAjU6xnNxExVD+22yLip8BV7P7Y9cOPGtcfbjM9ef+XAP/QuJ/3UT3RNvsOgMz8NtWrlUuohs4WUA17+S6mDgz0AcvMX2Tmv1EF7wuoxjkfBo7LzCPqy+FZ/QO1my3AaY3bHZGZB2Xmtg7b/mxmvoDqIEvgQx3W+1mqYYrFmXk41cvraGnTfJfO06hedVD/XdJh2UNUAQtA/YS2S4kd6tlbe9q3W6jGoFvdAyyOiObx8zSq4Zm9sQX4QMvjdnBmrgWIiGdRjTuvBT62h+v+IFU/npCZTwRez66PXbc+7vdjsAX405b7+oTMvL7txjO/kJnHZ+aRwF9TvSK4qc81FcNAH7CorASeBGyqz/o+AVwcEU+p2yyMiJf2sLrLgA9ExJL6dk+u191uu8dGxIsi4kCqccnJf361cxhwX2b+PCJOBn6/TZv3RsTBEXEc1T/IPlfPXwucX9eyALiA6iwR4FvAcRHxrIg4iOrVQtOPgN/ocp97aQPAXvTtJ4G3R8Rv14/TMXXf3kh11v3OiNi//hzAK4B1vdTRpuZPAG+qXwlFRBwSES+LiMPqfrmKarz+HGBhRPzZFOtqdRjV8N4DEbEQeEeXWtrVemREHN7TPevuMuBd9X5CRBweEa/p1Lju+3kR8WRgDTBan7mrnUGP+eyLF6pxy8l3FjwI3A78QWP5QVRnVndSvbNkE/CX9bIRpn6Xy1upxl8fpBou+GCjbXN8+kTgf+p29wH/Qf0P0jb1vppqSOHBut0l7D6GOvkulx/SeLdEfV8+RvWS+Qf19YMay99Ddea8herssVnjMn71zo8vdqjtTfV6dwCvbe2fNn3UsW+nWP/m+rG6HTipnn8c8DXgAaphgFc1bnMljbH/No/ZLjXX81ZQnXnuqJd9niqMLwa+3Ljtb9WP17JO62qp/zjglrr+b1K9+6dZy0qq8fkdNN6d1LKOK6jGxXfQ+V0uzf9ZbAVGGtNXAec3pv+Q6v8Bk++aumKK/v86v9pHLwcOGfTxO5svUXeaJGmOc8hFkgphoEtSIQx0SSqEgS5JhRjYl9wsWLAgly5dOqjNF+Whhx7ikEMOGXQZUkfuo/1zyy23/CQz234YbmCBvnTpUm6++eZBbb4oY2NjjIyMDLoMqSP30f6JiLs7LXPIRZIKYaBLUiEMdEkqhIEuSYUw0CWpEF0DPSKuiIjtEXF7h+URER+LiPGIuC0int3/MiVJ3fRyhn4l1TfBdXIa1bfiLaP6xr2PP/6yJEl7qmugZ+Z1VF9d2clKqt/DzMy8ATgiIp7arwIlSb3pxweLFrLrz49tref9oLVhRKyiOotnaGiIsbGxPmxeExMT9qVmNffRmTGjnxTNzDVUvzrC8PBw+smx/vBTeLNQtP5Cn9QwTb9D0Y93uWxj19+TXMTe/7aiJGkv9SPQR4E/qt/t8lzggczcbbhFkjS9ug65RMRaqt9EXBARW6l+eXt/gMy8DFgPnA6MU/1w7jnTVawkqbOugZ6ZZ3VZnsCf960iSdJe8ZOiklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEL0FOgRsSIiNkfEeESc12b50yLi2oi4NSJui4jT+1+qJGkqXQM9IuYBlwKnAcuBsyJieUuz84GrM/Mk4Ezgn/pdqCRpar2coZ8MjGfmnZn5CLAOWNnSJoEn1tcPB+7pX4mSpF7M76HNQmBLY3orcEpLmwuB/4yIvwAOAU7tS3WSpJ71Eui9OAu4MjM/EhHPAz4dEcdn5mPNRhGxClgFMDQ0xNjYWJ82v2+bmJiwL2eZkUEXoFltuo7XXgJ9G7C4Mb2ontd0LrACIDO/EREHAQuA7c1GmbkGWAMwPDycIyMje1e1djE2NoZ9Kc0d03W89jKGfhOwLCKOjogDqP7pOdrS5vvAiwEi4pnAQcCP+1moJGlqXQM9M3cCq4ENwCaqd7NsjIiLIuKMutnbgDdGxLeAtcDZmZnTVbQkaXc9jaFn5npgfcu8CxrX7wCe39/SJEl7wk+KSlIhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIXoK9IhYERGbI2I8Is7r0Oa1EXFHRGyMiM/2t0xJUjfzuzWIiHnApcBLgK3ATRExmpl3NNosA94FPD8z74+Ip0xXwZKk9no5Qz8ZGM/MOzPzEWAdsLKlzRuBSzPzfoDM3N7fMiVJ3XQ9QwcWAlsa01uBU1ra/CZARPw3MA+4MDO/0rqiiFgFrAIYGhpibGxsL0pWq4mJCftylhkZdAGa1abreO0l0HtdzzKq/XgRcF1EnJCZO5qNMnMNsAZgeHg4R0ZG+rT5fdvY2Bj2pTR3TNfx2suQyzZgcWN6UT2vaSswmpmPZub3gO9QBbwkaYb0Eug3Acsi4uiIOAA4ExhtafNF6leZEbGAagjmzv6VKUnqpmugZ+ZOYDWwAdgEXJ2ZGyPioog4o262Abg3Iu4ArgXekZn3TlfRkqTd9TSGnpnrgfUt8y5oXE/grfVFkjQAflJUkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIK0VOgR8SKiNgcEeMRcd4U7X4vIjIihvtXoiSpF10DPSLmAZcCpwHLgbMiYnmbdocBbwZu7HeRkqTuejlDPxkYz8w7M/MRYB2wsk279wEfAn7ex/okST2a30ObhcCWxvRW4JRmg4h4NrA4M6+JiHd0WlFErAJWAQwNDTE2NrbHBWt3ExMT9uUsMzLoAjSrTdfx2kugTyki9gP+Hji7W9vMXAOsARgeHs6RkZHHu3lR7Rz2pTR3TNfx2suQyzZgcWN6UT1v0mHA8cBYRNwFPBcY9R+jkjSzegn0m4BlEXF0RBwAnAmMTi7MzAcyc0FmLs3MpcANwBmZefO0VCxJaqtroGfmTmA1sAHYBFydmRsj4qKIOGO6C5Qk9aanMfTMXA+sb5l3QYe2I4+/LEnSnvKTopJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RC9BToEbEiIjZHxHhEnNdm+Vsj4o6IuC0i/isilvS/VEnSVLoGekTMAy4FTgOWA2dFxPKWZrcCw5l5IvAF4MP9LlSSNLVeztBPBsYz887MfARYB6xsNsjMazPzZ/XkDcCi/pYpSepmfg9tFgJbGtNbgVOmaH8u8OV2CyJiFbAKYGhoiLGxsd6q1JQmJibsy1lmZNAFaFabruO1l0DvWUS8HhgGXthueWauAdYADA8P58jISD83v88aGxvDvpTmjuk6XnsJ9G3A4sb0onreLiLiVOA9wAsz8//6U54kqVe9jKHfBCyLiKMj4gDgTGC02SAiTgIuB87IzO39L1OS1E3XQM/MncBqYAOwCbg6MzdGxEURcUbd7G+BQ4HPR8Q3I2K0w+okSdOkpzH0zFwPrG+Zd0Hj+ql9rkuStIf8pKgkFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBWip0CPiBURsTkixiPivDbLD4yIz9XLb4yIpX2vVJI0pa6BHhHzgEuB04DlwFkRsbyl2bnA/Zl5DHAx8KF+FypJmtr8HtqcDIxn5p0AEbEOWAnc0WizEriwvv4F4JKIiMzMPtb6KxHTstq5amTQBcw207TbSbNdL4G+ENjSmN4KnNKpTWbujIgHgCOBnzQbRcQqYFU9ORERm/emaO1mAS19vU/zCX82ch9tenz76JJOC3oJ9L7JzDXAmpnc5r4gIm7OzOFB1yF14j46M3r5p+g2YHFjelE9r22biJgPHA7c248CJUm96SXQbwKWRcTREXEAcCYw2tJmFHhDff3VwFenbfxcktRW1yGXekx8NbABmAdckZkbI+Ii4ObMHAU+BXw6IsaB+6hCXzPHYSzNdu6jMyA8kZakMvhJUUkqhIEuSYUw0Oewbl/JIA1aRFwREdsj4vZB17IvMNDnqB6/kkEatCuBFYMuYl9hoM9dv/xKhsx8BJj8SgZp1sjM66je+aYZYKDPXe2+kmHhgGqRNAsY6JJUCAN97urlKxkk7UMM9Lmrl69kkLQPMdDnqMzcCUx+JcMm4OrM3DjYqqRdRcRa4BvAsRGxNSLOHXRNJfOj/5JUCM/QJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqxP8DLXQWXHB4EIIAAAAASUVORK5CYII=",
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAThUlEQVR4nO3dfbBcdX3H8feXBEQeJJbIrYSYUEjRoKB4ATuj4y0+EdQGZ7SCVgvVpkzF6lSraNUy9anWOiIFjZFmUosm1Wpt0CjTmXalDqLAiEjAMFcUcgmKPAS4gIOBb/84J3qy2b27CXuz9/7yfs3s3D3n99tzvnt2z+ec/d19iMxEkjT77TPsAiRJg2GgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCfZSJiLCImGtMbI2Ksz9u+KiI2R8RkRDxnQPUsjoiMiLmDWN7j1b59NHgR8d6IuGTYdWhnBvoQRMTPIuLhOljvjYhvRMTC3VlWZh6bma0+u/8TcG5mHpSZP9id9e1JEbEmIj7Uo09GxNF7qqZBGGTNj3dZ9XPxxVO073SAzMyPZOabd3eduyIiXhkRN9T7ypURsXRPrHe2MtCH55WZeRDwVOAXwD/vgXUuAjbugfVIj1tELAG+AJwDzAMuA9bPlFeDM1JmetnDF+BnwIsb06cBNzemn0B1Nn0bVdivBJ5Yt40BE52WRXWAPg/4CXA38CXgd+rlTQIJPAj8pO7/buB24AFgE/CiLvW+HPgBcD+wGTi/0ba4Xu4KYAtwB/COtvtyQd22pb7+hLrtLOA7betK4Oh6eb8GHqlrv6xDXVc07tMk8Nrt2wd4B3BnXc/Z/WzbLvf9z4Gb6m10I3BCPf8ZQAvYSnWQ/KPGbdYAFwPfqG/3PeCobjXX818BXFcv70rguHr+a4FbgCfV08uAnwNP6bastvqPAv6nfj7cRRWQ8+q2fwMeAx6ub/+uttseWLc9VrdPAocD5wOXtj3+Z9fPjXupAvhE4Pr6/lzUttw/q7fpvcDlwKIu2/5c4BuN6X3qejo+T72kgT6Ujb5jCB8A/Cvw+Ub7BcB6qjA+mOrM5KN12xjdA/3twFXAEVTB9VlgbaNvAkfX14+pd8DD6+nF20OnQ71jwLPqHeo4qiA8vXG7BNbWAfAs4JeNmv6+rumwOoSuBD5Yt51Fl0Cvr68BPtRjW/6mf6PWbfV696U6WD4EPLnXtu2w7NdQHfBOBILqQLOoXu448F5gP+AUquA+plH3PcBJwFyqEF03Rc0nUB18TgbmAH9aP67bD3xfqJd5KNVB8RXdltXhPhwNvKR+Pmw/CFzQ6fkzxWM/0TbvfHYO9JXA/sBLgV8BX6sf8wX1fXth3f/0ets9o9427wOu7LLutwIbGtNz6mW/bdj78Ey9DL2AvfFS70STVGcv2+qd9Fl1W1CdcR3V6P8HwE/r6zvsYOwY6DfROHuhGs75NTC3nm6G5dH1jvZiYN9drP8C4JP19e079NMb7f8I/Et9/SfAaY22lwE/q6+fxfQE+sPb73M9707geb22bYdlX94pPIAXUJ0l79OYt5b6lUtd9yWNttOAH09R82eoD3KNeZsaITiP6hXFj4DPTnX/+3jsTgd+0On506X/Ds+3et757BzoCxrtd9N4tQB8BXh7ff2bwJsabftQHXAXdVj30+vHa4zqwPl+qlcL7xnEfljixTH04Tk9M+dRnTmdC3w7In6X6izqAODaiNgaEVuBb9Xze1kE/GfjdjcBjwIj7R0zc5zqjP584M6IWBcRh3daaEScHBH/GxG/jIj7qF5Sz2/rtrlx/Vaql+bUf2/t0jZd7s7MbY3ph4CD2PVtu5DqgNTucGBzZj7WmHcr1dnodj/vsP5uFgHv2F5TXdfCej1k5lbgy8AzgU9MsZydRMRh9WN7e0TcD1zKzo/dIPyicf3hDtPb7/8i4FON+3kP1YG2ue0AyMwfU71auYhq6Gw+1bCX72LqwkAfssx8NDO/ShW8z6ca53wYODYz59WXQ7L6B2ovm4FljdvNy8z9M/P2Luv+YmY+n2onS+BjXZb7RaphioWZeQjVy+to69N8l87TqF51UP9d1KXtQaqABaA+oO1QYpd6dteubtvNVGPQ7bYACyOiuf88jWp4ZndsBj7c9rgdkJlrASLi2VTjzmuBC3dx2R+l2o7HZeaTgD9hx8eu1zYe9GOwGfiLtvv6xMy8suPKM/8jM5+ZmYcCf0f1XLp6wDUVw0AfsqgsB54M3FSf9X0O+GREHFb3WRARL+tjcSuBD0fEovp2T6mX3Wm9x0TEKRHxBKpxyYepDiqdHAzck5m/ioiTgNd16PP+iDggIo6l+gfZv9fz1wLvq2uZD3yA6iwR4IfAsRHx7IjYn+rVQtMvgN/rcZ/76QPAbmzbS4B3RsRz68fp6Hrbfo/qYPSuiNi3/hzAK4F1/dTRoebPAefUr4QiIg6MiJdHxMH1drmUarz+bGBBRPzlFMtqdzD18F5ELAD+pkctnWo9NCIO6eue9bYSeE/9PCEiDomI13TrXG/7ORHxFKr/CV1Wn7mrk2GP+eyNF6pxy+3vLHgAuAF4faN9f+AjVO9uuJ9q6OSv6rYxpn6Xy19Tjb8+QDVc8JFG3+b49HHA9+t+9wBfp/4HaYd6X001pPBA3e8idh5D3f4ul5/TeLdEfV8upHrJfEd9ff9G+99SnTlvpjp7bNa4hN++8+NrXWo7p17uVuCP27dPh23UddtOsfxN9WN1A/Ccev6xwLeB+6iGAV7VuM0aGmP/HR6zHWqu551Kdea5tW77MlUYfxL4VuO2x9eP15Juy2qr/1jg2rr+66je/dOsZTnV+PxW4J1dtsFqqnHxrXR/l0vzfxYTwFhj+lLgfY3pN1D9P2D7u6ZWT7H9v8Nvn6OfBQ4c9v47ky9RbzRJ0iznkIskFcJAl6RCGOiSVAgDXZIKMbQvuZk/f34uXrx4WKsvyoMPPsiBBx447DKkrnyODs611157V2Z2/DDc0AJ98eLFXHPNNcNafVFarRZjY2PDLkPqyufo4ETErd3aHHKRpEIY6JJUCANdkgphoEtSIQx0SSpEz0CPiNURcWdE3NClPSLiwogYj4jrI+KEwZcpSeqlnzP0NVTfBNfNMqpvxVtC9Y17n3n8ZUmSdlXPQM/MK6i+urKb5VS/h5mZeRUwLyKeOqgCJUn9GcQHixaw48+PTdTz7mjvGBErqM7iGRkZodVqDWD1mpycdFtqRvM5umcMItDbf4oMuvxsVWauAlYBjI6Opp8cGww/hTdDRaddQwKm6XcoBvEulwl2/D3JI/jtb0ZKkvaQQQT6euCN9btdngfcl5k7DbdIkqZXzyGXiFhL9ZuI8yNiguqXt/cFyMyVwAbgNGAceIjqh2wlSXtYz0DPzDN7tCfwloFVJEnaLX5SVJIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklSIvgI9Ik6NiE0RMR4R53VoPyQiLouIH0bExog4e/ClSpKm0jPQI2IOcDGwDFgKnBkRS9u6vQW4MTOPB8aAT0TEfgOuVZI0hX7O0E8CxjPzlsx8BFgHLG/rk8DBERHAQcA9wLaBVipJmlI/gb4A2NyYnqjnNV0EPAPYAvwIeFtmPjaQCiVJfZnbR5/oMC/bpl8GXAecAhwF/HdE/F9m3r/DgiJWACsARkZGaLVau1qvOpicnHRbzkBjwy5AM9Z07a/9BPoEsLAxfQTVmXjT2cA/ZGYC4xHxU+DpwPebnTJzFbAKYHR0NMfGxnazbDW1Wi3cltLsMV37az9DLlcDSyLiyPofnWcA69v63Aa8CCAiRoBjgFsGWagkaWo9z9Azc1tEnAtcDswBVmfmxog4p25fCXwQWBMRP6Iaonl3Zt41jXVLktr0M+RCZm4ANrTNW9m4vgV46WBLkyTtCj8pKkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5Jhegr0CPi1IjYFBHjEXFelz5jEXFdRGyMiG8PtkxJUi9ze3WIiDnAxcBLgAng6ohYn5k3NvrMAz4NnJqZt0XEYdNUrySpi37O0E8CxjPzlsx8BFgHLG/r8zrgq5l5G0Bm3jnYMiVJvfQ8QwcWAJsb0xPAyW19fh/YNyJawMHApzLz8+0LiogVwAqAkZERWq3WbpSsdpOTk27LGWhs2AVoxpqu/bWfQI8O87LDcp4LvAh4IvDdiLgqM2/e4UaZq4BVAKOjozk2NrbLBWtnrVYLt6U0e0zX/tpPoE8ACxvTRwBbOvS5KzMfBB6MiCuA44GbkSTtEf2MoV8NLImIIyNiP+AMYH1bn/8CXhARcyPiAKohmZsGW6okaSo9z9Azc1tEnAtcDswBVmfmxog4p25fmZk3RcS3gOuBx4BLMvOG6SxckrSjfoZcyMwNwIa2eSvbpj8OfHxwpUmSdoWfFJWkQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEL0FegRcWpEbIqI8Yg4b4p+J0bEoxHx6sGVKEnqR89Aj4g5wMXAMmApcGZELO3S72PA5YMuUpLUWz9n6CcB45l5S2Y+AqwDlnfo91bgK8CdA6xPktSnuX30WQBsbkxPACc3O0TEAuBVwCnAid0WFBErgBUAIyMjtFqtXSxXnUxOTrotZ6CxYRegGWu69td+Aj06zMu26QuAd2fmoxGdutc3ylwFrAIYHR3NsbGx/qrUlFqtFm5LafaYrv21n0CfABY2po8AtrT1GQXW1WE+HzgtIrZl5tcGUaQkqbd+Av1qYElEHAncDpwBvK7ZITOP3H49ItYAXzfMJWnP6hnombktIs6levfKHGB1Zm6MiHPq9pXTXKMkqQ/9nKGTmRuADW3zOgZ5Zp71+MuSJO0qPykqSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKkRfgR4Rp0bEpogYj4jzOrS/PiKury9XRsTxgy9VkjSVnoEeEXOAi4FlwFLgzIhY2tbtp8ALM/M44IPAqkEXKkmaWj9n6CcB45l5S2Y+AqwDljc7ZOaVmXlvPXkVcMRgy5Qk9TK3jz4LgM2N6Qng5Cn6vwn4ZqeGiFgBrAAYGRmh1Wr1V6WmNDk56bacgcaGXYBmrOnaX/sJ9OgwLzt2jPhDqkB/fqf2zFxFPRwzOjqaY2Nj/VWpKbVaLdyW0uwxXftrP4E+ASxsTB8BbGnvFBHHAZcAyzLz7sGUJ0nqVz9j6FcDSyLiyIjYDzgDWN/sEBFPA74KvCEzbx58mZKkXnqeoWfmtog4F7gcmAOszsyNEXFO3b4S+ABwKPDpiADYlpmj01e2JKldP0MuZOYGYEPbvJWN628G3jzY0iRJu8JPikpSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiH6CvSIODUiNkXEeESc16E9IuLCuv36iDhh8KVKkqbSM9AjYg5wMbAMWAqcGRFL27otA5bUlxXAZwZcpySph7l99DkJGM/MWwAiYh2wHLix0Wc58PnMTOCqiJgXEU/NzDsGXnFVxLQsdrYaG3YBM03msCuQhqKfQF8AbG5MTwAn99FnAbBDoEfECqozeIDJiNi0S9Wqm/nAXcMuYsbwgD8T+RxtenzP0UXdGvoJ9E5rbj8F6qcPmbkKWNXHOrULIuKazBwddh1SNz5H94x+/ik6ASxsTB8BbNmNPpKkadRPoF8NLImIIyNiP+AMYH1bn/XAG+t3uzwPuG/axs8lSR31HHLJzG0RcS5wOTAHWJ2ZGyPinLp9JbABOA0YBx4Czp6+ktWBw1ia6XyO7gGRviNAkorgJ0UlqRAGuiQVwkCfxXp9JYM0bBGxOiLujIgbhl3L3sBAn6X6/EoGadjWAKcOu4i9hYE+e/3mKxky8xFg+1cySDNGZl4B3DPsOvYWBvrs1e3rFiTtpQz02auvr1uQtPcw0Gcvv25B0g4M9Nmrn69kkLQXMdBnqczcBmz/SoabgC9l5sbhViXtKCLWAt8FjomIiYh407BrKpkf/ZekQniGLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIf4fl30l+yrhOpkAAAAASUVORK5CYII=",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -943,6 +962,7 @@
         "p_hint_env = 1.0 # this is the \"true\" accuracy of the hint - i.e. how often does the hint actually signal which arm is better. REMEMBER: THIS IS INDEPENDENT OF HOW YOU PARAMETERIZE THE A MATRIX FOR THE HINT MODALITY\n",
         "p_reward_env = 0.7 # this is the \"true\" reward probability - i.e. how often does the better arm actually return a reward, as opposed to a loss. REMEMBER: THIS IS INDEPENDENT OF HOW YOU PARAMETERIZE THE A MATRIX FOR THE REWARD MODALITY\n",
         "env = TwoArmedBandit(p_hint = p_hint_env, p_reward = p_reward_env)\n",
+        "print(f'Context: {env.context}')\n",
         "\n",
         "T = 10\n",
         "\n",
@@ -962,14 +982,21 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 22,
+      "execution_count": 23,
       "metadata": {
         "id": "B1XpcHlX3Gnj"
       },
       "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Context: Right-Better\n"
+          ]
+        },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -984,12 +1011,12 @@
           "output_type": "stream",
           "text": [
             "Action at time 0: Play-left\n",
-            "Reward at time 0: Reward\n"
+            "Reward at time 0: Loss\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1009,7 +1036,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1023,13 +1050,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 2: Play-right\n",
-            "Reward at time 2: Reward\n"
+            "Action at time 2: Play-left\n",
+            "Reward at time 2: Loss\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1049,7 +1076,7 @@
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1063,13 +1090,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 4: Play-left\n",
-            "Reward at time 4: Loss\n"
+            "Action at time 4: Play-right\n",
+            "Reward at time 4: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1083,13 +1110,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 5: Play-left\n",
+            "Action at time 5: Play-right\n",
             "Reward at time 5: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAATcElEQVR4nO3df7AdZ33f8ffHMrbBGDvFiRrLiuRgDUWOKSQXO3RSuCGmyJBYZAKNnYbBlFQwjSak5JcTqMd1CBloG2gaT8ABj9MQbJy0zSjF1H803KQZCpVcuwShKhWOiWR+GIxtbGMwCt/+satmdXTuvUfX5+pIj96vmTP37O6zu9+zZ89n9zz3nLOpKiRJJ75TZl2AJGk6DHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6CeYJPNJDgyGdyeZn3DeH02yP8mjSZ4/pXo2Jqkkp05jeU/W6PbR9CX5lSTvm3UdOpKBPgNJ7k3yeB+sDyb5cJL1K1lWVV1UVQsTNv83wPaqenpV3bWS9R1LSW5O8rZl2lSSC49VTdMwzZqf7LL6ffGyJaYfcYCsqrdX1U+tdJ1HI8maJG9L8rkkjyS5K8k5x2LdJyIDfXZ+pKqeDnwn8EXg3x+DdW4Adh+D9UjT8q+AfwC8EHgG8Brg6zOt6HhWVd6O8Q24F7hsMPxy4C8Hw6fTnU3/NV3Yvwd4aj9tHjgwbll0B+hrgM8ADwC3AX+nX96jQAGPAZ/p2/8ScB/wCLAX+KFF6n0FcBfwVWA/cN1g2sZ+uduAzwGfB35+5LG8u5/2uf7+6f20q4E/H1lXARf2y/sm8ERf+x+PqevPBo/pUeDHD20f4OeA+/t6XjfJtl3ksf8zYE+/jT4NfG8//jnAAvAQ3UHyisE8NwM3AB/u5/sE8KzFau7H/zBwd7+8jwHP7cf/OPBXwDP64cuBLwDfvtiyRup/FvAn/f7wZeD3gXP6ab8HfAt4vJ//F0fmPbOf9q1++qPAecB1wAdGnv/X9fvGg8AbgRcAn+wfz2+NLPef9tv0QeAOYMMi2/7b+nU+a9av2RPlNvMCTsYbh4fw04DfBf7DYPq7gB10YXwW8MfAr/fT5lk80N8EfBw4vw+u9wK3DNoWcGF//9n9C/C8fnjjYi+cfp0X0x0wnksXhK8czFfALX0AXAx8aVDT9X1N39GH0MeAX+2nXc0igd7fvxl42zLb8v+3H9R6sF/vU+gOll8Dvm25bTtm2a+mO+C9AAjdgWZDv9x9wK8ApwEvoQvuZw/qfgC4BDiVLkRvXaLm59MdfC4F1gCv7Z/XQwe+3++X+Uy6g+IPL7asMY/hQuCl/f5w6CDw7nH7zxLP/YGRcddxZKC/BzgD+Ed0Z9B/1D/n6/rH9uK+/dZ+2z2n3zZvBT62yLpfRHdA+CW6g9hfAj8969fv8XybeQEn461/ET3a76zf7F+kF/fTQnfG9axB+xcCf9XfP+wFxuGBvofBWTZdd843gVP74WFYXti/0C4DnnKU9b8beFd//9AL+u8Npr8TeH9//zPAywfTXgbc29+/mtUJ9McPPeZ+3P3A9y+3bccs+w7gTWPG/8M+YE4ZjLuF/p1LX/f7BtNeDvyfJWr+bfqD3GDc3kEInkP3juIvgPcu9fgneO5eCdw1bv9ZpP1h+1s/7jqODPR1g+kPMHi3APxH4Gf7+x8BXj+YdgrdAXfDmHX/RL/s9wNPpTuZ+BLw0mm8Dlu82Yc+O6+sqnPozmq2A3+a5O/SnUU9DbgzyUNJHgL+az9+ORuA/zyYbw/wN8Da0YZVtQ/4WboX5/1Jbk1y3riFJrk0yUeTfCnJw3Rvqc8dabZ/cP+zdG/N6f9+dpFpq+WBqjo4GP4a8HSOftuupzsgjToP2F9V3xqM+yzd2eghXxiz/sVsAH7uUE19Xev79VBVDwF/AHwP8G+XWM4Rkqztn9v7knwV+ABHPnfT8MXB/cfHDB96/BuAfzd4nF+hO9AOt91wPoDrq+rxqvokcCvdAVJjGOgzVlV/U1X/iS54f4Cun/Nx4KKqOqe/nV3dP1CXsx+4fDDfOVV1RlXdt8i6P1hVP0D3IivgHYss94N03RTrq+psurfXGWkz/JTOd9G966D/u2GRaY/RBSwA/QHtsBIXqWeljnbb7qfrgx71OWB9kuHr57voumdWYj/wayPP29Oq6haAJM+j63e+BfjNo1z22+m248VV9QzgJzn8uVtuG0/7OdgPvGHksT61qj42pu0nx9Qw7XqaYqDPWDpb6f4BtKc/6/sd4F1JvqNvsy7JyyZY3HuAX0uyoZ/v2/tlj1vvs5O8JMnpdH2eh/75Nc5ZwFeq6utJLqF7KzzqXyZ5WpKL6P5B9qF+/C3AW/tazgWupTtLBPjfwEVJnpfkDLp3C0NfBL57mcc8SRsAVrBt3wf8fJLv65+nC/tt+wm6s+5fTPKU/nsAP0J39jiJ0Zp/B3hj/04oSc5M8ookZ/Xb5QN0/fWvA9Yl+edLLGvUWXTdew8nWQf8wjK1jKv1mUnOnuiRLe89wC/3+wlJzk7y6nENq+ozwH8H3pLk9CTPAa4E/suUamnPrPt8TsYbXb/loU8WPAJ8Cvgng+ln0J1Z3UP3yZI9wM/00+ZZ+lMub6brf32Errvg7YO2w/7p5wL/s2/3FboXyXmL1Psqui6FR/p2v8WRfaiHPuXyBQaflugfy2/Sfdrk8/39MwbT30J35ryf7uxxWOMm/vaTH3+0SG1v7Jf7EPCPR7fPmG206LZdYvl7++fqU8Dz+/EXAX8KPEz36ZcfHcxzM4O+/zHP2WE19+O2ADv7cZ+n62I5i+6fuB8ZzPv3++dr02LLGqn/IuDOvv676T79M6xlK13//EMMPp00soyb6PrFH2LxT7kM/2dxAJgfDH8AeOtg+DV0/w849Kmpm5bY/uvousUe7Z+zN8z69Xs839JvNEnSCc4uF0lqhIEuSY0w0CWpEQa6JDViZj95eu6559bGjRtntfqmPPbYY5x55pmzLkNalPvo9Nx5551frqqxX4abWaBv3LiRXbt2zWr1TVlYWGB+fn7WZUiLch+dniSfXWyaXS6S1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpERMFepItSfYm2ZfkmjHTr+4vfnB3fzsmVwSXJP2tZT+HnmQN3QVvX0r3s5g7k+yoqk+PNP1QVW1fhRolSROY5Az9EmBfVd1TVU/Q/Yj/2IsmSJJmZ5Jviq7j8OtFHqC7OvmoH0vyIrorc/+Lqto/2iDJNroLIbB27VoWFhaOumCA+R/8wRXN16r5WRdwnFn46EdnXYL76Ij5WRdwnFmtfXTZC1wkeRWwpap+qh9+DXDpsHslyTOBR6vqG0neQHfF75cstdy5ubla8Vf/M3o5S2ngeLhoi/uolvIk9tEkd1bV3Lhpk3S53MfhFwA+n5GL4VbVA1X1jX7wfcD3raRQSdLKTRLoO4FNSS5IchrdRVp3DBsk+c7B4BV012mUJB1Dy/ahV9XBJNuBO4A1dBd03Z3kemBXVe0AfibJFcBBugvYXr2KNUuSxpjZRaLtQ9eqsQ9dx7sZ9qFLkk4ABrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY2YKNCTbEmyN8m+JNcs0e7HklSSuemVKEmaxLKBnmQNcANwObAZuCrJ5jHtzgLeBHxi2kVKkpY3yRn6JcC+qrqnqp4AbgW2jmn3q8A7gK9PsT5J0oROnaDNOmD/YPgAcOmwQZLvBdZX1YeT/MJiC0qyDdgGsHbtWhYWFo66YID5Fc2lk8VK96tpmp91ATqurdY+OkmgLynJKcBvAFcv17aqbgRuBJibm6v5+fknu3rpCO5XOt6t1j46SZfLfcD6wfD5/bhDzgK+B1hIci/w/cAO/zEqScfWJIG+E9iU5IIkpwFXAjsOTayqh6vq3KraWFUbgY8DV1TVrlWpWJI01rKBXlUHge3AHcAe4Laq2p3k+iRXrHaBkqTJTNSHXlW3A7ePjLt2kbbzT74sSdLR8puiktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEZMFOhJtiTZm2RfkmvGTH9jkr9IcneSP0+yefqlSpKWsmygJ1kD3ABcDmwGrhoT2B+sqour6nnAO4HfmHahkqSlTXKGfgmwr6ruqaongFuBrcMGVfXVweCZQE2vREnSJE6doM06YP9g+ABw6WijJD8NvBk4DXjJVKqTJE1skkCfSFXdANyQ5CeAtwKvHW2TZBuwDWDt2rUsLCysaF3zK65SJ4OV7lfTND/rAnRcW619NFVL944keSFwXVW9rB/+ZYCq+vVF2p8CPFhVZy+13Lm5udq1a9eKiiZZ2Xw6OSyzTx8T7qNaypPYR5PcWVVz46ZN0oe+E9iU5IIkpwFXAjtGVrBpMPgK4P+utFhJ0sos2+VSVQeTbAfuANYAN1XV7iTXA7uqagewPcllwDeBBxnT3SJJWl0T9aFX1e3A7SPjrh3cf9OU65IkHSW/KSpJjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY2YKNCTbEmyN8m+JNeMmf7mJJ9O8skk/y3JhumXKklayrKBnmQNcANwObAZuCrJ5pFmdwFzVfVc4A+Bd067UEnS0iY5Q78E2FdV91TVE8CtwNZhg6r6aFV9rR/8OHD+dMuUJC3n1AnarAP2D4YPAJcu0f71wEfGTUiyDdgGsHbtWhYWFiarcsT8iubSyWKl+9U0zc+6AB3XVmsfnSTQJ5bkJ4E54MXjplfVjcCNAHNzczU/Pz/N1UsAuF/peLda++gkgX4fsH4wfH4/7jBJLgPeAry4qr4xnfIkSZOapA99J7ApyQVJTgOuBHYMGyR5PvBe4Iqqun/6ZUqSlrNsoFfVQWA7cAewB7itqnYnuT7JFX2zfw08HfiDJHcn2bHI4iRJq2SiPvSquh24fWTctYP7l025LknSUfKbopLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGTBToSbYk2ZtkX5Jrxkx/UZL/leRgkldNv0xJ0nKWDfQka4AbgMuBzcBVSTaPNPtr4Grgg9MuUJI0mVMnaHMJsK+q7gFIciuwFfj0oQZVdW8/7VurUKMkaQKTBPo6YP9g+ABw6UpWlmQbsA1g7dq1LCwsrGQxzK9oLp0sVrpfTdP8rAvQcW219tFJAn1qqupG4EaAubm5mp+fP5ar10nC/UrHu9XaRyf5p+h9wPrB8Pn9OEnScWSSQN8JbEpyQZLTgCuBHatbliTpaC0b6FV1ENgO3AHsAW6rqt1Jrk9yBUCSFyQ5ALwaeG+S3atZtCTpSBP1oVfV7cDtI+OuHdzfSdcVI0maEb8pKkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjZgo0JNsSbI3yb4k14yZfnqSD/XTP5Fk49QrlSQtadlAT7IGuAG4HNgMXJVk80iz1wMPVtWFwLuAd0y7UEnS0iY5Q78E2FdV91TVE8CtwNaRNluB3+3v/yHwQ0kyvTIlScs5dYI264D9g+EDwKWLtamqg0keBp4JfHnYKMk2YFs/+GiSvSspWkc4l5FtfVLzXOJ45D469OT20Q2LTZgk0Kemqm4EbjyW6zwZJNlVVXOzrkNajPvosTFJl8t9wPrB8Pn9uLFtkpwKnA08MI0CJUmTmSTQdwKbklyQ5DTgSmDHSJsdwGv7+68C/qSqanplSpKWs2yXS98nvh24A1gD3FRVu5NcD+yqqh3A+4HfS7IP+Apd6OvYsRtLxzv30WMgnkhLUhv8pqgkNcJAl6RGGOgnsOV+kkGatSQ3Jbk/yadmXcvJwEA/QU34kwzSrN0MbJl1EScLA/3ENclPMkgzVVV/RvfJNx0DBvqJa9xPMqybUS2SjgMGuiQ1wkA/cU3ykwySTiIG+olrkp9kkHQSMdBPUFV1EDj0kwx7gNuqavdsq5IOl+QW4H8Az05yIMnrZ11Ty/zqvyQ1wjN0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIa8f8Au8cMn6rZqU4AAAAASUVORK5CYII=",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1103,13 +1130,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 6: Play-left\n",
+            "Action at time 6: Play-right\n",
             "Reward at time 6: Loss\n"
           ]
         },
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAWp0lEQVR4nO3dfbQcd33f8ffHAplgjCEYbrEkbBerBBkoTi5ScvLABUyRCZHIAYKchGPzpHAaJSQ81STUx8dJaKFJIDROQCE+JjxYGNpyRCOinhbfUMpDJRdDkB1RIQiSeDAYG7jmwQi+/WNHdLzae+9I3qt7NXq/ztmjnfn9dua7szOfO/tb7U6qCknSye+0xS5AkjQeBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgX6SSTKV5GBrek+SqY6P/eUkB5LMJLloTPWcl6SS3Gccy7u3hrePxi/J7yV562LXoaMZ6IsgyeeTfKcJ1juS/G2SVcezrKq6sKqmO3b/Y2BLVT2gqj5xPOs7kZJcl+QP5+lTSS44UTWNwzhrvrfLavbFi+doP+oPZFW9tqpedLzrPIbafr45Rtq3SvKshV73ycpAXzy/VFUPAB4OfAX4jydgnecCe07AeqR7rar+Z3Py8YDmWHkGMAP83SKXtmQZ6Iusqr4LvBdYc2RektOT/HGSLyT5SpI3J/mxUY9vn2ElOS3JFUk+m+T2JDck+fFmeTPAMuCTST7b9P83SQ4l+VaSvUmeMss6fjHJJ5J8sxmyuWpEtxck+WKSLyV5xdBzeWPT9sXm/ulN2+VJPjy0rkpyQZLNwK8Br2rOzN4/oq4PNXc/2fR5bqvt5Ulua+p5/vFs26b/i5Pc2myjW5L8ZDP/0Ummk9zZDHttaD3muiTXNO+8vpXk40keOVfNSZ6R5OZmeR9J8rhm/nOTfC7JA5vpS5J8OclD53r+rVoemeSDzf7wtSTvTPKgpu3twCOA9zePf9XQY88APgCc0zpDPifJVUne0fQ5MuT2/GbfuCPJS5I8Icmnmufz50PLfUGzTe9IsjPJubNt/yGXAe+tqrs69j/1VJW3E3wDPg9c3Ny/P/A24G9a7W8AtgM/DpwJvB/4d03bFHBwlmW9FPgYsBI4HXgLcH2rbwEXNPcfBRwAzmmmzwMeOUu9U8BjGZwAPI7BO4pnth5XwPXAGU2/r7Zqurqp6WHAQ4GPAH/QtF0OfHhoXe0arwP+cJ5t+aP+rVoPN+u9L/B04NvAg+fbtiOW/RzgEPAEIMAFDN7l3BfYB/wesBx4MvAt4FGtum8H1gL3Ad4JbJuj5ouA24B1DP7oXta8rqc37e9slvkQ4IvAM2Zb1ojncAHw1GZ/eCjwIeCNo/afOV77g0PzrgLeMfT6vxm4H/CvgO8C72te8xXNc3ti039js+0e3Wyb1wAf6XDMnNFs46nFPn6X8m3RCzgVb81BNAPcCXy/OUgf27QFuItWuAI/A3yuuX+PA4x7BvqtwFNabQ9vln+fZrodlhc0B9rFwH2Psf43Am9o7h85oH+i1f564K+b+58Fnt5qexrw+eb+5SxMoH/nyHNu5t0G/PR823bEsncCLx0x/+eBLwOnteZdD1zVqvutrbanA/84R81/SfNHrjVvbysEHwR8AfgH4C1zPf8Or90zgU+M2n9m6X+P/a2ZdxVHB/qKVvvtwHNb0/8J+J3m/geAF7baTmPwB/fceep+HvA5IMd73J0KtyXxPxNOUc+sqv+eZBmDs5a/T7IG+CGDs/abkhzpGwZnbvM5F/gvSX7YmvcDYILBmeaPVNW+JL/D4OC8MMlO4GVV9cXhhSZZB/x74DEMzkhPB94z1O1A6/4/MThTBzinmW63ndPhudwbt1fV4db0t4EHMDhDPZZtu4rBH6Rh5wAHqqq9nf+JwdnoEV8esf7ZnAtcluS3WvOWN+uhqu5M8h7gZcAxfSCYZAL4MwZ/hM5kEKB3HMsyOvpK6/53Rkwfef7nAn+W5E/aZTLYdu39ZNhlDN7F+muCc3AMfZFV1Q+q6j8zCN6fA77G4AC4sKoe1NzOqsGHQvM5AFzSetyDqup+VXVoVOeqeldV/RyDg6yA182y3HcxGKZYVVVnMXh7naE+7f+l8wgG7zpo/j13lra7GAQsAEn+2XCJs9RzvI512x4AHjli/heBVUnax88jGPqjeQwOAH809Lrdv6quB0jyeOAFDN4FvOkYl/1aBtvxsVX1QODXuedrN982HvdrcAD4jaHn+mNV9ZHZHpDB/wCbAv5mzLX0joG+yDKwEXgwcGtz1vdXwBuSPKzpsyLJ0zos7s3AHx35kKn54GzjLOt9VJInNx9QfpdB0P1wVF8GZ3Zfr6rvJlkL/OqIPv82yf2TXAg8H3h3M/964DVNLWcDVwLvaNo+yeDdweOT3I/Bu4W2rwD/fJ7n3KUPAMexbd8KvCLJTzWv0wXNtv04g7PuVyW5bwbfA/glYFuXOkbU/FfAS5Ksa9ZzRgYfRJ/ZbJd3MBivfz6wIsm/nmNZw85kMLz3jSQrgFfOU8uoWh+S5KxOz2x+bwZe3ewnJDkryXPmeczzGIyzj3q3pLbFHvM5FW8Mxi2/w+BA+xbwaeDXWu33Y3BmtR/4JoOx8d9u2qaYfQz9NAZvy/c2y/0s8NpW3/b49OOA/930+zrwX2k+IB1R77MZvB3+VtPvzzl6DHUzgzPXLwOvGnoubwK+1NzeBNyv1f77DM6cDzA4e2zXuBq4mcFnDe+bpbaXNMu9E/iV4e0zYhvNum3nWP7e5rX6NHBRM/9C4O+BbwC3AL/cesx1tMb+R7xm96i5mbce2NXM+xKDIa0zGXyI+4HWY/9l83qtnm1ZQ/VfCNzU1H8z8PKhWjYyGJ+/E3jFLNvgWgbj4ncyGAa6asTr3/7M4iCtDy8Z/EF6TWv6eQw+D/hm87pfO8/x8o+0xt29zX5Ls8EkSSc5h1wkqScMdEnqCQNdknrCQJeknli0LxadffbZdd555y3W6nvlrrvu4owzzljsMqRZuY+Oz0033fS1qnroqLZFC/TzzjuP3bt3L9bqe2V6epqpqanFLkOalfvo+CSZ9Ru1DrlIUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BOdAj3J+gyuObkvyRUj2h+R5MYMrjv5qSRPH3+pkqS5zBvozRV1rgEuYXAh40ubK+u0vQa4oaouAjYBfzHuQiVJc+tyhr4W2FdV+6vqbgY/4j980YQCHtjcP4v/f0UaSdIJ0uWboiu45/UiDzK4OnnbVcB/a66JeAaDCw8fJclmBhdCYGJigunp6WMsV6PMzMy4LZeYqSc9abFLWFKmFruAJWb6xhsXZLnj+ur/pcB1VfUnSX4GeHuSx9Q9L6JLVW0FtgJMTk6WXwUeD79WLZ1cFup47TLkcoh7XgB4JUdfDPeFwA0AVfVRBpf5OnscBUqSuukS6LuA1UnOT7KcwYee24f6fAF4CkCSRzMI9K+Os1BJ0tzmDfSqOgxsAXYyuKDuDVW1J8nVSTY03V4OvDjJJxlc5f3y8mKlknRCdRpDr6odwI6heVe27t8C/Ox4S5MkHQu/KSpJPWGgS1JPGOiS1BMGuiT1hIEuST1hoEtSTxjoktQTBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BMGuiT1RKdAT7I+yd4k+5JcMaL9DUlubm6fSXLn2CuVJM1p3isWJVkGXAM8FTgI7EqyvblKEQBV9but/r8FXLQAtUqS5tDlDH0tsK+q9lfV3cA2YOMc/S9lcF1RSdIJ1CXQVwAHWtMHm3lHSXIucD7wwXtfmiTpWHS6SPQx2AS8t6p+MKoxyWZgM8DExATT09NjXv2paWZmxm25xEwtdgFa0hbqeO0S6IeAVa3plc28UTYBvznbgqpqK7AVYHJysqamprpVqTlNT0/jtpROHgt1vHYZctkFrE5yfpLlDEJ7+3CnJD8BPBj46HhLlCR1MW+gV9VhYAuwE7gVuKGq9iS5OsmGVtdNwLaqqoUpVZI0l05j6FW1A9gxNO/KoemrxleWJOlY+U1RSeoJA12SesJAl6SeMNAlqScMdEnqCQNdknrCQJeknjDQJaknDHRJ6gkDXZJ6wkCXpJ4w0CWpJwx0SeoJA12SesJAl6SeMNAlqScMdEnqiU6BnmR9kr1J9iW5YpY+v5LkliR7krxrvGVKkuYz7yXokiwDrgGeChwEdiXZXlW3tPqsBl4N/GxV3ZHkYQtVsCRptC5n6GuBfVW1v6ruBrYBG4f6vBi4pqruAKiq28ZbpiRpPl0uEr0CONCaPgisG+rzLwCS/C9gGXBVVf3d8IKSbAY2A0xMTDA9PX0cJWvYzMyM23KJmVrsArSkLdTx2iXQuy5nNYP9eCXwoSSPrao7252qaiuwFWBycrKmpqbGtPpT2/T0NG5L6eSxUMdrlyGXQ8Cq1vTKZl7bQWB7VX2/qj4HfIZBwEuSTpAugb4LWJ3k/CTLgU3A9qE+76N5l5nkbAZDMPvHV6YkaT7zBnpVHQa2ADuBW4EbqmpPkquTbGi67QRuT3ILcCPwyqq6faGKliQdrdMYelXtAHYMzbuydb+AlzU3SdIi8JuiktQTBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BMGuiT1hIEuST1hoEtSTxjoktQTBrok9YSBLkk9YaBLUk8Y6JLUE50CPcn6JHuT7EtyxYj2y5N8NcnNze1F4y9VkjSXeS9Bl2QZcA3wVOAgsCvJ9qq6Zajru6tqywLUKEnqoMsZ+lpgX1Xtr6q7gW3AxoUtS5J0rLpcJHoFcKA1fRBYN6Lfs5L8AvAZ4Her6sBwhySbgc0AExMTTE9PH3PBOtrMzIzbcomZWuwCtKQt1PHaJdC7eD9wfVV9L8lvAG8Dnjzcqaq2AlsBJicna2pqakyrP7VNT0/jtpROHgt1vHYZcjkErGpNr2zm/UhV3V5V32sm3wr81HjKkyR11SXQdwGrk5yfZDmwCdje7pDk4a3JDcCt4ytRktTFvEMuVXU4yRZgJ7AMuLaq9iS5GthdVduB306yATgMfB24fAFrliSN0GkMvap2ADuG5l3Zuv9q4NXjLU2SdCz8pqgk9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BMGuiT1hIEuST1hoEtSTxjoktQTBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPVEp0BPsj7J3iT7klwxR79nJakkk+MrUZLUxbyBnmQZcA1wCbAGuDTJmhH9zgReCnx83EVKkubX5Qx9LbCvqvZX1d3ANmDjiH5/ALwO+O4Y65MkddTlItErgAOt6YPAunaHJD8JrKqqv03yytkWlGQzsBlgYmKC6enpYy5YR5uZmXFbLjFTi12AlrSFOl67BPqckpwG/Clw+Xx9q2orsBVgcnKypqam7u3qxWDncFtKJ4+FOl67DLkcAla1plc28444E3gMMJ3k88BPA9v9YFSSTqwugb4LWJ3k/CTLgU3A9iONVfWNqjq7qs6rqvOAjwEbqmr3glQsSRpp3kCvqsPAFmAncCtwQ1XtSXJ1kg0LXaAkqZtOY+hVtQPYMTTvyln6Tt37siRJx8pvikpSTxjoktQTBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BMGuiT1hIEuST1hoEtSTxjoktQTBrok9YSBLkk9YaBLUk90CvQk65PsTbIvyRUj2l+S5B+S3Jzkw0nWjL9USdJc5g30JMuAa4BLgDXApSMC+11V9diqejzweuBPx12oJGluXc7Q1wL7qmp/Vd0NbAM2tjtU1Tdbk2cANb4SJUlddLlI9ArgQGv6ILBuuFOS3wReBiwHnjxqQUk2A5sBJiYmmJ6ePsZyNcrMzIzbcomZWuwCtKQt1PGaqrlPppM8G1hfVS9qpp8HrKuqLbP0/1XgaVV12VzLnZycrN27dx9f1bqH6elppqamFrsMtSWLXYGWsnlydy5JbqqqyVFtXYZcDgGrWtMrm3mz2QY8s3N1kqSx6BLou4DVSc5PshzYBGxvd0iyujX5i8D/HV+JkqQu5h1Dr6rDSbYAO4FlwLVVtSfJ1cDuqtoObElyMfB94A5gzuEWSdL4dflQlKraAewYmndl6/5Lx1yXJOkY+U1RSeoJA12SesJAl6SeMNAlqScMdEnqCQNdknrCQJeknjDQJaknDHRJ6gkDXZJ6wkCXpJ4w0CWpJwx0SeoJA12SesJAl6SeMNAlqScMdEnqiU6BnmR9kr1J9iW5YkT7y5LckuRTSf5HknPHX6okaS7zBnqSZcA1wCXAGuDSJGuGun0CmKyqxwHvBV4/7kIlSXPrcoa+FthXVfur6m5gG7Cx3aGqbqyqbzeTHwNWjrdMSdJ8ulwkegVwoDV9EFg3R/8XAh8Y1ZBkM7AZYGJigunp6W5VDpl60pOO63F9NbXYBSwx0zfeuNgl+JpoTsebffPpEuidJfl1YBJ44qj2qtoKbAWYnJysqampca5eAsD9SkvdQu2jXQL9ELCqNb2ymXcPSS4Gfh94YlV9bzzlSZK66jKGvgtYneT8JMuBTcD2dockFwFvATZU1W3jL1OSNJ95A72qDgNbgJ3ArcANVbUnydVJNjTd/gPwAOA9SW5Osn2WxUmSFkinMfSq2gHsGJp3Zev+xWOuS5J0jPymqCT1hIEuST1hoEtSTxjoktQTBrok9YSBLkk9YaBLUk8Y6JLUEwa6JPWEgS5JPWGgS1JPGOiS1BMGuiT1hIEuST1hoEtSTxjoktQTBrok9USnQE+yPsneJPuSXDGi/ReS/J8kh5M8e/xlSpLmM2+gJ1kGXANcAqwBLk2yZqjbF4DLgXeNu0BJUjddrim6FthXVfsBkmwDNgK3HOlQVZ9v2n64ADVKkjroEugrgAOt6YPAuuNZWZLNwGaAiYkJpqenj2cxTB3Xo3SqON79apymFrsALWkLtY92CfSxqaqtwFaAycnJmpqaOpGr1ynC/UpL3ULto10+FD0ErGpNr2zmSZKWkC6BvgtYneT8JMuBTcD2hS1LknSs5g30qjoMbAF2ArcCN1TVniRXJ9kAkOQJSQ4CzwHekmTPQhYtSTpapzH0qtoB7Biad2Xr/i4GQzGSpEXiN0UlqScMdEnqCQNdknrCQJeknjDQJaknDHRJ6gkDXZJ6wkCXpJ4w0CWpJwx0SeoJA12SesJAl6SeMNAlqScMdEnqCQNdknrCQJeknjDQJaknOgV6kvVJ9ibZl+SKEe2nJ3l30/7xJOeNvVJJ0pzmDfQky4BrgEuANcClSdYMdXshcEdVXQC8AXjduAuVJM2tyxn6WmBfVe2vqruBbcDGoT4bgbc1998LPCVJxlemJGk+XS4SvQI40Jo+CKybrU9VHU7yDeAhwNfanZJsBjY3kzNJ9h5P0TrK2Qxt61Oa5xJLkfto273bR8+draFLoI9NVW0Ftp7IdZ4KkuyuqsnFrkOajfvoidFlyOUQsKo1vbKZN7JPkvsAZwG3j6NASVI3XQJ9F7A6yflJlgObgO1DfbYDlzX3nw18sKpqfGVKkuYz75BLMya+BdgJLAOurao9Sa4GdlfVduCvgbcn2Qd8nUHo68RxGEtLnfvoCRBPpCWpH/ymqCT1hIEuST1hoJ/E5vtJBmmxJbk2yW1JPr3YtZwKDPSTVMefZJAW23XA+sUu4lRhoJ+8uvwkg7SoqupDDP7nm04AA/3kNeonGVYsUi2SlgADXZJ6wkA/eXX5SQZJpxAD/eTV5ScZJJ1CDPSTVFUdBo78JMOtwA1VtWdxq5LuKcn1wEeBRyU5mOSFi11Tn/nVf0nqCc/QJaknDHRJ6gkDXZJ6wkCXpJ4w0CWpJwx0SeoJA12SeuL/AfNeqhH6Xj8jAAAAAElFTkSuQmCC",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1123,13 +1150,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 7: Play-left\n",
+            "Action at time 7: Play-right\n",
             "Reward at time 7: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAATi0lEQVR4nO3dfbBcdX3H8ffXBEQeJFbkVpKYUEhRUFC8gs7oeOtjgtrgjA+g1ULVlKm0dapVaq1l6tNYa0UqGiPNpBZN1BFt1CjTmXalHcQCBZFAw1yjkktQ5CHABRwMfPvHOdFzN7t3N2Fv9t5f3q+Znbvn/H579rtn93zO2d+e3RuZiSRp7nvMsAuQJA2GgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDfY6JiLGImGhMb46IsT5v++qI2BYRkxHxrAHVszQiMiLmD2J5j1b7+tHgRcR7I+LiYdeh3RnoQxARP4mIB+tgvTsivhURi/dmWZl5Qma2+uz+D8C5mXloZl67N/e3L0XEuoj4YI8+GRHH7quaBmGQNT/aZdWvxZdM077bDjIzP5yZb93b+9wTEfGiiPjfiLg3IrZGxKp9cb9zlYE+PK/KzEOBJwM/B/5pH9znEmDzPrgf6VGLiAOArwGfBQ4HXg/8Y0ScNNTCZrPM9LKPL8BPgJc0pk8Dbm5MP5bqaPoWqrBfDTyubhsDJjoti2oHfR7wI+BO4MvAb9XLmwQSuB/4Ud3/PcCtwH3AFuDFXep9BXAtcC+wDTi/0ba0Xu4qYDtwG/DOtsdyQd22vb7+2LrtLOC/2+4rgWPr5f0KeKiu/Rsd6rq88ZgmqTb4MWACeCdwe13P2f2s2y6P/W3ATfU6uhE4uZ7/NKAF7KDaSf5+4zbrgIuAb9W3+z5wTLea6/mvBK6rl3cFcGI9//XAVuDx9fQK4GfAk7otq63+Y4D/qF8PdwBfABbUbf8KPAI8WN/+3W23PaRue6RunwSOAs4HLml7/s+uXxt3A+cAzwGurx/Pp9qW+0f1Or0buAxY0mXdj9TLPrgx7yrgzGFvw7P1MvQC9scLU0P4YOBfgM832i8ANlKF8WHAN4CP1G1jdA/0dwBXAouoguuzwPpG3wSOra8fV2+AR9XTS3eFTod6x4BnUO0wTqQKwtMbt0tgfR0AzwB+0ajp7+qajqxD6ArgA3XbWXQJ9Pr6OuCDPdblr/s3at1Z3+8BVDvLB4An9Fq3HZb9Wqod3nOAoNrRLKmXOw68FzgQeBFVcB/XqPsu4BRgPlWIbpim5pOpdj6nAvOAP6yf1107vi/Uy3wi1U7xld2W1eExHAu8tH497NoJXNDp9TPNcz/RNu98dg/01cBBwMuAXwJfr5/zhfVje2Hd//R63T2tXjfvA66Y5v6/CLy9Xi/Pq5e1eNjb8Gy9DL2A/fFSb0STVEcvO+uN9Bl1W1AdcR3T6P884Mf19SkbGFMD/SYaR9lUwzm/AubX082wPLbeOF4CHLCH9V8AfKK+vmuDfmqj/e+Bf66v/wg4rdH2cuAn9fWzmJlAf3DXY67n3Q48t9e67bDsy4A/7zD/BVRHyY9pzFtP/c6lrvviRttpwP9NU/NnqHdyjXlbGiG4gOodxQ+Bz073+Pt47k4Hru30+unSf8rrrZ53PrsH+sJG+5003i0AXwXeUV//NvCWRttjqHa4S7rc/6uoDiB21pe3Pdrtr+SLY+jDc3pmLqA6cjoX+G5E/DbVUdTBwDURsSMidgDfqef3sgT4WuN2NwEPU711nSIzx6mO6M8Hbo+IDRFxVKeFRsSpEfGfEfGLiLiH6i31EW3dtjWu/5TqrTn13592aZspd2bmzsb0A8Ch7Pm6XUy1Q2p3FLAtMx9pzPsp1dHoLj/rcP/dLAHeuaumuq7F9f2QmTuArwBPBz4+zXJ2ExFH1s/trRFxL3AJuz93g/DzxvUHO0zvevxLgE82HuddVDva5rrbVftTgS8Bb6Z6J3QC8O6IeMXAqy+EgT5kmflwZl5KFbzPpxrnfBA4ITMX1JfDs/oAtZdtwIrG7RZk5kGZeWuX+/5iZj6faiNL4KNdlvtFqmGKxZl5ONXb62jr0zxL5ylU7zqo/y7p0nY/VcACUO/QppTYpZ69tafrdhvVGHS77cDiiGhuP0+hGp7ZG9uAD7U9bwdn5nqAiHgm1bjzeuDCPVz2R6jW44mZ+XjgD5j63PVax4N+DrYBf9z2WB+XmVd06Pt0YEtmXpaZj2TmFqrPJVYMuKZiGOhDFpWVwBOAm+qjvs8Bn4iII+s+CyPi5X0sbjXwoYhYUt/uSfWyO93vcfUpYY+lGvN8kGqn0slhwF2Z+cuIOAV4Q4c+fxMRB0fECVQfkH2pnr8eeF9dyxHA+6mOEgF+AJwQEc+MiIOo3i00/Rz4nR6PuZ8+AOzFur0YeFdEPLt+no6t1+33qXZG746IA+rvAbwK2NBPHR1q/hxwTv1OKCLikIh4RUQcVq+XS6jG688GFkbEn0yzrHaHUQ/vRcRC4C971NKp1idGxOF9PbLeVgN/Vb9OiIjDI+K1XfpeCyyrX6cREcdQfXj8gwHVUp5hj/nsjxeqcctdZxbcB9wAvLHRfhDwYaqzG+6lGjr5s7ptjOnPcvkLqvHX+6iGCz7c6Nscnz4R+J+6313AN6k/IO1Q72uohhTuq/t9it3HUHed5fIzGmdL1I/lQqqzTW6rrx/UaP9rqiPnbVRHj80al/GbMz++3qW2c+rl7gBe175+Oqyjrut2muVvqZ+rG4Bn1fNPAL4L3EN19surG7dZR2Psv8NzNqXmet5yqjM4dtRtX6EK408A32nc9qT6+VrWbVlt9Z8AXFPXfx3V2T/NWlZSjc/vAN7VZR2spRoX30H3s1yan1lMAGON6UuA9zWm30T1ecCus6bWTrP+X1ev9/vq5X6UxmcXXqZeol5pkqQ5ziEXSSqEgS5JhTDQJakQBrokFWJoP3l6xBFH5NKlS4d190W5//77OeSQQ4ZdhtSVr9HBueaaa+7IzI5fhhtaoC9dupSrr756WHdflFarxdjY2LDLkLryNTo4EfHTbm0OuUhSIQx0SSqEgS5JhTDQJakQBrokFaJnoEfE2oi4PSJu6NIeEXFhRIxHxPURcfLgy5Qk9dLPEfo6ql+C62YF1a/iLaP6xb3PPPqyJEl7qmegZ+blVD/X2c1Kqv+HmZl5JbAgIp48qAIlSf0ZxBeLFjL1349N1PNua+8YEauojuIZGRmh1WoN4O41OTnputSs5mt03xhEoLf/KzLo8m+rMnMNsAZgdHQ0/ebYYPgtvFkqOm0aEjBD/4diEGe5TDD1/0ku4jf/M1KStI8MItA3Am+uz3Z5LnBPZu423CJJmlk9h1wiYj3V/0Q8IiImgL8FDgDIzNXAJuA0YBx4gOof2UqS9rGegZ6ZZ/ZoT+DtA6tIkrRX/KaoJBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRB9BXpELI+ILRExHhHndWg/PCK+ERE/iIjNEXH24EuVJE2nZ6BHxDzgImAFcDxwZkQc39bt7cCNmXkSMAZ8PCIOHHCtkqRp9HOEfgownplbM/MhYAOwsq1PAodFRACHAncBOwdaqSRpWvP76LMQ2NaYngBObevzKWAjsB04DHh9Zj7SvqCIWAWsAhgZGaHVau1FyWo3OTnpupyFxoZdgGatmdpe+wn06DAv26ZfDlwHvAg4Bvj3iPivzLx3yo0y1wBrAEZHR3NsbGxP61UHrVYL16U0d8zU9trPkMsEsLgxvYjqSLzpbODSrIwDPwaeOpgSJUn96CfQrwKWRcTR9QedZ1ANrzTdArwYICJGgOOArYMsVJI0vZ5DLpm5MyLOBS4D5gFrM3NzRJxTt68GPgCsi4gfUg3RvCcz75jBuiVJbfoZQyczNwGb2uatblzfDrxssKVJkvaE3xSVpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RC9BXoEbE8IrZExHhEnNelz1hEXBcRmyPiu4MtU5LUy/xeHSJiHnAR8FJgArgqIjZm5o2NPguATwPLM/OWiDhyhuqVJHXRzxH6KcB4Zm7NzIeADcDKtj5vAC7NzFsAMvP2wZYpSeql5xE6sBDY1pieAE5t6/O7wAER0QIOAz6ZmZ9vX1BErAJWAYyMjNBqtfaiZLWbnJx0Xc5CY8MuQLPWTG2v/QR6dJiXHZbzbODFwOOA70XElZl585QbZa4B1gCMjo7m2NjYHhes3bVaLVyX0twxU9trP4E+ASxuTC8Ctnfoc0dm3g/cHxGXAycBNyNJ2if6GUO/ClgWEUdHxIHAGcDGtj7/BrwgIuZHxMFUQzI3DbZUSdJ0eh6hZ+bOiDgXuAyYB6zNzM0RcU7dvjozb4qI7wDXA48AF2fmDTNZuCRpqn6GXMjMTcCmtnmr26Y/BnxscKVJkvaE3xSVpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFaKvQI+I5RGxJSLGI+K8afo9JyIejojXDK5ESVI/egZ6RMwDLgJWAMcDZ0bE8V36fRS4bNBFSpJ66+cI/RRgPDO3ZuZDwAZgZYd+fwp8Fbh9gPVJkvrUT6AvBLY1pifqeb8WEQuBVwOrB1eaJGlPzO+jT3SYl23TFwDvycyHIzp1rxcUsQpYBTAyMkKr1eqvSk1rcnLSdTkLjQ27AM1aM7W99hPoE8DixvQiYHtbn1FgQx3mRwCnRcTOzPx6s1NmrgHWAIyOjubY2NjeVa0pWq0Wrktp7pip7bWfQL8KWBYRRwO3AmcAb2h2yMyjd12PiHXAN9vDXJI0s3oGembujIhzqc5emQeszczNEXFO3e64uSTNAv0coZOZm4BNbfM6BnlmnvXoy5Ik7Sm/KSpJhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYXoK9AjYnlEbImI8Yg4r0P7GyPi+vpyRUScNPhSJUnT6RnoETEPuAhYARwPnBkRx7d1+zHwwsw8EfgAsGbQhUqSptfPEfopwHhmbs3Mh4ANwMpmh8y8IjPvrievBBYNtkxJUi/z++izENjWmJ4ATp2m/1uAb3dqiIhVwCqAkZERWq1Wf1VqWpOTk67LWWhs2AVo1pqp7bWfQI8O87Jjx4jfowr053dqz8w11MMxo6OjOTY21l+Vmlar1cJ1Kc0dM7W99hPoE8DixvQiYHt7p4g4EbgYWJGZdw6mPElSv/oZQ78KWBYRR0fEgcAZwMZmh4h4CnAp8KbMvHnwZUqSeul5hJ6ZOyPiXOAyYB6wNjM3R8Q5dftq4P3AE4FPRwTAzswcnbmyJUnt+hlyITM3AZva5q1uXH8r8NbBliZJ2hN+U1SSCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgrRV6BHxPKI2BIR4xFxXof2iIgL6/brI+LkwZcqSZpOz0CPiHnARcAK4HjgzIg4vq3bCmBZfVkFfGbAdUqSepjfR59TgPHM3AoQERuAlcCNjT4rgc9nZgJXRsSCiHhyZt428IqrImZksXPV2LALmG0yh12BNBT9BPpCYFtjegI4tY8+C4EpgR4Rq6iO4AEmI2LLHlWrbo4A7hh2EbOGO/zZyNdo06N7jS7p1tBPoHe65/ZDoH76kJlrgDV93Kf2QERcnZmjw65D6sbX6L7Rz4eiE8DixvQiYPte9JEkzaB+Av0qYFlEHB0RBwJnABvb+mwE3lyf7fJc4J4ZGz+XJHXUc8glM3dGxLnAZcA8YG1mbo6Ic+r21cAm4DRgHHgAOHvmSlYHDmNptvM1ug9EekaAJBXBb4pKUiEMdEkqhIE+h/X6SQZp2CJibUTcHhE3DLuW/YGBPkf1+ZMM0rCtA5YPu4j9hYE+d/36Jxky8yFg108ySLNGZl4O3DXsOvYXBvrc1e3nFiTtpwz0uauvn1uQtP8w0Ocuf25B0hQG+tzVz08ySNqPGOhzVGbuBHb9JMNNwJczc/Nwq5Kmioj1wPeA4yJiIiLeMuyaSuZX/yWpEB6hS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUiP8HW+AiQoSvjnYAAAAASUVORK5CYII=",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1143,13 +1170,13 @@
           "name": "stdout",
           "output_type": "stream",
           "text": [
-            "Action at time 8: Play-left\n",
+            "Action at time 8: Play-right\n",
             "Reward at time 8: Reward\n"
           ]
         },
         {
           "data": {
-            "image/png": "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",
+            "image/png": "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",
             "text/plain": [
               "<Figure size 432x288 with 1 Axes>"
             ]
@@ -1164,16 +1191,17 @@
           "output_type": "stream",
           "text": [
             "Action at time 9: Play-right\n",
-            "Reward at time 9: Loss\n"
+            "Reward at time 9: Reward\n"
           ]
         }
       ],
       "source": [
         "# change the 'shape' of the agent's reward function\n",
-        "C[1][1] = 5.0 \n",
+        "C[1][1] = 0.0 # makes the Loss \"less aversive\" than before (higher prior prior probability assigned to seeing the Loss outcome). This should make the agent less risk-averse / willing to explore both arms, under uncertainty\n",
         "\n",
         "my_agent = Agent(A = A, B = B, C = C, D = D) # redefine the agent with the new preferences\n",
         "env = TwoArmedBandit(p_hint = 0.8, p_reward = 0.8) # re-initialize the environment -- this time, the hint is not always accurate (`p_hint = 0.8`)\n",
+        "print(f'Context: {env.context}')\n",
         "\n",
         "run_active_inference_loop(my_agent, env, T = T)"
       ]
@@ -1202,7 +1230,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.8.8"
+      "version": "3.7.10"
     }
   },
   "nbformat": 4,
diff --git a/docs/requirements.txt b/docs/requirements.txt
index 5a59efb2..1987806b 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -1,10 +1,14 @@
 # sphinx <4 required by myst-nb v0.12.0 (Feb 2021)
 # sphinx >=3 required by sphinx-autodoc-typehints v1.11.1 (Oct 2020)
-sphinx >=3, <4
+# sphinx >=3, <4 # old version of sphinx dependency, based on two comments above
+
+# New commit to myst-nb (September 2021) suggests it can work with sphinx >4 (see https://github.com/executablebooks/MyST-NB/commit/9f6fae2da3f1ce3e726320eade079b8e25a878fa)
+sphinx==4.2.0
 sphinx_rtd_theme
 sphinx-autodoc-typehints==1.11.1
 jupyter-sphinx>=0.3.2
 myst-nb
+jinja2==3.0.0
 
 # Packages used for notebook execution
 matplotlib
diff --git a/examples/free_energy_calculation.ipynb b/examples/free_energy_calculation.ipynb
new file mode 100644
index 00000000..f874765a
--- /dev/null
+++ b/examples/free_energy_calculation.ipynb
@@ -0,0 +1,768 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Computing the variational free energy in categorical models\n",
+    "\n",
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/infer-actively/pymdp/blob/master/docs/notebooks/free_energy_calculation.ipynb)\n",
+    "\n",
+    "*Author: Conor Heins*\n",
+    "\n",
+    "This notebook walks the user through the computation of the variational free energy (or *VFE*) for discrete generative models, composed of categorical distributions. We can represent these sorts of generative models easily in array-focused programming languages like `NumPy` and `MATLAB` using matrices and vectors.\n",
+    "\n",
+    "In the discrete state-space formulation, the variational free energy is very straightforward to compute when we take advantage of the NDarray representation of probability distributions. The highly-optimized matrix algebra built into today's numerical computing paradigms can be exploited to write simple, one-line expressions for information-theoretic terms (like Kullback-Leibler divergences, cross-entropies, log-likelihoods, etc.). All these terms end up being variants of things like inner products, matrix-vector products or matrix-matrix multiplications.\n",
+    "\n",
+    "This notebook is inspired by the supplementary MATLAB script for the paper [\"A Step-by-Step Tutorial on Active Inference Modelling and its Application to Empirical Data\"](https://www.sciencedirect.com/science/article/pii/S0022249621000973) by Ryan Smith, Karl Friston, and Christopher Whyte. The original MATLAB script is called `VFE_calculation_example.m`, and can be found on [Ryan Smith's GitHub repository](https://github.com/rssmith33/Active-Inference-Tutorial-Scripts), which also contains a set of tutorial scripts that are supplementary to their paper."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*Note*: When running this notebook in Google Colab, you may have to run `!pip install inferactively-pymdp` at the top of the notebook, before you can `import pymdp`. That cell is left commented out below, in case you are running this notebook from Google Colab."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ! pip install inferactively-pymdp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports\n",
+    "\n",
+    "First, import `pymdp` and the modules we'll need."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "import pathlib\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from IPython.display import display, Latex\n",
+    "\n",
+    "path = pathlib.Path(os.getcwd())\n",
+    "module_path = str(path.parent) + '/'\n",
+    "sys.path.append(module_path)\n",
+    "\n",
+    "from pymdp import utils, maths"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A simple generative model composed of a likelihood and a prior\n",
+    "\n",
+    "We begin by constructing a simple generative model composed of two sets of categorical distributions: a likelihood distribution $P(o|s)$ and a prior distribution $P(s)$. \n",
+    "\n",
+    "Because both of these distributions are categorical distributions, we can represent them easily in code using matrices and vectors. The likelihood distribution is a conditional distribution that tells the probability that the generative model assigns to different observations, given different hidden states. Since observations and hidden states are both discrete, this can be efficiently represented as a matrix, each of whose **columns** store the conditional probabilities of all the observations (the **rows**), given a particular hidden state. Each hidden state setting is thus indexed by a column. For this reason, each column of this matrix is a categorical probability distributions and its entries must sum to one. \n",
+    "\n",
+    "The prior is represented as a 1-D vector and stores the prior probabilities that the generative model assigns to each hidden state. \n",
+    "\n",
+    "Finally, to set ourselves up later for showing model inversion and free energy calculations, we initialize an observation that we assume the agent or generative model has \"gathered\" or \"seen.\" In `pymdp` we can represent these observations either as one-hot vectors (a `1` in one entry, and `0`'s everywhere else) or more sparsely as simple indices (integers) that represent *which* of the observations was observed. Because observations are not distributions (or technically, they are Dirac distributions), you don't need to store a whole vector of elements, you can just store a particular index.\n",
+    "\n",
+    "Below we create 3 main variables: \n",
+    "\n",
+    "- An `observation` that represents a real observation that the agent or generative model \"sees\". \n",
+    "- The `prior` distribution that represents the agent's prior beliefs about the hidden states\n",
+    "- the `likliheood_dist` that represents the agent's beliefs about how hidden states probabilistically relate to observations.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Define a quick helper function for printing arrays nicely (see https://gist.github.com/braingineer/d801735dac07ff3ac4d746e1f218ab75)\n",
+    "def matprint(mat, fmt=\"g\"):\n",
+    "    col_maxes = [max([len((\"{:\"+fmt+\"}\").format(x)) for x in col]) for col in mat.T]\n",
+    "    for x in mat:\n",
+    "        for i, y in enumerate(x):\n",
+    "            print((\"{:\"+str(col_maxes[i])+fmt+\"}\").format(y), end=\"  \")\n",
+    "        print(\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Observation: 0\n",
+      "\n",
+      "Prior:[0.5 0.5]\n",
+      "\n",
+      "Likelihood:\n",
+      "0.8  0.2  \n",
+      "0.2  0.8  \n"
+     ]
+    }
+   ],
+   "source": [
+    "num_obs = 2 # dimensionality of observations (2 possible observation levels)\n",
+    "num_states = 2 # dimensionality of observations (2 possible hidden state levels)\n",
+    "\n",
+    "observation = 0 # index representation\n",
+    "# observation = np.array([1, 0]) # one hot representation\n",
+    "# observation = utils.onehot(0, num_obs) # one hot representation, but use one of pymdp's utility functions to create a one-hot\n",
+    "\n",
+    "prior = np.array([0.5, 0.5]) # simply set it by hand\n",
+    "# prior = np.ones(num_states) / num_states # create a uniform prior distribution by creating a vector of ones and dividing each by the number of states\n",
+    "# prior = utils.norm_dist(np.ones(num_states)) # use one of pymdp's utility functions to normalize any vector into a probability distribution\n",
+    "\n",
+    "likelihood_dist = np.array([ [0.8, 0.2],\n",
+    "                        [0.2, 0.8] ])\n",
+    "\n",
+    "if isinstance(observation, np.ndarray):\n",
+    "    print(f'Observation:{observation}\\n')\n",
+    "else:\n",
+    "    print(f'Observation: {observation}\\n')\n",
+    "print(f'Prior:{prior}\\n')\n",
+    "print('Likelihood:')\n",
+    "matprint(likelihood_dist)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bayesian inference\n",
+    "\n",
+    "Before we define variational free energy for this generative model, let's step through the computations involved in inverting this model using Bayes' rule, i.e. computing the optimal Bayesian posterior over hidden states, given our sensory observation (which we will formally refer to as $o_t$). By performing exact Bayesian inference first, we can directly compares its results to that of variational free energy minimization. This will help us better understand the meaning of the free energy calculations that come later.\n",
+    "\n",
+    "#### 1. Compute the likelihood over hidden states, given the observation \n",
+    "\n",
+    "Now that we have a generative model and have fixed a particular observatio $o_t$ (`observation`), we have to perform Bayes' rule to compute the posterior. Mathematically, this can be expressed as follows:\n",
+    "\n",
+    "### $ \\hspace{60mm} P(s | o _t) = \\frac{P(o = o_t | s)P(s)}{P(o = o_t)} $\n",
+    "\n",
+    "Computing the posterior via Bayes' rule (also known as \"model inversion\") is the essence of optimal statistical inference, when one has a generative model of how one's data is caused, and some data. \n",
+    "\n",
+    "To start with, let's computing the likelihood term $P(o = o_t | s)$. We can represent the computation of the likelihood with this line of `NumPy`: ``likelihood_dist[observation,:]``. By doing so, we are providing a numerical answer to the question: \"What is the likelihood that State 1 vs State 2 caused the actual sensory data $o_t$ that I've observed?\".\n",
+    "\n",
+    " Mathematically, our likelihood function $P(o = o_t | s)$ (in the statistics literature also referred to as $L(\\theta)$) is a *function of the hidden states*. The particular function over hidden states we use is *defined* by the observation $o_t$. So you can think of the likelihood as a multi-dimensional function or simply a space of functions, where the particular function you use for inference is determined by your data.\n",
+    "\n",
+    "This act of computing the likelihood via an indexing  operation ``likelihood_dist[observation,:]``, is similar in spirit to the operation of *conditioning*. We are, in some sense, \"conditioning\" on a particular observation (slicing out a \"row\" of our ``likelihood_dist`` matrix), and then looking at the *induced* likelihood over possible causes (hidden states) that could've have been the latent source of that observation. This operation captures the essence of what we mean when we speak of \"inverting\" generative models. Generative models are referred to as *generative* because they can be used to generate fictive observations, given some fixed setting of latent parameters. *Inversion* is thus moving in the opposite direction -- given some sensory data, what is the consequent likelihood over the *causes* or hidden states that might have generated that data?\n",
+    "\n",
+    "**Note**: We can also compute the likelihood using a matrix-vector product, if the observation is represented as a one-hot vector.\n",
+    "\n",
+    "```\n",
+    "likelihood_s = likelihood_dist.T @ observation\n",
+    "```\n",
+    "\n",
+    "You can see think of this as a weighted average of the rows of the likelihood matrix, where the weights are provided by the observations. Since we have insisted that the observations are a one-hot vector, this is equivalent to just selecting a single row of the likelihood matrix (the one indexed by the entry of the observation that is `1.0`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(o=o_t|s):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.8 0.2]\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "if isinstance(observation, np.ndarray): # use the matrix-vector version if your observation is a one-hot vector\n",
+    "    likelihood_s = likelihood_dist.T @ observation\n",
+    "elif isinstance(observation, int): # use the index version if your observation is an integer index\n",
+    "    likelihood_s = likelihood_dist[observation,:] \n",
+    "display(Latex(f'$P(o=o_t|s):$'))\n",
+    "print(f'{likelihood_s}')\n",
+    "print('==================\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2. The joint distribution $P(o = o_t, s) = P(o = o_t|s)P(s)$ \n",
+    "\n",
+    "To compute the full numerator on the right-hand side of the Bayes' rule equation, we need to compute the joint distribution $P(o = o_t|s)P(s)$.\n",
+    "\n",
+    "The joint distribution, which also fully defines the generative model, is the product of the likelihood and prior distributions. The joint distribution expresses the joint probability of observations and hidden states, given the likelihood distribution and the prior over hidden states. If we condition on an actual observation $o_t$, as we have done here, then this joint distribution is, like the likelihood, a function of hidden states. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(o = o_t,s) = P(o = o_t|s)P(s):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.4 0.1]\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "joint_prob = likelihood_s * prior # element-wise product of the likelihood of each hidden state, given the observation, with the prior probability assigned to each hidden state\n",
+    "display(Latex(f'$P(o = o_t,s) = P(o = o_t|s)P(s):$'))\n",
+    "print(f'{joint_prob}')\n",
+    "print('==================\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3. Marginal probability or marginal likelihood: $\\sum_s P(o = o_t, s) = P(o = o_t)$\n",
+    "\n",
+    "Let's remind ourselves of Bayes' rule below:\n",
+    "\n",
+    "#### $ \\hspace{60mm} P(s | o _t) = \\frac{P(o = o_t | s)P(s)}{P(o = o_t)} $\n",
+    "\n",
+    "So far, using the likelihood, the observation, and the prior, we have computed the numerator of this term: the unnormalized joint distribution $P(o = o_t,s)$. All that's left is to do is then divide this term by the denominator $P(o=o_t)$. This term is also referred to as the model evidence or the marginal likelihood. \n",
+    "\n",
+    "This can be thought of as the probability of having seen the particular observation you saw, under all possible settings of the hidden states. This can be computed by marginalizing the joint distribution, using the prior probabilities of the hidden states:\n",
+    "\n",
+    "#### $ \\hspace{60mm}P(o) = \\sum_s P(o|s)P(s)$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p_o = joint_prob.sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4. Compute the posterior $P(s|o=o_t)$\n",
+    "\n",
+    "Now to compute the Bayes-optimal posterior, simply divide the numerator by the denominator!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$P(s|o = o_t) = \\frac{P(o = o_t,s)}{P(o=o_t)}$:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Posterior over hidden states: [0.8 0.2]\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "posterior = joint_prob / p_o # divide the joint by the marginal\n",
+    "display(Latex('$P(s|o = o_t) = \\\\frac{P(o = o_t,s)}{P(o=o_t)}$:'))\n",
+    "print(f'Posterior over hidden states: {posterior}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### The variational free energy\n",
+    "\n",
+    "The variational free energy is an upper bound on **surprise**: surprise is define as $ - \\ln p(o)$, and is also known as the negative (log) evidence. By minimizing free energy, we are **minimizing** surprise and thus **maximizing** log evidence.  This evidence is simply the (log of the) term we computed in the previous step, the normalizing denominator used in Bayes' rule. We can thus first compute the surprise associated with the observation we saw earlier:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$- \\ln P(o=o_t)$:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Surprise: 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "surprise = - np.log(p_o)\n",
+    "\n",
+    "display(Latex('$- \\ln P(o=o_t)$:'))\n",
+    "print(f'Surprise: {surprise.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By minimizing variational free energy with respect to the parameters of an arbitrary, parametrized distribution, also known as the approximate or variational posterior $Q(s)$, we are forcing the surprise to go down, and the model evidence to go up. In doing so, the approximate posterior distribution will get \"closer\" to the true posterior distribution (the $P(s|o)$ we computed above), $Q(s) \\approx P(s|o)$.\n",
+    "\n",
+    "This idea of minimizing a bound on surprise, is the core principle underlying the variational free energy principle, active inference, and the statistical methodology of variational principles more generally. This comes in handy because in many realistic scenarios where agents or systems need to make inferences about the hidden causes of sensory perturbations, performing Bayesian inference exactly becomes intractable (due mostly to the computation of the $P(o)$ denominator term, also known as the normalizing constant). Variational inference turns this intractable marginalization problem into a tractable optimization problem, where one only needs to change the approximate posterior $Q(s)$ in order to minimize a bound on surprise.\n",
+    "\n",
+    "But what is the variational free energy exactly, mathematically? It is commonly written as the expectation, under the approximate posterior, of the log ratio between the approximate posterior and the generative model:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] $\n",
+    "\n",
+    "Because of the rules of logarithms, we can also express this as an expected difference between the log posterior and the log generative model:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)] $\n",
+    "\n",
+    "By doing taking advantage of some more mathematical relationships (the factorization of the joint, rules for logarithms of products, and the definition of the conditional expectation), we can re-write this as an upper bound on surprise:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)] - \\ln P(o) $\n",
+    "\n",
+    "By re-arranging this equality and taking advantage of the fact that the quantity $\\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)]$ (also known as the Kullback-Leibler divergence) is greater than or equal to 0, we can easily show that the VFE is an upper bound on surprise:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} \\geq - \\ln P(o) $\n",
+    "\n",
+    "Let's now compute the VFE numerically for our generative model and fixed observation. Given we already defined those two things ($o_t$ and $P(o,s)$), the last thing we need to do, is to define an initial setting of our approximate posterior $Q(s)$, and compute the variational free energy using one of the formulas above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Variational free energy (F) = 0.916\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# to begin with, set our initial Q(s) equal to our prior distribution -- i.e. a flat/uninformative belief about hidden states\n",
+    "initial_qs = np.array([0.5, 0.5])\n",
+    "\n",
+    "# redefine generative model and observation, for ease\n",
+    "observation = 0\n",
+    "likelihood_dist = np.array([[0.8, 0.2], [0.2, 0.8]])\n",
+    "prior = utils.norm_dist(np.ones(2))\n",
+    "\n",
+    "# compute the joint or generative model using the factorization: P(o=o|s)P(s)\n",
+    "joint_prob = likelihood_dist[observation,:] * prior\n",
+    "\n",
+    "# compute the variational free energy using the expected log difference formulation\n",
+    "initial_F = initial_qs.dot(np.log(initial_qs) - np.log(joint_prob))\n",
+    "## @NOTE: because of log-rules, `initial_F` can also be computed using the division inside the logarithm:\n",
+    "# initial_F = initial_qs.dot(np.log(initial_qs/joint_prob))\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'Variational free energy (F) = {initial_F.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's then change the approximate posterior $Q(s)$ and see what happens to the variational free energy.\n",
+    "\n",
+    "By definition, optimal inference (and 'perfect' VFE minimization) obtains when we set the approximate posterior $Q(s)$ to be equal to the true posterior, $Q(s) = P(s|o)$. \n",
+    "\n",
+    "As an extreme case, let's do this and then measure the variational free energy. We can see that it has decreased, relative to it's initial setting when the approximate posterior was equal to the prior $P(s)$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F = 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "final_qs = posterior.copy() # now we just assert that the approximate posterior is equal to the true posterior\n",
+    "final_F = final_qs.dot(np.log(final_qs) - np.log(joint_prob))\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'F = {final_F.round(3)}')\n",
+    "print('==================')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that the free energy is 0.693 -- if you recall, this is exactly the **surprise** or negative log marginal likelihood $-\\ln P(o = o_t)$, related to the marginal likelihood quantity $P(o=o_t)$ that we had to compute when performing exact Bayesian inference earlier. \n",
+    "\n",
+    "It is easy to see why this equality should hold, when we consider the VFE in terms of the surprise bound:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)] - \\ln P(o) $\n",
+    "\n",
+    "When $Q(s) = P(s|o)$, as we have enforced with the line ``final_qs = posterior.copy()`` above, the first term $\\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(s|o)]$ will become 0. This is a property of the Kullback-Leibler divergence between two distributions $\\operatorname{D}_{KL}(Q \\parallel P) = \\mathbb{E}_{Q}[\\ln Q - \\ln P]$. \n",
+    "\n",
+    "So since that KL divergence is 0, this is a case when the bound on surprise is exact:\n",
+    "\n",
+    "#### $ \\hspace{60mm} \\mathcal{F} = 0 - \\ln P(o) = - \\ln P(o)$\n",
+    "\n",
+    "In other words, minimizing free energy \"as much as possible\" in the case of this generative model, means that the approximate posterior equals the true posterior, and the free energy bound becomes \"tight\", i.e. the free energy simply IS the negative log evidence!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$-\\ln P(o):$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.693\n",
+      "==================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compute the surprise (which we can do analytically for this simple generative model)\n",
+    "p_o = joint_prob.sum()\n",
+    "surprise = - np.log(p_o)\n",
+    "display(Latex('$-\\ln P(o):$'))\n",
+    "print(f'{surprise.round(3)}')\n",
+    "print('==================\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bonus material: auto-differentiation to perform gradient descent on the variational free energy\n",
+    "\n",
+    "In this section, we are going to numerically differentiate the variational free energy with respect to the parameters of the approximate posterior. We can take advantage of modern autodifferentiation software, that can calculate the derivatives of arbitrary computer programs, to compute these derivatives without doing any analytic differentiation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import autograd.numpy as np_auto   # Thinly-wrapped version of Numpy that is auto-differentiable\n",
+    "from autograd import grad          # this is the function that we use to evaluate derivatives\n",
+    "from functools import partial"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, let's create a variational free energy function, that takes as input the variational posterior `qs`, an observation `obs`, the likelihood matrix `likelihood` and a prior distribution `prior`.\n",
+    "\n",
+    "By defining this computation as a function, we can calculate its derivatives automatically using the autodifferentiation package `autograd`, which allows users to pass gradients through arbitrary Python code. It includes a special version of `numpy` (`autograd.numpy`) that has a differentiable back-end. We will thus use this \"special\" verison of `numpy` when we instantiate our arrays and perform numerical operations on them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define the variational free energy as a function of the approximate posterior, an observation, and the generative model\n",
+    "def vfe(qs, obs, likelihood, prior):\n",
+    "    \"\"\"\n",
+    "    Quick docstring below on inputs\n",
+    "    Arguments:\n",
+    "    =========\n",
+    "    `qs` [1D np_auto.ndarray]: variational posterior over hidden states\n",
+    "    `obs` [int]: index of the observation\n",
+    "    `likelihood` [2D np_auto.ndarray]: likelihood distribution P(o|s), relating hidden states probabilistically to observations\n",
+    "    `prior` [1D np_auto.ndarray]: prior over hidden states\n",
+    "    \"\"\"\n",
+    "\n",
+    "    likelihood_s = likelihood[obs,:]\n",
+    "\n",
+    "    joint = likelihood_s * prior\n",
+    "\n",
+    "    vfe = qs @ (np_auto.log(qs) - np_auto.log(joint))\n",
+    "\n",
+    "    return vfe\n",
+    "\n",
+    "# initialize an observation, an initial variational posterior, a prior, and a likelihood matrix\n",
+    "obs = 0\n",
+    "init_qs = np_auto.array([0.5, 0.5])\n",
+    "prior = np_auto.array([0.5, 0.5])\n",
+    "likelihood_dist = np_auto.array([ [0.8, 0.2],\n",
+    "                        [0.2, 0.8] ])\n",
+    "\n",
+    "# this use of `partial` creates a version of the vfe function that is a function of Qs only, \n",
+    "# with the other parameters (the observation, the generative model) fixed as constant parameters\n",
+    "vfe_qs = partial(vfe, obs = obs, likelihood = likelihood_dist, prior = prior)\n",
+    "\n",
+    "# By calling `grad` on a function, we get out a function that can be used to compute the gradients of the VFE with respect to its input (in our case, `qs`)\n",
+    "grad_vfe_qs = grad(vfe_qs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have a variational free energy function, and a derivative function that will give us the gradients of the VFE, with respect $Q(s)$, we can use it to perform a gradient descent on VFE, with respect to the parameters of $Q(s)$. In other words, we will implement this discretized differential equation to update the approximate posterior:\n",
+    "\n",
+    "#### $ \\hspace{60mm} Q(s)_{t+1} =Q(s)_{t} - \\frac{\\partial \\mathcal{F}}{\\partial Q(s)_{t}} $\n",
+    "\n",
+    "Where the gradient term $\\frac{\\partial \\mathcal{F}}{\\partial Q(s)_{t}}$ will simply be the output of the gradient function `grad_vfe_qs` we've defined above.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# number of iterations of gradient descent to perform\n",
+    "n_iter = 40\n",
+    "\n",
+    "qs_hist = np_auto.zeros((n_iter, 2))\n",
+    "qs_hist[0,:] = init_qs\n",
+    "\n",
+    "vfe_hist = np_auto.zeros(n_iter)\n",
+    "vfe_hist[0] = vfe_qs(qs = init_qs)\n",
+    "\n",
+    "learning_rate = 0.1 # learning rate to prevent gradient steps that are too big (overshooting)\n",
+    "for i in range(n_iter-1):   \n",
+    "\n",
+    "    dFdqs = grad_vfe_qs(qs_hist[i,:])\n",
+    "\n",
+    "    ln_qs = np_auto.log(qs_hist[i,:]) - learning_rate * dFdqs # transform qs to log-space to perform gradient descent\n",
+    "    qs_hist[i+1,:] = maths.softmax(ln_qs) # re-normalize to make it a proper, categorical Q(s) again\n",
+    "\n",
+    "    vfe_hist[i+1] = vfe_qs(qs = qs_hist[i+1,:]) # measure final variational free energy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since we were storing the history of the variational free energy over the course of the gradient descent, we can plot its trajectory below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Gradient descent on VFE')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(8,6))\n",
+    "plt.plot(vfe_hist)\n",
+    "plt.ylabel('$\\\\mathcal{F}$', fontsize = 22)\n",
+    "plt.xlabel(\"Iteration\", fontsize = 22)\n",
+    "plt.xlim(0, n_iter)\n",
+    "plt.ylim(vfe_hist[-1], vfe_hist[0])\n",
+    "plt.title('Gradient descent on VFE', fontsize = 24)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Latex object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial F = 0.916\n",
+      "==================\n",
+      "Final posterior:\n",
+      "[0.8 0.2]\n",
+      "==================\n",
+      "Final F = 0.693\n",
+      "==================\n"
+     ]
+    }
+   ],
+   "source": [
+    "final_qs, initial_F, final_F = qs_hist[-1,:], vfe_hist[0], vfe_hist[-1]\n",
+    "\n",
+    "display(Latex('$\\mathcal{F} = \\mathbb{E}_{Q(s)}[\\ln \\\\frac{Q(s)}{P(o, s)}] = \\mathbb{E}_{Q(s)}[\\ln Q(s) - \\ln P(o, s)]:$'))\n",
+    "print(f'Initial F = {initial_F.round(3)}')\n",
+    "print('==================')\n",
+    "\n",
+    "print('Final posterior:')\n",
+    "print(f'{final_qs.round(1)}') # note that because of numerical imprecision in the gradient descent (constant learning rate, etc.), the approximate posterior will not exactly be the optimal posterior\n",
+    "print('==================')\n",
+    "print(f'Final F = {vfe_qs(final_qs).round(3)}')\n",
+    "print('==================')\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "24ee14d9f6452059a99d44b6cbd71d1bb479b0539b0360a6a17428ecea9f0810"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.10 64-bit ('pymdp_env2': conda)",
+   "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.7.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/paper/paper.bib b/paper/paper.bib
new file mode 100644
index 00000000..e0cc4d1b
--- /dev/null
+++ b/paper/paper.bib
@@ -0,0 +1,760 @@
+@article{friston_reinforcement_2009,
+	title = {Reinforcement learning or active inference?},
+	author = {Friston, Karl J. and Daunizeau, Jean and Kiebel, Stefan J.},
+	journal = {PLoS ONE},
+	year = {2009},
+	volume = {4},
+	number = {7},
+	pages = {e6421},
+	doi = {10.1371/journal.pone.0006421}
+}
+
+@article{vanderbroeck2019active,
+  title={Active inference for robot control: A factor graph approach},
+  author={Vanderbroeck, Mees and Baioumy, Mohamed and van der Lans, Daan and de Rooij, Rens and van der Werf, Tiis},
+  journal={Student Undergraduate Research E-journal!},
+  volume={5},
+  pages={1--5},
+  year={2019}
+}
+
+@inproceedings{ergul2020learning,
+  title={Learning Where to Park},
+  author={Ergul, Burak and van de Laar, Thijs and Koudahl, Magnus and Roa-Villescas, Martin and de Vries, Bert},
+  booktitle={International Workshop on Active Inference},
+  pages={125--132},
+  year={2020},
+  organization={Springer}
+}
+
+@article{10.1162/neco_a_01427,
+ author={van de Laar, Thijs and Senoz, Ismail and {\"O}z{\c{c}}elikkale, Ay{\c{c}}a and Wymeersch, Henk},
+ title = {Chance-Constrained Active Inference},
+ journal = {Neural Computation},
+ volume = {33},
+ number = {10},
+ pages = {2710-2735},
+ year = {2021},
+ month = {09},
+ issn = {0899-7667},
+ doi = {10.1162/neco_a_01427},
+ url = {https://doi.org/10.1162/neco\_a\_01427},
+ eprint = {https://direct.mit.edu/neco/article-pdf/33/10/2710/1963501/neco\_a\_01427.pdf},
+ }
+
+@Article{         harris2020array,
+ title         = {Array programming with {NumPy}},
+ author        = {Charles R. Harris and K. Jarrod Millman and St{\'{e}}fan J.
+                 van der Walt and Ralf Gommers and Pauli Virtanen and David
+                 Cournapeau and Eric Wieser and Julian Taylor and Sebastian
+                 Berg and Nathaniel J. Smith and Robert Kern and Matti Picus
+                 and Stephan Hoyer and Marten H. van Kerkwijk and Matthew
+                 Brett and Allan Haldane and Jaime Fern{\'{a}}ndez del
+                 R{\'{i}}o and Mark Wiebe and Pearu Peterson and Pierre
+                 G{\'{e}}rard-Marchant and Kevin Sheppard and Tyler Reddy and
+                 Warren Weckesser and Hameer Abbasi and Christoph Gohlke and
+                 Travis E. Oliphant},
+ year          = {2020},
+ month         = sep,
+ journal       = {Nature},
+ volume        = {585},
+ number        = {7825},
+ pages         = {357--362},
+ doi           = {10.1038/s41586-020-2649-2},
+ publisher     = {Springer Science and Business Media {LLC}},
+ url           = {https://doi.org/10.1038/s41586-020-2649-2}
+}
+
+@misc{heins2022pymdp_arxiv},
+    title={pymdp: A Python library for active inference in discrete state spaces},
+    author={Heins, Conor and Millidge, Beren and Demekas, Daphne and Klein, Brennan and Friston, Karl and Couzin, Iain and Tschantz, Alexander},
+    eprint={2201.03904v1},
+    archivePrefix={arXiv},
+    primaryClass={cs.AI}, 
+    year={2022}
+}
+
+@misc{millidge2021understanding,
+    title={Understanding the origin of information-seeking exploration in probabilistic objectives for control},
+    author={Millidge, Beren and Tschantz, Alexander and Seth, Anil and Buckley, Christopher},
+    eprint={2103.06859v7},
+    archivePrefix={arXiv},
+    primaryClass={cs.LG}, 
+    year={2021}
+}
+
+@article{millidge2021whence,
+    title = {Whence the expected free energy?},
+    author = {Millidge, Beren and Tschantz, Alexander and Buckley, Christopher L.},
+    journal = {Neural Computation},
+    year = {2021},
+    volume = {33},
+    number = {2},
+    pages = {447--482},
+    doi = {10.1162/neco_a_01354}
+}
+
+@article{friston2015active,
+    title = {Active inference and epistemic value},
+    author = {Friston, Karl J. and Rigoli, Francesco and Ognibene, Dimitri and Mathys, Christoph and Fitzgerald, Thomas and Pezzulo, Giovanni},
+    journal = {Cognitive Neuroscience},
+    year = {2015},
+    volume = {6},
+    number = {4},
+    pages = {187--214},
+    doi = {10.1080/17588928.2015.1020053}
+}
+
+@article{parr2019neuronal,
+    title = {Neuronal message passing using Mean-field, Bethe, and Marginal approximations},
+    author = {Parr, Thomas and Markovic, Dimitrije and Kiebel, Stefan J. and Friston, Karl J.},
+    journal = {Scientific Reports},
+    year = {2019},
+    volume = {9},
+    number = {1},
+    pages = {1--18},
+    doi = {10.1038/s41598-018-38246-3}
+}
+
+@book{wainwright2008graphical,
+    title = {Graphical models, exponential families, and variational inference},
+    author = {Wainwright, Martin J. and Jordan, Michael Irwin},
+    year = {2008},
+    volume = {1},
+    publisher = {Now Publishers Inc},
+    doi = {10.1561/2200000001}
+}
+
+@book{beal2003variational,
+    title = {{Variational Algorithms for Approximate Bayesian Inference}},
+    author = {Beal, Matthew James},
+    year = {2003},
+    publisher = {University of London, University College London},
+    url = {https://cse.buffalo.edu/faculty/mbeal/thesis/}
+}
+
+@inproceedings{yedidia2000generalized,
+    title = {Generalized belief propagation},
+    author = {Yedidia, Jonathan S. and Freeman, William T. and Weiss, Yair},
+    booktitle = {Advances in Neural Information Processing Systems},
+    volume = {13},
+    pages = {689--695},
+    year = {2000},
+    url = {https://dl.acm.org/doi/10.5555/3008751.3008848}
+}
+
+@article{winn2005variational,
+    title = {Variational message passing},
+    author = {Winn, John and Bishop, Christopher M.},
+    journal = {Journal of Machine Learning Research},
+    year = {2005},
+    volume = {6},
+    number = {23},
+    pages = {661--694},
+    url = {http://jmlr.org/papers/v6/winn05a.html}
+}
+
+@article{leptourgos2020circular,
+    title = {Circular inference in bistable perception},
+    author = {Leptourgos, Pantelis and Notredame, Charles-Edouard and Eck, Marion and Jardri, Renaud and Den{\`e}ve, Sophie},
+    journal = {Journal of Vision},
+    year = {2020},
+    volume = {20},
+    number = {4},
+    pages = {12},
+    doi = {10.1167/jov.20.4.12}
+}
+
+@article{jardri2017experimental,
+    title = {Experimental evidence for circular inference in schizophrenia},
+    author = {Jardri, Renaud and Duverne, Sandrine and Litvinova, Alexandra S. and Den{\`e}ve, Sophie},
+    journal = {Nature Communications},
+    year = {2017},
+    volume = {8},
+    number = {14218},
+    pages = {1--13},
+    doi = {10.1038/ncomms14218}
+}
+
+@article{parr2020modules,
+    title = {Modules or mean-fields?},
+    author = {Parr, Thomas and Sajid, Noor and Friston, Karl J.},
+    journal = {Entropy},
+    year = {2020},
+    volume = {22},
+    number = {5},
+    pages = {552},
+    doi = {10.3390/e22050552}
+}
+
+@article{mackay1992bayesian,
+    title = {Bayesian interpolation},
+    author = {MacKay, David J.C.},
+    journal = {Neural Computation},
+    year = {1992},
+    volume = {4},
+    number = {3},
+    pages = {415--447},
+    doi = {10.1162/neco.1992.4.3.415}
+}
+
+@article{penny2004modelling,
+    title = {Modelling functional integration: A comparison of structural equation and dynamic causal models},
+    author = {Penny, Will D. and Stephan, Klaas E. and Mechelli, Andrea and Friston, Karl J.},
+    journal = {NeuroImage},
+    year = {2004},
+    volume = {23},
+    pages = {S264--S274},
+    doi = {10.1016/j.neuroimage.2004.07.041}
+}
+
+@article{blei2017variational,
+    title = {Variational inference: A review for statisticians},
+    author = {Blei, David M. and Kucukelbir, Alp and McAuliffe, Jon D.},
+    journal = {Journal of the American Statistical Association},
+    year = {2017},
+    volume = {112},
+    number = {518},
+    pages = {859--877},
+    doi = {10.1080/01621459.2017.1285773}
+}
+
+@article{markov2013cortical,
+    title = {Cortical high-density counterstream architectures},
+    author = {Markov, Nikola T. and Ercsey-Ravasz, M{\'a}ria and Van Essen, David C. and Knoblauch, Kenneth and Toroczkai, Zolt{\'a}n and Kennedy, Henry},
+    journal = {Science},
+    year = {2013},
+    volume = {342},
+    number = {6158},
+    doi = {10.1126/science.1238406}
+}
+
+@article{friston_active_2012,
+	title = {Active inference and agency: Optimal control without cost functions},
+	author = {Friston, Karl J. and Samothrakis, Spyridon and Montague, Read},
+	journal = {Biological Cybernetics},
+	year = {2012},
+	volume = {106},
+	number = {8-9},
+	pages = {523--541},
+    doi = {10.1007/s00422-012-0512-8}
+}
+
+@article{montague2012computational,
+    title = {Computational psychiatry},
+    author = {Montague, P. Read and Dolan, Raymond J. and Friston, Karl J. and Dayan, Peter},
+    journal = {Trends in Cognitive Sciences},
+    year = {2012},
+    volume = {16},
+    number = {1},
+    pages = {72--80},
+    doi = {10.1016/j.tics.2011.11.018}
+}
+
+@inproceedings{tschantz2020reinforcement,
+    title = {Reinforcement learning through active inference},
+    author = {Tschantz, Alexander and Millidge, Beren and Seth, Anil K. and Buckley, Christopher L.},
+    booktitle = {Bridging AI and Cognitive Science at the International Conference on Learning Representations},
+    year = {2020},
+    url = {https://baicsworkshop.github.io/pdf/BAICS_37.pdf}
+}
+
+@article{sajid2021active,
+    title = {Active inference: Demystified and compared},
+    author = {Sajid, Noor and Ball, Philip J. and Parr, Thomas and Friston, Karl J.},
+    journal = {Neural Computation},
+    year = {2021},
+    volume = {33},
+    number = {3},
+    pages = {674--712},
+    doi = {10.1162/neco_a_01357}
+}
+
+@inproceedings{tschantz2020scaling,
+    title = {Scaling active inference},
+    author = {Tschantz, Alexander and Baltieri, Manuel and Seth, Anil K. and Buckley, Christopher L.},
+    booktitle = {2020 International Joint Conference on Neural Networks (IJCNN)},
+    year = {2020},
+    pages = {1--8},
+    organization = {IEEE},
+    doi = {10.1109/IJCNN48605.2020.9207382}
+}
+
+@article{mishkin1983object,
+    title = {Object vision and spatial vision: Two cortical pathways},
+    author = {Mishkin, Mortimer and Ungerleider, Leslie G and Macko, Kathleen A.},
+    journal = {Trends in Neurosciences},
+    year = {1983},
+    volume = {6},
+    pages = {414--417},
+    doi = {10.1016/0166-2236(83)90190-X}
+}
+
+@article{zeki1991direct,
+    title = {A direct demonstration of functional specialization in human visual cortex},
+    author = {Zeki, Semir and Watson, J.D. and Lueck, C.J. and Friston, Karl J. and Kennard, C. and Frackowiak, R.S.},
+    journal = {Journal of Neuroscience},
+    year = {1991},
+    volume = {11},
+    number = {3},
+    pages = {641--649},
+    doi = {10.1523/JNEUROSCI.11-03-00641.1991}
+}
+
+@article{friston2017process,
+    title = {Active inference: A process theory},
+    author = {Friston, Karl J. and FitzGerald, Thomas and Rigoli, Francesco and Schwartenbeck, Philipp and Pezzulo, Giovanni},
+    journal = {Neural Computation},
+    year = {2017},
+    volume = {29},
+    number = {1},
+    pages = {1--49},
+    doi = {10.1162/NECO_a_00912}
+}
+
+@article{baltieri2019pid,
+    title = {PID control as a process of active inference with linear generative models},
+    author = {Baltieri, Manuel and Buckley, Christopher L.},
+    journal = {Entropy},
+    year = {2019},
+    volume = {21},
+    number = {3},
+    pages = {257},
+    doi = {10.3390/e21030257}
+}
+
+@inproceedings{fountas2020deep,
+    title = {Deep active inference agents using Monte-Carlo methods},
+    author = {Fountas, Zafeirios and Sajid, Noor and Mediano, Pedro A.M. and Friston, Karl J.},
+    booktitle = {Advances in Neural Information Processing Systems},
+    year = {2020},
+    url = {https://proceedings.neurips.cc/paper/2020/hash/865dfbde8a344b44095495f3591f7407-Abstract.html}
+}
+
+@article{van2019simulating,
+    title = {Simulating active inference processes by message passing},
+    author = {van de Laar, Thijs W. and de Vries, Bert},
+    journal = {Frontiers in Robotics and AI},
+    year = {2019},
+    volume = {6},
+    pages = {20},
+    doi = {10.3389/frobt.2019.00020}
+}
+
+@article{ueltzhoffer2018deep,
+    title = {Deep active inference},
+    author = {Ueltzh{\"o}ffer, Kai},
+    journal = {Biological Cybernetics},
+    year = {2018},
+    volume = {112},
+    number = {6},
+    pages = {547--573},
+    doi = {10.1007/s00422-018-0785-7}
+}
+
+@article{tschantz2020learning,
+    title = {Learning action-oriented models through active inference},
+    author = {Tschantz, Alexander and Seth, Anil K. and Buckley, Christopher L.},
+    journal = {PLoS Computational Biology},
+    year = {2020},
+    volume = {16},
+    number = {4},
+    pages = {e1007805},
+    doi = {10.1371/journal.pcbi.1007805}
+}
+
+@inproceedings{ccatal2020learning,
+    title = {Learning perception and planning with deep active inference},
+    author = {{\c{C}}atal, Ozan and Verbelen, Tim and Nauta, Johannes and De Boom, Cedric and Dhoedt, Bart},
+    booktitle = {IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
+    year = {2020},
+    pages = {3952--3956},
+    organization = {IEEE},
+    doi = {10.1109/ICASSP40776.2020.9054364}
+}
+
+@book{penny2011statistical,
+    title = {Statistical parametric mapping: The analysis of functional brain images},
+    author = {Penny, William D. and Friston, Karl J. and Ashburner, John T. and Kiebel, Stefan J. and Nichols, Thomas E.},
+    year = {2007},
+    isbn = {978-0-12-372560-8},
+    doi = {10.1016/B978-0-12-372560-8.X5000-1}
+}
+
+@article{friston2010free,
+    title = {The free-energy principle: A unified brain theory?},
+    author = {Friston, Karl J.},
+    journal = {Nature Reviews Neuroscience},
+    year = {2010},
+    volume = {11},
+    number = {2},
+    pages = {127--138},
+    doi = {10.1038/nrn2787}
+}
+
+@article{da2020active,
+    title = {Active inference on discrete state-spaces: A synthesis},
+    author = {Da Costa, Lancelot and Parr, Thomas and Sajid, Noor and Veselic, Sebastijan and Neacsu, Victorita and Friston, Karl J.},
+    journal = {Journal of Mathematical Psychology},
+    year = {2020},
+    volume = {99},
+    pages = {102447},
+    doi = {10.1016/j.jmp.2020.102447}
+}
+
+@article{kaelbling1998planning,
+    title = {Planning and acting in partially observable stochastic domains},
+    author = {Kaelbling, Leslie Pack and Littman, Michael L. and Cassandra, Anthony R.},
+    journal = {Artificial Intelligence},
+    year = {1998},
+    volume = {101},
+    number = {1-2},
+    pages = {99--134},
+    doi = {10.1016/S0004-3702(98)00023-X}
+}
+
+@article{friston2021sophisticated,
+    title = {Sophisticated inference},
+    author = {Friston, Karl J. and Da Costa, Lancelot and Hafner, Danijar and Hesp, Casper and Parr, Thomas},
+    journal = {Neural Computation},
+    year = {2021},
+    volume = {33},
+    number = {3},
+    pages = {713--763},
+    doi = {10.1162/neco_a_01351}
+}
+
+@article{schwartenbeck2015dopaminergic,
+    title = {The dopaminergic midbrain encodes the expected certainty about desired outcomes},
+    author = {Schwartenbeck, Philipp and FitzGerald, Thomas and Mathys, Christoph and Dolan, Ray and Friston, Karl J.},
+    journal = {Cerebral Cortex},
+    year = {2015},
+    volume = {25},
+    number = {10},
+    pages = {3434--3445},
+    doi = {10.1093/cercor/bhu159}
+}
+
+@article{smith2020imprecise,
+    title = {Imprecise action selection in substance use disorder: Evidence for active learning impairments when solving the explore-exploit dilemma},
+    author = {Smith, Ryan and Schwartenbeck, Philipp and Stewart, Jennifer L. and Kuplicki, Rayus and Ekhtiari, Hamed and Paulus, Martin P. and {Tulsa 1000 Investigators}},
+    journal = {Drug and Alcohol Dependence},
+    year = {2020},
+    volume = {215},
+    pages = {108208},
+    doi = {10.1016/j.drugalcdep.2020.108208}
+}
+
+@article{smith2021greater,
+    title = {Greater decision uncertainty characterizes a transdiagnostic patient sample during approach-avoidance conflict: A computational modelling approach},
+    author = {Smith, Ryan and Kirlic, Namik and Stewart, Jennifer L. and Touthang, James and Kuplicki, Rayus and Khalsa, Sahib S. and Feinstein, Justin and Paulus, Martin P. and Aupperle, Robin L.},
+    journal = {Journal of Psychiatry \& Neuroscience},
+    year = {2021},
+    volume = {46},
+    number = {1},
+    pages = {E74},
+    doi = {10.1503/jpn.200032}
+}
+
+@article{smith2022step,
+  title={A step-by-step tutorial on active inference and its application to empirical data},
+  author={Smith, Ryan and Friston, Karl J and Whyte, Christopher J},
+  journal={Journal of Mathematical Psychology},
+  volume={107},
+  pages={102632},
+  year={2022},
+  publisher={Elsevier},
+  doi={10.1016/j.jmp.2021.102632}
+}
+
+@article{friston2008variational,
+    title = {DEM: A variational treatment of dynamic systems},
+    author = {Friston, Karl J. and Trujillo-Barreto, N. and Daunizeau, Jean},
+    journal = {NeuroImage},
+    volume = {41},
+    number = {3},
+    pages = {849--885},
+    year = {2008},
+    doi = {10.1016/j.neuroimage.2008.02.054}
+}
+
+@misc{friston2019free,
+  title={A free energy principle for a particular physics},
+  author={Friston, Karl},
+  eprint={1906.10184v1},
+  archivePrefix={arXiv},
+  primaryClass={q-bio.NC}, 
+  year={2019}
+}
+
+@article{millidge2020deep,
+    title = {Deep active inference as variational policy gradients},
+    author = {Millidge, Beren},
+    journal = {Journal of Mathematical Psychology},
+    year = {2020},
+    volume = {96},
+    pages = {102348},
+    doi = {10.1016/j.jmp.2020.102348}
+}
+
+@inproceedings{millidge2020relationship,
+    title = {On the relationship between active inference and control as inference},
+    author = {Millidge, Beren and Tschantz, Alexander and Seth, Anil K. and Buckley, Christopher L.},
+    booktitle = {International Workshop on Active Inference},
+    year = {2020},
+    pages = {3--11},
+    organization = {Springer},
+    doi = {10.1007/978-3-030-64919-7_1}
+}
+
+@article{ForneyLab2019,
+	title = {A factor graph approach to automated design of {Bayesian} signal processing algorithms},
+	volume = {104},
+	issn = {0888-613X},
+	url = {http://www.sciencedirect.com/science/article/pii/S0888613X18304298},
+	doi = {10.1016/j.ijar.2018.11.002},
+	abstract = {The benefits of automating design cycles for Bayesian inference-based algorithms are becoming increasingly recognized by the machine learning community. As a result, interest in probabilistic programming frameworks has much increased over the past few years. This paper explores a specific probabilistic programming paradigm, namely message passing in Forney-style factor graphs (FFGs), in the context of automated design of efficient Bayesian signal processing algorithms. To this end, we developed “ForneyLab”2 as a Julia toolbox for message passing-based inference in FFGs. We show by example how ForneyLab enables automatic derivation of Bayesian signal processing algorithms, including algorithms for parameter estimation and model comparison. Crucially, due to the modular makeup of the FFG framework, both the model specification and inference methods are readily extensible in ForneyLab. In order to test this framework, we compared variational message passing as implemented by ForneyLab with automatic differentiation variational inference (ADVI) and Monte Carlo methods as implemented by state-of-the-art tools “Edward” and “Stan”. In terms of performance, extensibility and stability issues, ForneyLab appears to enjoy an edge relative to its competitors for automated inference in state-space models.},
+	urldate = {2018-11-16},
+	journal = {International Journal of Approximate Reasoning},
+	author = {Cox, Marco and van de Laar, Thijs and de Vries, Bert},
+	month = jan,
+	year = {2019},
+	keywords = {Bayesian inference, Message passing, Factor graphs, Julia, Probabilistic programming},
+	pages = {185--204}
+}
+
+@misc{baltieri2019generative,
+  title={Generative models as parsimonious descriptions of sensorimotor loops},
+  author={Baltieri, Manuel and Buckley, Christopher L},
+  eprint={1904.12937v1},
+  archivePrefix={arXiv},
+  primaryClass={q-bio.NC}, 
+  year={2019}
+}
+
+@article{gregory1980perceptions,
+  title={Perceptions as hypotheses},
+  author={Gregory, Richard Langton},
+  journal={Philosophical Transactions of the Royal Society of London. B, Biological Sciences},
+  volume={290},
+  number={1038},
+  pages={181--197},
+  year={1980},
+  publisher={The Royal Society London},
+  doi={10.1098/rstb.1980.0090}
+}
+
+@misc{brockman2016openai,
+  title={Openai gym},
+  author={Brockman, Greg and Cheung, Vicki and Pettersson, Ludwig and Schneider, Jonas and Schulman, John and Tang, Jie and Zaremba, Wojciech},
+  eprint={1606.01540v1},
+  archivePrefix={arXiv},
+  primaryClass={cs.LG},
+  year={2016}
+}
+
+@article{friston2016active,
+    title = {Active inference and learning},
+    author = {Friston, Karl J. and FitzGerald, Thomas and Rigoli, Francesco and Schwartenbeck, Philipp and O'Doherty, John and Pezzulo, Giovanni},
+    journal = {Neuroscience \& Biobehavioral Reviews},
+    year = {2016},
+    volume = {68},
+    pages = {862--879},
+    doi = {10.1016/j.neubiorev.2016.06.022}
+}
+
+@article{dayan1995helmholtz,
+    title = {The Helmholtz Machine},
+    author = {Dayan, Peter and Hinton, Geoffrey E. and Neal, Radford M. and Zemel, Richard S.},
+    journal = {Neural Computation},
+    year = {1995},
+    volume = {7},
+    number = {5},
+    pages = {889--904},
+    doi = {10.1162/neco.1995.7.5.889}
+}
+
+@misc{von1910treatise,
+    title = {Treatise on physiological optics (Vol. 3)},
+    author = {Von Helmholtz, Herman and Southall, JPC},
+    year = {1910},
+    publisher = {Dover, New York},
+    doi = {10.1037/13536-000}
+}
+
+@inproceedings{hinton1983optimal,
+    title = {Optimal perceptual inference},
+    author = {Hinton, Geoffrey E. and Sejnowski, Terrence J.},
+    booktitle = {Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
+    volume = {448},
+    year = {1983},
+    organization = {Citeseer},
+    url = {http://www.cs.toronto.edu/~hinton/absps/optimal.pdf}
+}
+
+@misc{baioumy2021towards,
+    title = {Towards stochastic fault-tolerant control using precision learning and active inference},
+    author = {Baioumy, Mohamed and Pezzato, Corrado and Corbato, Carlos Hernandez and Hawes, Nick and Ferrari, Riccardo},
+    eprint={2109.05870v1},
+    archivePrefix={arXiv},
+    primaryClass={cs.RO},
+    year={2021}
+}
+
+@article{ccatal2021robot,
+    title = {Robot navigation as hierarchical active inference},
+    author = {{\c{C}}atal, Ozan and Verbelen, Tim and Van de Maele, Toon and Dhoedt, Bart and Safron, Adam},
+    journal = {Neural Networks},
+    year = {2021},
+    volume = {142},
+    pages = {192--204},
+    doi = {10.1016/j.neunet.2021.05.010}
+}
+
+@article{wirkuttis2021leading,
+    title = {Leading or following? Dyadic robot imitative interaction using the active inference framework},
+    author = {Wirkuttis, Nadine and Tani, Jun},
+    journal = {IEEE Robotics and Automation Letters},
+    year = {2021},
+    volume = {6},
+    number = {3},
+    pages = {6024--6031},
+    doi = {10.1109/LRA.2021.3090015}
+}
+
+@article{martinez2021probabilistic,
+    title = {Probabilistic modeling for optimization of bioreactors using reinforcement learning with active inference},
+    author = {Mart{\'i}nez, Ernesto C. and Kim, Jong Woo and Barz, Tilman and Bournazou, Mariano N. Cruz},
+    journal = {Computer Aided Chemical Engineering},
+    year = {2021},
+    volume = {50},
+    pages = {419--424},
+    doi = {10.1016/B978-0-323-88506-5.50066-8}
+}
+
+@misc{moreno2021pid,
+    title = {PID control as a process of active inference applied to a refrigeration system},
+    author = {Moreno, Adri{\'a}n Rocandio},
+    year = {2021},
+    url = {https://projekter.aau.dk/projekter/files/415131289/1034_PID_Control_as_Active_Inference.pdf}
+}
+
+@article{parr2019generalised,
+    title = {Generalised free energy and active inference},
+    author = {Parr, Thomas and Friston, Karl J.},
+    journal = {Biological Cybernetics},
+    year = {2019},
+    volume = {113},
+    number = {5},
+    pages = {495--513},
+    doi = {10.1007/s00422-019-00805-w}
+}
+
+@misc{hipolito2021enactive,
+    title = {Enactive-Dynamic Social Cognition and Active Inference},
+    author = {Hip{\'o}lito, In{\^e}s and van Es, Thomas},
+    year = {2021},
+    url = {http://philsci-archive.pitt.edu/19653/}
+}
+
+@article{fox2021active,
+    title = {Active inference: Applicability to different types of social organization explained through reference to industrial engineering and quality management},
+    author = {Fox, Stephen},
+    journal = {Entropy},
+    year = {2021},
+    volume = {23},
+    number = {2},
+    pages = {198},
+    doi = {10.3390/e23020198}
+}
+
+@article{tison2021communication,
+    title = {Communication as socially extended active inference: An ecological approach to communicative behavior},
+    author = {Tison, Remi and Poirier, Pierre},
+    journal = {Ecological Psychology},
+    year = {2021},
+    volume = {33},
+    pages = {197--235},
+    doi = {10.1080/10407413.2021.1965480}
+}
+
+@article{friston2013life,
+    title = {Life as we know it},
+    author = {Friston, Karl J.},
+    journal = {Journal of the Royal Society Interface},
+    year = {2013},
+    volume = {10},
+    number = {86},
+    pages = {20130475},
+    doi = {10.1098/rsif.2013.0475}
+}
+
+@article{schwartenbeck2019computational,
+    title = {Computational mechanisms of curiosity and goal-directed exploration},
+    author = {Schwartenbeck, Philipp and Passecker, Johannes and Hauser, Tobias U. and FitzGerald, Thomas and Kronbichler, Martin and Friston, Karl J.},
+    journal = {Elife},
+    year = {2019},
+    volume = {8},
+    pages = {e41703},
+    doi = {10.7554/eLife.41703}
+}
+
+@article{friston2017active,
+    title = {Active inference, curiosity and insight},
+    author = {Friston, Karl J. and Lin, Marco and Frith, Christopher D. and Pezzulo, Giovanni and Hobson, J. Allan and Ondobaka, Sasha},
+    journal = {Neural Computation},
+    year = {2017},
+    volume = {29},
+    number = {10},
+    pages = {2633--2683},
+    doi = {10.1162/neco_a_00999}
+}
+
+@misc{lance_lnA,
+  author = "Da Costa, Lancelot",
+  date = "2021",
+  howpublished = "Personal communication"
+}
+
+@article{holmes2021active,
+  title={Active inference, selective attention, and the cocktail party problem},
+  author={Holmes, Emma and Parr, Thomas and Griffiths, Timothy D and Friston, Karl J},
+  journal={Neuroscience \& Biobehavioral Reviews},
+  volume={131},
+  pages={1288--1304},
+  year={2021},
+  publisher={Elsevier},
+  doi={10.1016/j.neubiorev.2021.09.038}
+}
+
+@article{adams2021everything,
+  title={Everything is connected: Inference and attractors in delusions},
+  author={Adams, Rick A and Vincent, Peter and Benrimoh, David and Friston, Karl J and Parr, Thomas},
+  journal={Schizophrenia research},
+  year={2021},
+  publisher={Elsevier},
+  doi={10.1016/j.schres.2021.07.032}
+}
+
+@article{parr2020prefrontal,
+  title={Prefrontal computation as active inference},
+  author={Parr, Thomas and Rikhye, Rajeev Vijay and Halassa, Michael M and Friston, Karl J},
+  journal={Cerebral Cortex},
+  volume={30},
+  number={2},
+  pages={682--695},
+  year={2020},
+  publisher={Oxford University Press}
+}
+
+@article{smith2021long,
+  title={Long-term stability of computational parameters during approach-avoidance conflict in a transdiagnostic psychiatric patient sample},
+  author={Smith, Ryan and Kirlic, Namik and Stewart, Jennifer L and Touthang, James and Kuplicki, Rayus and McDermott, Timothy J and Taylor, Samuel and Khalsa, Sahib S and Paulus, Martin P and Aupperle, Robin L},
+  journal={Scientific reports},
+  volume={11},
+  number={1},
+  pages={1--13},
+  year={2021},
+  publisher={Nature Publishing Group},
+  doi={10.1038/s41598-021-91308-x}
+}
\ No newline at end of file
diff --git a/paper/paper.md b/paper/paper.md
new file mode 100644
index 00000000..f982517a
--- /dev/null
+++ b/paper/paper.md
@@ -0,0 +1,92 @@
+---
+title: 'pymdp: A Python library for active inference in discrete state spaces'
+tags:
+  - Python
+  - active inference
+  - Markov Decision Process
+  - POMDP
+  - MDP
+  - Reinforcement Learning
+  - Artificial Intelligence
+  - Bayesian inference
+  - free energy principle
+authors:
+  - name: Conor Heins^[corresponding author]
+    affiliation: "1, 2, 3, 4"
+  - name: Beren Millidge
+    affiliation: "4, 5"
+  - name: Daphne Demekas
+    affiliation: "6"
+  - name: Brennan Klein
+    orcid: 0000-0001-8326-5044
+    affiliation: "4, 7, 8"
+  - name: Karl Friston
+    affiliation: "9" 
+  - name: Iain D. Couzin
+    affiliation: "1, 2, 3" 
+  - name: Alexander Tschantz^[corresponding author]
+    affiliation: "4, 10, 11"
+affiliations:
+ - name: Department of Collective Behaviour, Max Planck Institute of Animal Behavior, 78457 Konstanz, Germany
+   index: 1
+ - name: Centre for the Advanced Study of Collective Behaviour, 78457 Konstanz, Germany
+   index: 2
+ - name: Department of Biology, University of Konstanz, 78457 Konstanz, Germany
+   index: 3
+ - name: VERSES Research Lab, Los Angeles, California, USA
+   index: 4
+ - name: MRC Brain Networks Dynamics Unit, University of Oxford, Oxford, UK
+   index: 5
+ - name: Department of Computing, Imperial College London, London, UK
+   index: 6
+ - name: Network Science Institute, Northeastern University, Boston, MA, USA
+   index: 7
+ - name: Laboratory for the Modeling of Biological and Socio-Technical Systems, Northeastern University, Boston, USA
+   index: 8
+ - name: Wellcome Centre for Human Neuroimaging, Queen Square Institute of Neurology, University College London, London WC1N 3AR, UK
+   index: 9
+ - name: Sussex AI Group, Department of Informatics, University of Sussex, Brighton, UK
+   index: 10
+ - name: Sackler Centre for Consciousness Science, University of Sussex, Brighton, UK
+   index: 11
+  
+date: 14 January 2022
+bibliography: paper.bib
+---
+
+# Statement of Need
+
+Active inference is an account of cognition and behavior in complex systems which brings together action, perception, and learning under the theoretical mantle of Bayesian inference [@friston_reinforcement_2009; @friston_active_2012; @friston2015active; @friston2017process]. Active inference has seen growing applications in academic research, especially in fields that seek to model human or animal behavior [@parr2020prefrontal; @holmes2021active; @adams2021everything]. The majority of applications have focused on cognitive neuroscience, with a particular focus on modelling decision-making under uncertainty [@schwartenbeck2015dopaminergic; @smith2020imprecise; @smith2021greater]. Nonetheless, the framework has broad applicability and has recently been applied to diverse disciplines, ranging from computational models of psychopathology [@montague2012computational; @smith2021greater], control theory [@baltieri2019pid; @millidge2020relationship; @baioumy2021towards] and reinforcement learning  [@tschantz2020reinforcement; @tschantz2020scaling; @sajid2021active; @fountas2020deep; @millidge2020deep], through to social cognition [@adams2021everything; @wirkuttis2021leading; @tison2021communication] and even real-world engineering problems [@martinez2021probabilistic; @moreno2021pid; @fox2021active]. While in recent years, some of the code arising from the active inference literature has been written in open source languages like Python and Julia  [@ueltzhoffer2018deep; @van2019simulating; @tschantz2020learning; @ccatal2020learning; @millidge2020deep], to-date, the most popular software for simulating active inference agents is the `DEM` toolbox of `SPM` [@friston2008variational; @smith2022step], a MATLAB library originally developed for the statistical analysis and modelling of neuroimaging data [@penny2011statistical]. `DEM` contains a reliable, reproducible set of functions for studying active inference, but the use of the toolbox can be restrictive for researchers in settings where purchasing a MATLAB license is financially costly. And although active inference researchers have relied heavily on `DEM` for simulating and fitting models of behavior, most of its functionality is restricted to single MATLAB scripts or functions, particularly one called `spm_MDP_VB_X.m`, that lack modularity and often must be customized for applications on a domain-specific basis. Increasing interest in active inference, manifested both in terms of sheer number of cited research papers as well as diversifying applications across disciplines, has thus created a need for generic, widely-available, and user-friendly code for simulating active inference in open-source scientific computing languages like Python. The software we present here, [`pymdp`](https://github.com/infer-actively/pymdp), represents a significant step in this direction: namely, we provide the first open-source package for simulating active inference with discrete state-space generative models. The name `pymdp` derives from the fact that the package is written in the **Py**thon programming language and concerns discrete, Markovian generative models of decision-making, which take the form of Markov Decision Processes or **MDP**s.
+
+`pymdp` is a Python package that is directly inspired by the active inference routines contained in `DEM`. However, `pymdp`  is has a modular, flexible structure that allows researchers to build and simulate active inference agents quickly and with a high degree of customization. We developed `pymdp` in the hopes that it will increase the accessibility and exposure of the active inference framework to researchers, engineers, and developers with diverse disciplinary backgrounds. In the spirit of open-source software, we also hope that it spurs new innovation, development, and collaboration in the growing active inference and wider Bayesian modelling communities. For additional pedagogical and technical resources on `pymdp`, we refer the reader to the package's github repository: https://github.com/infer-actively/pymdp. We also encourage more technically-interested readers to consult a companion preprint article that includes technical material covering the mathematics of active inference in discrete state spaces: https://arxiv.org/abs/2201.03904 [@heins2022pymdp_arxiv].
+
+# Summary
+
+`pymdp` offers a suite of robust, tested, and modular routines for simulating active inference agents equipped with *partially-observable Markov Decision Process* (POMDP) generative models. Mathematically,  a POMDP comprises a joint distribution over observations $o$, hidden states $s$, control states $u$ and hyperparameters $\phi$: $P(o, s, u, \phi)$. This joint distribution further factorizes into a set of categorical and Dirichlet distributions: the likelihoods and priors of the generative model. With `pymdp`, one can build a generative model using a set of prior and likelihood distributions, initialize an agent, and then link it to an external environment to run active inference processes - all in a few lines of code. The `Agent` and `Env` (environment) APIs of `pymdp` are built according to the standardized framework of OpenAIGym commonly used in reinforcement learning, where an agent and environment object recursively exchange observations and actions over time [@brockman2016openai].
+
+# Introduction
+
+Simulations of active inference are commonly performed in discrete time and space [@friston2015active; @da2020active]. This is partially motivated by the mathematical tractability of performing inference with discrete probability distributions, but also by the intuition of modelling choice behavior as a sequence of discrete, mutually-exclusive choices, in e.g. psychophysics or decision-making experiments. The most popular generative models -- used to realize active inference in this context -- are partially-observable Markov Decision Processes or *POMDPs* [@kaelbling1998planning]. POMDPs are state-space models that model the environment in terms of hidden states that stochastically change over time, as a function of both the current state of the environment as well as the behavioral output of an agent (control states or actions). Crucially, the environment is *partially-observable*, i.e. the hidden states are not directly observed by the agent, but can only be inferred through observations that relate to hidden states in a probabilistic manner, such that observations are modelled as being generated stochastically from the current hidden state. This necessitates both "perceptual" inference of hidden states as well as control.
+
+As such, in most POMDP problems, an agent is tasked with inferring the hidden state of its environment and then choosing a sequence of control states or actions to change hidden states in a way that leads to desired outcomes (maximizing reward, or occupancy within some preferred set of states). 
+
+# Usage 
+
+In order to enhance the user-friendliness of `pymdp` without sacrificing flexibility, we have built the library to be highly modular and customizable, such that agents in `pymdp` can be specified at a variety of levels of abstraction with desired parameterisations. The methods of the `Agent` class can thus be called in any particular order, depending on the application, and furthermore they can be specified with various keyword arguments that entail choices of implementation details at lower levels.
+
+By retaining a modular structure throughout the package's dependency hierarchy, `pymdp` also affords the ability to flexibly compose different low level functions. This allows users to customize and integrate their active inference loops with desired inference algorithms and policy selection routines. For instance, one could sub-class the `Agent` class and write a customized `step()` function, that combines whichever components of active inference one is interested in.   
+
+# Related software packages
+
+The `DEM` toolbox within `SPM` in MATLAB is the current gold-standard in active inference modelling. In particular, simulating an active inference process in `DEM` consists of defining the generative model in terms of a fixed set of matrices and vectors, and then calling the `spm_MDP_VB_X.m` function to simulate a sequence of trials. `pymdp`, by contrast, provides a user-friendly and modular development experience, with core functionality split up into different libraries that separately perform the computations of active inference in a standalone fashion. Moreover, `pymdp` provides the user the ability to write an active inference process at different levels of abstraction depending on the user's level of expertise or skill with the package -- ranging from the high level `Agent` functionality, which allows the user to define and simulate an active inference agent in just a few lines of code, all the way to specifying a particular variational inference algorithm (e.g. marginal-message passing [@parr2019neuronal]) for the agent to use during state estimation. In the `DEM` toolbox of `SPM`, this would require setting undocumented flags or else manually editing the routines in `spm_MDP_VB_X.m` to enable or disable bespoke functionality. There has been one recent attempt at creating a comprehensive user-guide for building active inference agents in `DEM` [@smith2022step], though to our knowledge there has not been a package devoted to the open source development of these powerful software tools.
+
+A recent related, but largely non-overlapping project is [ForneyLab](https://github.com/biaslab/ForneyLab.jl), which provides a set of Julia libraries for performing approximate Bayesian inference via message passing on Forney Factor Graphs [@ForneyLab2019]. Notably, this package has also seen several applications in simulating active inference processes, using ForneyLab as the backend for the inference algorithms employed by an active inference agent [@van2019simulating; @vanderbroeck2019active; @ergul2020learning; @10.1162/neco_a_01427]. While ForneyLab focuses on including a rigorous set of message passing routines that can be used to simulate active inference agents, `pymdp` is specifically designed to help users quickly build agents (regardless of their underlying inference routines) and plug them into arbitrary environments to run active inference in a few easy steps.
+
+# Funding Statement
+CH and IDC acknowledge support from the Office of Naval Research grant (ONR, N00014- 64019-1-2556), with IDC further acknowledging support from the European Union’s Horizon 2020 research and innovation programme under the Marie Skłodowska-Curie grant agreement (ID: 860949), the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy-EXC 2117- 422037984, and the Max Planck Society. KF is supported by funding for the Wellcome Centre for Human Neuroimaging (Ref: 205103/Z/16/Z) and the Canada-UK Artificial Intelligence Initiative (Ref: ES/T01279X/1). CH, DD, and BK acknowledge the support of a grant from the John Templeton Foundation (61780). The opinions expressed in this publication are those of the author(s) and do not necessarily reflect the views of the John Templeton Foundation.
+
+# Acknowledgements
+
+The authors would like to thank Dimitrije Markovic, Arun Niranjan, Sivan Altinakar, Mahault Albarracin, Alex Kiefer, Magnus Koudahl, Ryan Smith, Casper Hesp, and Maxwell Ramstead for discussions and feedback that contributed to development of `pymdp`. We would also like to thank Thomas Parr for pointing out a technical error in an earlier version of the arXiv preprint for this work. Finally, we are grateful to the many users of `pymdp` whose feedback and usage of the package have contributed to its continued improvement and development.
+
+# References
\ No newline at end of file
diff --git a/pymdp/agent.py b/pymdp/agent.py
index 1c746f0e..a681af67 100644
--- a/pymdp/agent.py
+++ b/pymdp/agent.py
@@ -15,7 +15,19 @@
 
 class Agent(object):
     """ 
-    Agent class 
+    The Agent class, the highest-level API that wraps together processes for action, perception, and learning under active inference.
+
+    The basic usage is as follows:
+
+    >>> my_agent = Agent(A = A, B = C, <more_params>)
+    >>> observation = env.step(initial_action)
+    >>> qs = my_agent.infer_states(observation)
+    >>> q_pi, G = my_agent.infer_policies()
+    >>> next_action = my_agent.sample_action()
+    >>> next_observation = env.step(next_action)
+
+    This represents one timestep of an active inference process. Wrapping this step in a loop with an ``Env()`` class that returns
+    observations and takes actions as inputs, would entail a dynamic agent-environment interaction.
     """
 
     def __init__(
@@ -67,7 +79,7 @@ def __init__(
         self.lr_pB = lr_pB
         self.lr_pD = lr_pD
 
-        """ Initialise observation model (A matrices) """
+        # Initialise observation model (A matrices)
         if not isinstance(A, np.ndarray):
             raise TypeError(
                 'A matrix must be a numpy array'
@@ -75,16 +87,16 @@ def __init__(
 
         self.A = utils.to_obj_array(A)
 
-        assert utils.is_normalized(self.A), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0"
+        assert utils.is_normalized(self.A), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0)"
 
-        """ Determine number of observation modalities and their respective dimensions """
+        # Determine number of observation modalities and their respective dimensions
         self.num_obs = [self.A[m].shape[0] for m in range(len(self.A))]
         self.num_modalities = len(self.num_obs)
 
-        """ Assigning prior parameters on observation model (pA matrices) """
+        # Assigning prior parameters on observation model (pA matrices)
         self.pA = pA
 
-        """ Initialise transition model (B matrices) """
+        # Initialise transition model (B matrices)
         if not isinstance(B, np.ndarray):
             raise TypeError(
                 'B matrix must be a numpy array'
@@ -92,13 +104,13 @@ def __init__(
 
         self.B = utils.to_obj_array(B)
 
-        assert utils.is_normalized(self.B), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0"
+        assert utils.is_normalized(self.B), "B matrix is not normalized (i.e. B.sum(axis = 0) must all equal 1.0)"
 
         # Determine number of hidden state factors and their dimensionalities
         self.num_states = [self.B[f].shape[0] for f in range(len(self.B))]
         self.num_factors = len(self.num_states)
 
-        """ Assigning prior parameters on transition model (pB matrices) """
+        # Assigning prior parameters on transition model (pB matrices) 
         self.pB = pB
 
         # If no `num_controls` are given, then this is inferred from the shapes of the input B matrices
@@ -130,7 +142,7 @@ def __init__(
 
         assert all([n_c == max_action for (n_c, max_action) in zip(self.num_controls, list(np.max(all_policies, axis =0)+1))]), "Maximum number of actions is not consistent with `num_controls`"
 
-        """ Construct prior preferences (uniform if not specified) """
+        # Construct prior preferences (uniform if not specified)
 
         if C is not None:
             if not isinstance(C, np.ndarray):
@@ -146,7 +158,7 @@ def __init__(
         else:
             self.C = self._construct_C_prior()
 
-        """ Construct prior over hidden states (uniform if not specified) """
+        # Construct prior over hidden states (uniform if not specified)
     
         if D is not None:
             if not isinstance(D, np.ndarray):
@@ -167,11 +179,10 @@ def __init__(
 
         assert utils.is_normalized(self.D), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0"
 
-        """ Assigning prior parameters on initial hidden states (pD vectors) """
+        # Assigning prior parameters on initial hidden states (pD vectors)
         self.pD = pD
 
-        """ Construct prior over policies (uniform if not specified) """
-
+        # Construct prior over policies (uniform if not specified) 
         if E is not None:
             if not isinstance(E, np.ndarray):
                 raise TypeError(
@@ -255,6 +266,20 @@ def _construct_E_prior(self):
         return E
 
     def reset(self, init_qs=None):
+        """
+        Resets the posterior beliefs about hidden states of the agent to a uniform distribution, and resets time to first timestep of the simulation's temporal horizon.
+        Returns the posterior beliefs about hidden states.
+
+        Returns
+        ---------
+        qs: ``numpy.ndarray`` of dtype object
+           Initialized posterior over hidden states. Depending on the inference algorithm chosen and other parameters (such as the parameters stored within ``edge_handling_paramss),
+           the resulting ``qs`` variable will have additional sub-structure to reflect whether beliefs are additionally conditioned on timepoint and policy.
+            For example, in case the ``self.inference_algo == 'MMP' `, the indexing structure of ``qs`` is policy->timepoint-->factor, so that 
+            ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` 
+            at timepoint ``t_idx``. In this case, the returned ``qs`` will only have entries filled out for the first timestep, i.e. for ``q[p_idx][0]``, for all 
+            policy-indices ``p_idx``. Subsequent entries ``q[:][1, 2, ...]`` will be initialized to empty ``numpy.ndarray`` objects.
+        """
 
         self.curr_timestep = 0
 
@@ -282,6 +307,16 @@ def reset(self, init_qs=None):
         return self.qs
 
     def step_time(self):
+        """
+        Advances time by one step. This involves updating the ``self.prev_actions``, and in the case of a moving
+        inference horizon, this also shifts the history of post-dictive beliefs forward in time (using ``self.set_latest_beliefs()``),
+        so that the penultimate belief before the beginning of the horizon is correctly indexed.
+
+        Returns
+        ---------
+        curr_timestep: ``int``
+            The index in absolute simulation time of the current timestep.
+        """
 
         if self.prev_actions is None:
             self.prev_actions = [self.action]
@@ -297,9 +332,21 @@ def step_time(self):
     
     def set_latest_beliefs(self,last_belief=None):
         """
-        This method sets the 'last' belief before the inference horizon. In the case that the inference
-        horizon reaches back to the first timestep of the simulation, then the `latest_belief` is
-        identical to the first belief / the prior (`self.D`). 
+        Both sets and returns the penultimate belief before the first timestep of the backwards inference horizon. 
+        In the case that the inference horizon includes the first timestep of the simulation, then the ``latest_belief`` is
+        simply the first belief of the whole simulation, or the prior (``self.D``). The particular structure of the ``latest_belief``
+        depends on the value of ``self.edge_handling_params['use_BMA']``.
+
+        Returns
+        ---------
+        latest_belief: ``numpy.ndarray`` of dtype object
+            Penultimate posterior beliefs over hidden states at the timestep just before the first timestep of the inference horizon. 
+            Depending on the value of ``self.edge_handling_params['use_BMA']``, the shape of this output array will differ.
+            If ``self.edge_handling_params['use_BMA'] == True``, then ``latest_belief`` will be a Bayesian model average 
+            of beliefs about hidden states, where the average is taken with respect to posterior beliefs about policies.
+            Otherwise, `latest_belief`` will be the full, policy-conditioned belief about hidden states, and will have indexing structure
+            policies->factors, such that ``latest_belief[p_idx][f_idx]`` refers to the penultimate belief about marginal factor ``f_idx``
+            under policy ``p_idx``.
         """
 
         if last_belief is None:
@@ -320,10 +367,18 @@ def set_latest_beliefs(self,last_belief=None):
     
     def get_future_qs(self):
         """
-        This method only gets the last `policy_len` timesteps of each policy-conditioned belief
+        Returns the last ``self.policy_len`` timesteps of each policy-conditioned belief
         over hidden states. This is a step of pre-processing that needs to be done before computing
         the expected free energy of policies. We do this to avoid computing the expected free energy of 
-        policies using ('post-dictive') beliefs about hidden states in the past
+        policies using beliefs about hidden states in the past (so-called "post-dictive" beliefs).
+
+        Returns
+        ---------
+        future_qs_seq: ``numpy.ndarray`` of dtype object
+            Posterior beliefs over hidden states under a policy, in the future. This is a nested ``numpy.ndarray`` object array, with one
+            sub-array ``future_qs_seq[p_idx]`` for each policy. The indexing structure is policy->timepoint-->factor, so that 
+            ``future_qs_seq[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` 
+            at future timepoint ``t_idx``, relative to the current timestep.
         """
         
         future_qs_seq = utils.obj_array(len(self.qs))
@@ -334,21 +389,24 @@ def get_future_qs(self):
 
 
     def infer_states(self, observation):
-        '''
-        Docstring @ TODO 
-        Update variational posterior over hidden states, i.e. Q(\tilde{s})
+        """
+        Update approximate posterior over hidden states by solving variational inference problem, given an observation.
+
         Parameters
         ----------
-        `self` [type]:
-            -Description
-        `observation` [list or tuple of ints]:
-            The observation (generated by the environment). Each observation[m] stores the index of the discrete
-            observation for that modality.
-        Returns:
+        observation: ``list`` or ``tuple`` of ints
+            The observation input. Each entry ``observation[m]`` stores the index of the discrete
+            observation for modality ``m``.
+
+        Returns
         ---------
-        `qs` [numpy object array]:
-            - posterior beliefs over hidden states. 
-        '''
+        qs: ``numpy.ndarray`` of dtype object
+            Posterior beliefs over hidden states. Depending on the inference algorithm chosen, the resulting ``qs`` variable will have additional sub-structure to reflect whether
+            beliefs are additionally conditioned on timepoint and policy.
+            For example, in case the ``self.inference_algo == 'MMP' `` indexing structure is policy->timepoint-->factor, so that 
+            ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` 
+            at timepoint ``t_idx``.
+        """
 
         observation = tuple(observation) 
 
@@ -397,7 +455,11 @@ def infer_states(self, observation):
 
         return qs
 
-    def infer_states_test(self, observation):
+    def _infer_states_test(self, observation):
+        """
+        Test version of ``infer_states()`` that additionally returns intermediate variables of MMP, such as
+        the prediction errors and intermediate beliefs from the optimization. Used for benchmarking against SPM outputs.
+        """
         observation = tuple(observation)
 
         if not hasattr(self, "qs"):
@@ -447,9 +509,22 @@ def infer_states_test(self, observation):
         return qs, xn, vn
 
     def infer_policies(self):
+        """
+        Perform policy inference by optimizing a posterior (categorical) distribution over policies.
+        This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected
+        free energy of policies, ``gamma`` is a policy precision and ``lnE`` is the (log) prior probability of policies.
+        This function returns the posterior over policies as well as the negative expected free energy of each policy.
+
+        Returns
+        ----------
+        q_pi: 1D ``numpy.ndarray``
+            Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy.
+        G: 1D ``numpy.ndarray``
+            Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.
+        """
 
         if self.inference_algo == "VANILLA":
-            q_pi, efe = control.update_posterior_policies(
+            q_pi, G = control.update_posterior_policies(
                 self.qs,
                 self.A,
                 self.B,
@@ -467,7 +542,7 @@ def infer_policies(self):
 
             future_qs_seq = self.get_future_qs()
 
-            q_pi, efe = control.update_posterior_policies_full(
+            q_pi, G = control.update_posterior_policies_full(
                 future_qs_seq,
                 self.A,
                 self.B,
@@ -490,10 +565,22 @@ def infer_policies(self):
                 self.q_pi_hist = self.q_pi_hist[-(self.inference_horizon-1):]
 
         self.q_pi = q_pi
-        self.efe = efe
-        return q_pi, efe
+        self.G = G
+        return q_pi, G
 
     def sample_action(self):
+        """
+        Sample or select a discrete action from the posterior over control states.
+        This function both sets or cachés the action as an internal variable with the agent and returns it.
+        This function also updates time variable (and thus manages consequences of updating the moving reference frame of beliefs)
+        using ``self.step_time()``.
+        
+        Returns
+        ----------
+        action: 1D ``numpy.ndarray``
+            Vector containing the indices of the actions for each control factor
+        """
+
         action = control.sample_action(
             self.q_pi, self.policies, self.num_controls, self.action_selection
         )
@@ -506,10 +593,21 @@ def sample_action(self):
 
     def update_A(self, obs):
         """
-        Update posterior beliefs about Dirichlet parameters that parameterise the observation likelihood 
+        Update approximate posterior beliefs about Dirichlet parameters that parameterise the observation likelihood or ``A`` array.
+
+        Parameters
+        ----------
+        observation: ``list`` or ``tuple`` of ints
+            The observation input. Each entry ``observation[m]`` stores the index of the discrete
+            observation for modality ``m``.
+
+        Returns
+        -----------
+        qA: ``numpy.ndarray`` of dtype object
+            Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations.
         """
 
-        pA_updated = learning.update_obs_likelihood_dirichlet(
+        qA = learning.update_obs_likelihood_dirichlet(
             self.pA, 
             self.A, 
             obs, 
@@ -518,17 +616,27 @@ def update_A(self, obs):
             self.modalities_to_learn
         )
 
-        self.pA = pA_updated
-        self.A = utils.norm_dist_obj_arr(self.pA) 
+        self.pA = qA # set new prior to posterior
+        self.A = utils.norm_dist_obj_arr(qA) # take expected value of posterior Dirichlet parameters to calculate posterior over A array
 
-        return pA_updated
+        return qA
 
     def update_B(self, qs_prev):
         """
         Update posterior beliefs about Dirichlet parameters that parameterise the transition likelihood 
+        
+        Parameters
+        -----------
+        qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object
+            Marginal posterior beliefs over hidden states at previous timepoint.
+    
+        Returns
+        -----------
+        qB: ``numpy.ndarray`` of dtype object
+            Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions.
         """
 
-        pB_updated = learning.update_state_likelihood_dirichlet(
+        qB = learning.update_state_likelihood_dirichlet(
             self.pB,
             self.B,
             self.action,
@@ -538,14 +646,28 @@ def update_B(self, qs_prev):
             self.factors_to_learn
         )
 
-        self.pB = pB_updated
-        self.B = utils.norm_dist_obj_arr(self.pB) 
+        self.pB = qB # set new prior to posterior
+        self.B = utils.norm_dist_obj_arr(qB)  # take expected value of posterior Dirichlet parameters to calculate posterior over B array
 
-        return pB_updated
+        return qB
     
     def update_D(self, qs_t0 = None):
         """
-        Update posterior beliefs about Dirichlet parameters that parameterise the prior over initial hidden states
+        Update Dirichlet parameters of the initial hidden state distribution 
+        (prior beliefs about hidden states at the beginning of the inference window).
+
+        Parameters
+        -----------
+        qs_t0: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, or ``None``
+            Marginal posterior beliefs over hidden states at current timepoint. If ``None``, the 
+            value of ``qs_t0`` is set to ``self.qs_hist[0]`` (i.e. the initial hidden state beliefs at the first timepoint).
+            If ``self.inference_algo == "MMP"``, then ``qs_t0`` is set to be the Bayesian model average of beliefs about hidden states
+            at the first timestep of the backwards inference horizon, where the average is taken with respect to posterior beliefs about policies.
+      
+        Returns
+        -----------
+        qD: ``numpy.ndarray`` of dtype object
+            Posterior Dirichlet parameters over initial hidden state prior (same shape as ``qs_t0``), after having updated it with state beliefs.
         """
         
         if self.inference_algo == "VANILLA":
@@ -574,12 +696,12 @@ def update_D(self, qs_t0 = None):
             
                 qs_t0 = inference.average_states_over_policies(qs_pi_t0,q_pi_t0) # beliefs about hidden states at the first timestep of the inference horizon
         
-        pD_updated = learning.update_state_prior_dirichlet(self.pD, qs_t0, self.lr_pD, factors = self.factors_to_learn)
+        qD = learning.update_state_prior_dirichlet(self.pD, qs_t0, self.lr_pD, factors = self.factors_to_learn)
         
-        self.pD = pD_updated
-        self.D = utils.norm_dist_obj_arr(self.pD)
+        self.pD = qD # set new prior to posterior
+        self.D = utils.norm_dist_obj_arr(qD) # take expected value of posterior Dirichlet parameters to calculate posterior over D array
 
-        return pD_updated
+        return qD
 
     def _get_default_params(self):
         method = self.inference_algo
diff --git a/pymdp/default_models.py b/pymdp/default_models.py
index c1d6322e..bd93bf93 100644
--- a/pymdp/default_models.py
+++ b/pymdp/default_models.py
@@ -67,4 +67,49 @@ def generate_epistemic_MAB_model():
 
     control_fac_idx = [1]
 
-    return A, B, C, control_fac_idx
\ No newline at end of file
+    return A, B, C, control_fac_idx
+
+def generate_grid_world_transitions(action_labels, num_rows = 3, num_cols = 3):
+    """ 
+    Wrapper code for creating the controllable transition matrix 
+    that an agent can use to navigate in a 2-dimensional grid world
+    """
+
+    num_grid_locs = num_rows * num_cols
+
+    transition_matrix = np.zeros( (num_grid_locs, num_grid_locs, len(action_labels)) )
+
+    grid = np.arange(num_grid_locs).reshape(num_rows, num_cols)
+    it = np.nditer(grid, flags=["multi_index"])
+
+    loc_list = []
+    while not it.finished:
+        loc_list.append(it.multi_index)
+        it.iternext()
+
+    for action_id, action_label in enumerate(action_labels):
+
+        for curr_state, grid_location in enumerate(loc_list):
+
+            curr_row, curr_col = grid_location
+            
+            if action_label == "LEFT":
+                next_col = curr_col - 1 if curr_col > 0 else curr_col 
+                next_row = curr_row
+            elif action_label == "DOWN":
+                next_row = curr_row + 1 if curr_row < (num_rows-1) else curr_row 
+                next_col = curr_col
+            elif action_label == "RIGHT":
+                next_col = curr_col + 1 if curr_col < (num_cols-1) else curr_col 
+                next_row = curr_row
+            elif action_label == "UP":
+                next_row = curr_row - 1 if curr_row > 0 else curr_row 
+                next_col = curr_col
+            elif action_label == "STAY":
+                next_row, next_col = curr_row, curr_col
+
+            new_location = (next_row, next_col)
+            next_state = loc_list.index(new_location)
+            transition_matrix[next_state, curr_state, action_id] = 1.0
+    
+    return transition_matrix
diff --git a/pymdp/envs/env.py b/pymdp/envs/env.py
index 4d39cb9f..635e4e98 100644
--- a/pymdp/envs/env.py
+++ b/pymdp/envs/env.py
@@ -9,13 +9,50 @@
 
 
 class Env(object):
+    """ 
+    The Env base class, loosely-inspired by the analogous ``env`` class of the OpenAIGym framework. 
+
+    A typical workflow is as follows:
+
+    >>> my_env = MyCustomEnv(<some_params>)
+    >>> initial_observation = my_env.reset(initial_state)
+    >>> my_agent.infer_states(initial_observation)
+    >>> my_agent.infer_policies()
+    >>> next_action = my_agent.sample_action()
+    >>> next_observation = my_env.step(next_action)
+
+    This would be the first step of an active inference process, where a sub-class of ``Env``, ``MyCustomEnv`` is initialized, 
+    an initial observation is produced, and these observations are fed into an instance of ``Agent`` in order to produce an action,
+    that can then be fed back into the the ``Env`` instance.
+
+    """
+
     def reset(self, state=None):
+        """
+        Resets the initial state of the environment. Depending on case, it may be common to return an initial observation as well.
+        """
         raise NotImplementedError
 
     def step(self, action):
+        """
+        Steps the environment forward using an action.
+
+        Parameters
+        ----------
+        action
+            The action, the type/format of which depends on the implementation.
+
+        Returns
+        ---------
+        observation
+            Sensory observations for an agent, the type/format of which depends on the implementation of ``step`` and the observation space of the agent.
+        """
         raise NotImplementedError
 
     def render(self):
+        """
+        Rendering function, that typically creates a visual representation of the state of the environment at the current timestep.
+        """
         pass
 
     def sample_action(self):
diff --git a/pymdp/envs/grid_worlds.py b/pymdp/envs/grid_worlds.py
index 722fd551..f27be9d4 100644
--- a/pymdp/envs/grid_worlds.py
+++ b/pymdp/envs/grid_worlds.py
@@ -16,7 +16,7 @@
 
 
 class GridWorldEnv(Env):
-    """ Basic grid-world implementation """
+    """ 2-dimensional grid-world implementation with 5 actions (the 4 cardinal directions and staying put)."""
 
     UP = 0
     RIGHT = 1
@@ -27,6 +27,18 @@ class GridWorldEnv(Env):
     CONTROL_NAMES = ["UP", "RIGHT", "DOWN", "LEFT", "STAY"]
 
     def __init__(self, shape=[2, 2], init_state=None):
+        """
+        Initialization function for 2-D grid world
+
+        Parameters
+        ----------
+        shape: ``list`` of ``int``, where ``len(shape) == 2``
+            The dimensions of the grid world, stored as a list of integers, storing the discrete dimensions of the Y (vertical) and X (horizontal) spatial dimensions, respectively.
+        init_state: ``int`` or ``None``
+            Initial state of the environment, i.e. the location of the agent in grid world. If not ``None``, must be a discrete index  in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the initial location of the agent in grid world.
+            If ``None``, then an initial location will be randomly sampled from the grid.
+        """
+        
         self.shape = shape
         self.n_states = np.prod(shape)
         self.n_observations = self.n_states
@@ -38,21 +50,70 @@ def __init__(self, shape=[2, 2], init_state=None):
         self.last_action = None
 
     def reset(self, init_state=None):
+        """
+        Reset the state of the 2-D grid world. In other words, resets the location of the agent, and wipes the current action.
+
+        Parameters
+        ----------
+        init_state: ``int`` or ``None``
+            Initial state of the environment, i.e. the location of the agent in grid world. If not ``None``, must be a discrete index  in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the initial location of the agent in grid world.
+            If ``None``, then an initial location will be randomly sampled from the grid.
+
+        Returns
+        ----------
+        self.state: ``int``
+            The current state of the environment, i.e. the location of the agent in grid world. Will be a discrete index  in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the location of the agent in grid world.
+        """
         self.set_init_state(init_state)
         self.last_action = None
         return self.state
 
     def set_state(self, state):
+        """
+        Sets the state of the 2-D grid world.
+
+        Parameters
+        ----------
+        state: ``int`` or ``None``
+            State of the environment, i.e. the location of the agent in grid world. If not ``None``, must be a discrete index  in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the location of the agent in grid world.
+            If ``None``, then a location will be randomly sampled from the grid.
+
+        Returns
+        ----------
+        self.state: ``int``
+            The current state of the environment, i.e. the location of the agent in grid world. Will be a discrete index  in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the location of the agent in grid world.
+        """
         self.state = state
         return state
 
     def step(self, action):
+        """
+        Updates the state of the environment, i.e. the location of the agent, using an action index that corresponds to one of the 5 possible moves.
+
+        Parameters
+        ----------
+        action: ``int`` 
+            Action index that refers to which of the 5 actions the agent will take. Actions are, in order: "UP", "RIGHT", "DOWN", "LEFT", "STAY".
+
+        Returns
+        ----------
+        state: ``int``
+            The new, updated state of the environment, i.e. the location of the agent in grid world after the action has been made. Will be discrete index in the range ``(0, (shape[0] * shape[1])-1)``. It is thus a "linear index" of the location of the agent in grid world.
+        """
         state = self.P[self.state][action]
         self.state = state
         self.last_action = action
         return state
 
     def render(self, title=None):
+        """
+        Creates a heatmap showing the current position of the agent in the grid world.
+
+        Parameters
+        ----------
+        title: ``str`` or ``None``
+            Optional title for the heatmap.
+        """
         values = np.zeros(self.shape)
         values[self.position] = 1.0
         _, ax = plt.subplots(figsize=(3, 3))
@@ -132,7 +193,7 @@ def position(self):
 
 
 class DGridWorldEnv(object):
-    """ Only one dimension (three actions) """
+    """ 1-dimensional grid-world implementation with 3 possible movement actions ("LEFT", "STAY", "RIGHT")"""
 
     LEFT = 0
     STAY = 1
diff --git a/pymdp/envs/mdp_search_env.py b/pymdp/envs/mdp_search_env.py
deleted file mode 100644
index 7215336f..00000000
--- a/pymdp/envs/mdp_search_env.py
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-""" Scene Construction / Visual Search Environment
-
-__author__: Conor Heins, Alexander Tschantz, Brennan Klein
-
-"""
-
-from pymdp.envs import Env
-import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib.offsetbox import OffsetImage, AnnotationBbox
-
-
-scenes = {}
-
-scenes['flee'] = np.array([["bird", "cat"], 
-                    ["null", "null"]])
-scenes['feed'] = np.array([["bird", "seed"], 
-                    ["null", "null"]])
-scenes['wait'] = np.array([["bird", "null"], 
-                    ["null", "seed"]])
-
-graphics_folder = "MDP_search_graphics"
-
-
-fig, ax = plt.subplots(figsize=(16, 10))
-
-img = plt.imread(os.path.join(graphics_folder,'bird.png'))
-im = OffsetImage(img, zoom=0.35)
-
-ab = AnnotationBbox(im, (0.75, 0.75), xycoords='data', frameon=False)
-an = ax.add_artist(ab)
-
-class SceneConstruction(Env):
-
-    def __init__(self, scenes=None):
-        if scenes is None:
-            self.scenes = self._construct_default_scenes()
-        else:
-            self.scenes = scenes
-
-    def display_scene_array(self):
-
-        img_arr = scenes[self.scene]
-
-        for row_i, img_names in enumerate(img_arr):
-            for col_i, img_name in enumerate(img_names):
-                print(f'Row: {row_i}, Column: {col_i}, image: {img_name}')
-
-    def _construct_default_scenes(self):
-        scenes = {}
-
-        scenes['flee'] = [["bird", "cat"], 
-                          ["null", "null"]]
-        scenes['feed'] = [["bird", "seed"], 
-                          ["null", "null"]]
-        scenes['wait'] = [["bird", "null"], 
-                          ["null", "seed"]]
-
-        return scenes
diff --git a/pymdp/envs/tmaze.py b/pymdp/envs/tmaze.py
index 15bd4660..c861ce57 100644
--- a/pymdp/envs/tmaze.py
+++ b/pymdp/envs/tmaze.py
@@ -23,6 +23,7 @@
 
 
 class TMazeEnv(Env):
+    """ Implementation of the 3-arm T-Maze environment """
     def __init__(self, reward_probs=None):
 
         if reward_probs is None:
@@ -189,6 +190,9 @@ def reward_condition(self):
 
 
 class TMazeEnvNullOutcome(Env):
+    """ Implementation of the 3-arm T-Maze environment where there is an additional null outcome within the cue modality, so that the agent
+    doesn't get a random cue observation, but a null one, when it visits non-cue locations"""
+
     def __init__(self, reward_probs=None):
 
         if reward_probs is None:
diff --git a/pymdp/envs/visual_foraging.py b/pymdp/envs/visual_foraging.py
index ac2a7afe..b3cf8996 100644
--- a/pymdp/envs/visual_foraging.py
+++ b/pymdp/envs/visual_foraging.py
@@ -15,6 +15,8 @@
 
 
 class VisualForagingEnv(Env):
+    """ Implementation of the visual foraging environment used for scene construction simulations """
+
     def __init__(self, scenes=None, n_features=2):
         if scenes is None:
             self.scenes = self._construct_default_scenes()
diff --git a/pymdp/learning.py b/pymdp/learning.py
index bd694a6d..ec334f68 100644
--- a/pymdp/learning.py
+++ b/pymdp/learning.py
@@ -100,7 +100,7 @@ def update_state_likelihood_dirichlet(
 
     for factor in factors:
         dfdb = maths.spm_cross(qs[factor], qs_prev[factor])
-        dfdb *= (B[factor][:, :, actions[factor]] > 0).astype("float")
+        dfdb *= (B[factor][:, :, int(actions[factor])] > 0).astype("float")
         qB[factor][:,:,int(actions[factor])] += (lr*dfdb)
 
     return qB
diff --git a/requirements.txt b/requirements.txt
index 7740ed10..d09a154b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -23,3 +23,4 @@ typing-extensions>=3.7.4.3
 xlsxwriter>=1.4.3
 sphinx-rtd-theme>=0.4
 myst-nb>=0.13.1
+autograd>=1.3
diff --git a/setup.py b/setup.py
index da98f7d1..a6ad874b 100644
--- a/setup.py
+++ b/setup.py
@@ -34,7 +34,8 @@
     'typing-extensions>=3.7.4.3',
     'xlsxwriter>=1.4.3',
     'sphinx-rtd-theme>=0.4',
-    'myst-nb>=0.13.1'
+    'myst-nb>=0.13.1',
+    'autograd>=1.3'
     ],
     packages=[
         "pymdp",


Test patch:
diff --git a/test/test_SPM_validation.py b/test/test_SPM_validation.py
index b8784967..537cab2c 100644
--- a/test/test_SPM_validation.py
+++ b/test/test_SPM_validation.py
@@ -45,8 +45,8 @@ def test_active_inference_SPM_1a(self):
 
         for t in range(T):
             o_t = (np.where(obs[t])[0][0],)
-            qx, xn_t, vn_t = agent.infer_states_test(o_t)
-            q_pi, efe= agent.infer_policies()
+            qx, xn_t, vn_t = agent._infer_states_test(o_t)
+            q_pi, G= agent.infer_policies()
             action = agent.sample_action()
 
             actions_python[t] = action
diff --git a/test/test_agent.py b/test/test_agent.py
index 6ff21e01..1a0f3956 100644
--- a/test/test_agent.py
+++ b/test/test_agent.py
@@ -16,6 +16,7 @@
 from pymdp.agent import Agent
 from pymdp import utils, maths
 from pymdp import inference, control, learning
+from pymdp.default_models import generate_grid_world_transitions
 
 class TestAgent(unittest.TestCase):
     
@@ -199,11 +200,61 @@ def test_mmp_active_inference(self):
         
         self.assertEqual(len(agent.prev_obs), T)
         self.assertEqual(len(agent.prev_actions), T)
+
+    def test_agent_with_B_learning_vanilla(self):
+        """ Unit test for updating prior Dirichlet parameters over transition model (pB) with the ``Agent`` class,
+        in the case that you're using "vanilla" inference mode.
+        """
+
+        # 3 x 3, 2-dimensional grid world
+        num_obs = [9]
+        num_states = [9]
+        num_controls = [4]
+
+        A = utils.obj_array_zeros([ [num_obs[0], num_states[0]] ])
+        A[0] = np.eye(num_obs[0])
+
+        action_labels = ["LEFT", "DOWN", "RIGHT", "UP"]
+
+        # flat transition prior
+        pB = utils.obj_array_ones([[num_states[0], num_states[0], num_controls[0]]])
+        B = utils.norm_dist_obj_arr(pB)
+        
+        # instantiate the agent
+        learning_rate_pB = 2.0
+        agent = Agent(A = A, B = B, pB = pB, inference_algo="VANILLA", save_belief_hist = True, action_selection="stochastic", lr_pB= learning_rate_pB)
+
+        # get some true transition dynamics
+        true_transition_matrix = generate_grid_world_transitions(action_labels, num_rows = 3, num_cols = 3)
+
+        # time horizon
+        T = 10
+        next_state = 0
+
+        for t in range(T):
+            
+            prev_state = next_state
+            o = [prev_state] 
+            qx = agent.infer_states(o)
+            agent.infer_policies()
+            agent.sample_action()
+
+            # sample the next state given the true transition dynamics and the sampled action
+            next_state = utils.sample(true_transition_matrix[:,prev_state,int(agent.action[0])])
+
+            if t > 0:
+                
+                # compute the predicted update to the action-conditioned slice of qB
+                predicted_update = agent.pB[0][:,:,int(agent.action[0])] + learning_rate_pB * maths.spm_cross(agent.qs_hist[-1][0], agent.qs_hist[-2][0])
+                qB = agent.update_B(qs_prev = agent.qs_hist[-2]) # update qB using the agent function
+
+                # check if the predicted update and the actual update are the same
+                self.assertTrue(np.allclose(predicted_update, qB[0][:,:,int(agent.action[0])]))
     
     def test_agent_with_D_learning_vanilla(self):
         """
-        Test updating prior Dirichlet parameters over initial hidden states (pD) with the agent class,
-        in the case that you're using "vanilla" inference. 
+        Test updating prior Dirichlet parameters over initial hidden states (pD) with the ``Agent`` class,
+        in the case that you're using "vanilla" inference mode.
         """
 
         num_obs = [2, 4]
diff --git a/test/test_demos.py b/test/test_demos.py
index 5c17ba37..0b2a5aa1 100644
--- a/test/test_demos.py
+++ b/test/test_demos.py
@@ -109,7 +109,7 @@ def plot_likelihood(A, title=""):
         for t in range(T):
             qx = agent.infer_states(obs)
 
-            q_pi, efe = agent.infer_policies()
+            q_pi, G = agent.infer_policies()
 
             action = agent.sample_action()