tutorials/robots_and_marbles/robot-marbles-part-1/robot-marbles-part-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "cadCAD# cadCAD Tutorials: The Robot and the Marbles, part 1\n",
    "## What is cadCAD?\n",
    "cadCAD is a Python library that assists in the processes of designing, testing and validating complex systems through simulation. At its core, cadCAD is a differential games engine that supports parameter sweeping and Monte Carlo analyses and can be easily integrated with other scientific computing Python modules and data science workflows.\n",
    "\n",
    "At [BlockScience](http://bit.ly/github_articles_M_1), we've been using cadCAD as a tool for [Token Engineering](https://medium.com/block-science/on-the-practice-of-token-engineering-part-i-c2cc2434e727) - the design of self-organizing systems enabled through cryptographic peer-to-peer networks. But cadCAD can simulate any system that can be described as state variables that evolve over time according to a set of equations. This series of articles will go over the basic concepts of cadCAD and the 'language' in which a system must be described in order for it to be interpretable by the library. This article will cover the following concepts:\n",
    "* State Variables\n",
    "* Timestep\n",
    "* State Update Functions\n",
    "* Partial State Update Blocks\n",
    "* Simulation Configuration Parameters\n",
    "\n",
    "To help illustrate, we'll refer to a simple example system\n",
    "\n",
    "__The robot and the marbles__  \n",
    "* Picture a box (`box_A`) with ten marbles in it; an empty box (`box_B`) next to the first one; and a robot arm capable of taking a marble from any one of the boxes and dropping it into the other one. \n",
    "* The robot is programmed to take one marble at a time from the box containing the largest number of marbles and drop it in the other box. It repeats that process until the boxes contain an equal number of marbles.  \n",
    "\n",
    "## State Variables\n",
    ">A state variable is one of the set of variables that are used to describe the mathematical \"state\" of a dynamical system. Intuitively, the state of a system describes enough about the system to determine its future behaviour in the absence of any external forces affecting the system. [_(source: Wikipedia)_](https://en.wikipedia.org/wiki/State_variable)\n",
    "\n",
    "cadCAD can handle state variables of any Python data type, including custom classes. It is up to the user of cadCAD to determine the state variables needed to sufficiently accurately describe the system they are interested in.\n",
    "\n",
    "We could describe the simple system in our example with only two state variables: the number of marbles in `box_A` and in `box_B`. These are not the only two variables that describe the system, of course. Things like the position of the robot arm in space or its temperature also qualify as \"variables that describe the state of the system\". But if we assume those variables have no impact on the behavior of the system (as implied by the description) we can safely disregard them.\n",
    "\n",
    "cadCAD expects state variables to be passed to it as a Python `dict` where the `dict_keys` are the __names of the \n",
    "variables__ and the `dict_values` are their __initial values__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# List of all the state variables in the system and their initial values\n",
    "genesis_states = {\n",
    "    'box_A': 10, # as per the description of the example, box_A starts out with 10 marbles in it\n",
    "    'box_B': 0 # as per the description of the example, box_B starts out empty\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Timestep\n",
    "Computer simulations run in discrete time:\n",
    ">Discrete time views values of variables as occurring at distinct, separate \"points in time\", or equivalently as being unchanged throughout each non-zero region of time (\"time period\")—that is, time is viewed as a discrete variable. Thus a non-time variable jumps from one value to another as time moves from one time period to the next. This view of time corresponds to a digital clock that gives a fixed reading of 10:37 for a while, and then jumps to a new fixed reading of 10:38, etc. [_(source: Wikipedia)_](https://en.wikipedia.org/wiki/Discrete_time_and_continuous_time)\n",
    "\n",
    "The concept of Timestep in cadCAD refers to a discrete unit of time. cadCAD increments a \"time counter\", and at each step it updates the state variables according to the equations that describe the system. If time itself is a state variable that the user is interested in keeping track of, they may specify a state update function that models the passing of time. We'll cover that scenario in an upcoming article. For the moment, it suffices to define that the robot acts once per timestep.\n",
    "# State Update Functions\n",
    "State Update Functions are Python functions that represent the equations according to which the state variables change over time. Each state update function must return a tuple containing the name of the state variable being updated and its new value. The general structure of a state update function is:\n",
    "```python\n",
    "def function(params, step, sL, s, _input):\n",
    "    ...\n",
    "    y = ...\n",
    "    x = ...\n",
    "    return (y, x)\n",
    "```\n",
    "State update functions can read the current state of the system from argument `s`. We'll ignore the other arguments for now. `s` is a Python `dict` where the `dict_keys` are the __names of the variables__ and the `dict_values` are their __current values__. With this, we can define the state update functions for variables `box_A` and `box_B`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def update_A(params, step, sH, s, _input):\n",
    "    y = 'box_A'\n",
    "    add_to_A = 0\n",
    "    if (s['box_A'] > s['box_B']):\n",
    "        add_to_A = -1\n",
    "    elif (s['box_A'] < s['box_B']):\n",
    "        add_to_A = 1\n",
    "    x = s['box_A'] + add_to_A\n",
    "    return (y, x)\n",
    "\n",
    "def update_B(params, step, sH, s, _input):\n",
    "    y = 'box_B'\n",
    "    add_to_B = 0\n",
    "    if (s['box_B'] > s['box_A']):\n",
    "        add_to_B = -1\n",
    "    elif (s['box_B'] < s['box_A']):\n",
    "        add_to_B = 1\n",
    "    x = s['box_B'] + add_to_B\n",
    "    return (y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Partial State Update Blocks\n",
    "Within a timestep, state update functions can be run in any combination of serial or parallel executions. Take the following diagram for example:\n",
    "![partial state update blocks](partial-state-update-blocks.png \"Partial State Update Blocks\") <center><b>Figure 1: Visual representation of Partial State Update Blocks</b></center>\n",
    "\n",
    "State update functions (SUF) 1 and 2 are run in parallel. This means that if SUF2 reads the value of variable A, it will not get the value updated by SUF1. On the other hand, SUF3 and SUF4 are executed after SUF1 and SUF2 have completed, thus having access to the updated values of variables A and C.\n",
    "\n",
    "We refer to the groups of state update functions that are executed in parallel within a timestep as Partial State Update Blocks. cadCAD expects partial state update blocks to be specified as a list of `dict`s with the following structure:\n",
    "```python\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': {\n",
    "            'policy1': policy_function_1,\n",
    "            'policy2': policy_function_2,\n",
    "            ...\n",
    "        },\n",
    "        'variables': {\n",
    "            'variable1': state_update_function_1,\n",
    "            'variable2': state_update_function_2,\n",
    "            ...\n",
    "        }\n",
    "    },\n",
    "    ...\n",
    "]\n",
    "```\n",
    "\n",
    "We'll ignore the `policies` key for now. The `dict` that represents the structure of Figure 1 would be:\n",
    "```python\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': {\n",
    "        },\n",
    "        'variables': {\n",
    "            'variableA': state_update_function_1,\n",
    "            'variableC': state_update_function_2,\n",
    "        }\n",
    "    },\n",
    "    { \n",
    "        'policies': {\n",
    "        },\n",
    "        'variables': {\n",
    "            'variableA': state_update_function_3,\n",
    "            'variableB': state_update_function_4,\n",
    "        }\n",
    "    }\n",
    "]\n",
    "```\n",
    "\n",
    "In the case of our robot and marbles example system, we can model the system so that all state update functions are executed in parallel. In other words, we consider the marbles move from one box to the other simultaneously (ie, `box_A + box_B` is constant)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# In the Partial State Update Blocks, the user specifies if state update functions will be run in series or in parallel\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': { # We'll ignore policies for now\n",
    "        },\n",
    "        'variables': { # The following state variables will be updated simultaneously\n",
    "            'box_A': update_A,\n",
    "            'box_B': update_B\n",
    "        }\n",
    "    }\n",
    "]\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Simulation Configuration Parameters\n",
    "Lastly, we define the number of timesteps and the number of Monte Carlo runs of the simulation. These parameters must be passed in a dictionary, in `dict_keys` `T` and `N`, respectively. In our example, we'll run the simulation for 10 timesteps. And because we are dealing with a deterministic system, it makes no sense to have multiple Monte Carlo runs, so we set `N=1`. We'll ignore the `M` key for now and set it to an empty `dict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# Settings of general simulation parameters, unrelated to the system itself\n",
    "# `T` is a range with the number of discrete units of time the simulation will run for;\n",
    "# `N` is the number of times the simulation will be run (Monte Carlo runs)\n",
    "# In this example, we'll run the simulation once (N=1) and its duration will be of 10 timesteps\n",
    "# We'll cover the `M` key in a future article. For now, let's omit it\n",
    "sim_config_dict = {\n",
    "    'T': range(10),\n",
    "    'N': 1,\n",
    "    #'M': {}\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Putting it all together\n",
    "We have defined the state variables of our system and their initial conditions, as well as the state update functions, which have been grouped in a single state update block. We have also specified the parameters of the simulation (number of timesteps and runs). We are now ready to put all those pieces together in a `Configuration` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "#imported some addition utilities to help with configuration set-up\n",
    "from cadCAD.configuration.utils import config_sim\n",
    "from cadCAD.configuration import Experiment\n",
    "from cadCAD import configs\n",
    "\n",
    "exp = Experiment()\n",
    "c = config_sim(sim_config_dict)\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "del configs[:]\n",
    "exp.append_configs(initial_state=genesis_states, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_configs=c #preprocessed dictionaries containing simulation parameters\n",
    "                      )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Running the engine\n",
    "We are now ready to run the engine with the configuration defined above. Instantiate an ExecutionMode, an ExecutionContext and an Executor objects, passing the Configuration object to the latter. Then run the `execute()` method of the Executor object, which returns the results of the experiment in the first element of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "from cadCAD.engine import ExecutionMode, ExecutionContext\n",
    "exec_mode = ExecutionMode()\n",
    "local_mode_ctx = ExecutionContext(exec_mode.local_mode)\n",
    "\n",
    "from cadCAD.engine import Executor\n",
    "\n",
    "simulation = Executor(exec_context=local_mode_ctx, configs=exp.configs) # Pass the configuration object inside an array\n",
    "raw_system_events, tensor_field, sessions = simulation.execute() # The `execute()` method returns a tuple; its first elements contains the raw results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Analyzing the results\n",
    "We can now convert the raw results into a DataFrame for analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>box_A</th>\n",
       "      <th>box_B</th>\n",
       "      <th>simulation</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>subset</th>\n",
       "      <th>run</th>\n",
       "      <th>timestep</th>\n",
       "      <th>substep</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"11\" valign=\"top\">0</th>\n",
       "      <th rowspan=\"11\" valign=\"top\">1</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <th>1</th>\n",
       "      <td>9</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             box_A  box_B  simulation\n",
       "subset run timestep substep                          \n",
       "0      1   0        0           10      0           0\n",
       "           1        1            9      1           0\n",
       "           2        1            8      2           0\n",
       "           3        1            7      3           0\n",
       "           4        1            6      4           0\n",
       "           5        1            5      5           0\n",
       "           6        1            5      5           0\n",
       "           7        1            5      5           0\n",
       "           8        1            5      5           0\n",
       "           9        1            5      5           0\n",
       "           10       1            5      5           0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "simulation_result = pd.DataFrame(raw_system_events)\n",
    "simulation_result.set_index(['subset', 'run', 'timestep', 'substep'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulation_result.plot('timestep', ['box_A', 'box_B'], grid=True, \n",
    "        colormap = 'RdYlGn',\n",
    "        xticks=list(simulation_result['timestep'].drop_duplicates()), \n",
    "        yticks=list(range(1+(simulation_result['box_A']+simulation_result['box_B']).max())));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Because the number of marbles in the system is even, it converges to an equilibrium with 5 marbles in each box. Simulating a scenario with an odd number of marbles is as easy as modifying the `initial_condition` of the system, recreating the configuration object and rerunning the simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "genesis_states = {\n",
    "    'box_A': 11,\n",
    "    'box_B': 0\n",
    "}\n",
    "\n",
    "del exp.configs[:]\n",
    "exp.append_configs(initial_state=genesis_states, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_configs=c #preprocessed dictionaries containing simulation parameters\n",
    "                      )\n",
    "\n",
    "raw_result, tensor, sessions = simulation.execute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>box_A</th>\n",
       "      <th>box_B</th>\n",
       "      <th>subset</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>simulation</th>\n",
       "      <th>run</th>\n",
       "      <th>timestep</th>\n",
       "      <th>substep</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"11\" valign=\"top\">1</th>\n",
       "      <th rowspan=\"11\" valign=\"top\">1</th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "      <td>11</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <th>1</th>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <th>1</th>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <th>1</th>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                 box_A  box_B  subset\n",
       "simulation run timestep substep                      \n",
       "1          1   0        0           11      0       0\n",
       "               1        1           10      1       0\n",
       "               2        1            9      2       0\n",
       "               3        1            8      3       0\n",
       "               4        1            7      4       0\n",
       "               5        1            6      5       0\n",
       "               6        1            5      6       0\n",
       "               7        1            6      5       0\n",
       "               8        1            5      6       0\n",
       "               9        1            6      5       0\n",
       "               10       1            5      6       0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulation_result = pd.DataFrame(raw_result)\n",
    "simulation_result.set_index(['simulation', 'run', 'timestep', 'substep'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulation_result.plot('timestep', ['box_A', 'box_B'], grid=True, \n",
    "        colormap = 'RdYlGn',\n",
    "        xticks=list(simulation_result['timestep'].drop_duplicates()), \n",
    "        yticks=list(range(1+(simulation_result['box_A']+simulation_result['box_B']).max())));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "As was to be expected, the system oscilates between 5 and 6 marbles in each box.\n",
    "\n",
    "In the next article of this series we'll cover another base concept in cadCAD: **policies**.\n",
    "\n",
    "---\n",
    "\n",
    "_About BlockScience_  \n",
    "[BlockScience](http://bit.ly/github_articles_M_1) is a research and engineering firm specialized in complex adaptive systems and applying practical methodologies from engineering design, development and testing to projects in emerging technologies such as blockchain. Follow us on [Medium](http://bit.ly/bsci-medium) or [Twitter](http://bit.ly/bsci-twitter) to stay in touch."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}