CADtrojanDAO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cadCAD x TrojanDAO\n",
    "\n",
    "In parts [1](../robot-marbles-part-1/robot-marbles-part-1.ipynb) and [2](../robot-marbles-part-2/robot-marbles-part-2.ipynb) we introduced the 'language' in which a system must be described in order for it to be interpretable by cadCAD and some of the basic concepts of the library:\n",
    "* State Variables\n",
    "* Timestep\n",
    "* State Update Functions\n",
    "* Partial State Update Blocks\n",
    "* Simulation Configuration Parameters\n",
    "* Policies\n",
    "\n",
    "So far, all the examples referred to deterministic systems: no matter how many times you ran one of those simulations, the results would be the same. However, systems are more commonly non-deterministic, and modelling them as deterministic might be an oversimplification sometimes. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import random as rd\n",
    "# a = np.array([]) \n",
    "# x_user_balances = np.array([120,120,120,120,120,120,120])\n",
    "# actusr = x_user_balances[rd.randint(1,7)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# List of all the state variables in the system and their initial values\n",
    "# Assumption: we model interactions on the BC and DAO pools, treating user interactions stochastically\n",
    "\n",
    "initial_conditions = {\n",
    "  'BC_reserve': 0,\n",
    "  'token_holders': np.array([1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000]),\n",
    "  'n': 8, # max number of token holders including guildbank and DAO pool\n",
    "  'DAO_pool_index': 0,\n",
    "  'guildbank_index': 1,\n",
    "  'amount_to_mint': 100, # in eth\n",
    "  'amount_to_burn': 0.2, # proportion of holdings\n",
    "  'price': 1, # in eth/tok\n",
    "  'total_tokens': 0,\n",
    "  'action': 'mint',\n",
    "  'update_index': 0,\n",
    "  'DAO_tax_rate': 0.02,\n",
    "  'redist_tax_rate': 0.01,\n",
    "  'burn_tax_rate': 0.03,\n",
    "  'redist': 0,\n",
    "}\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \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 leave it empty\n",
    "simulation_parameters = {\n",
    "    'T': range(100),\n",
    "    'N': 1,\n",
    "    'M': {}\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# Investor,liquidator logic in a Policy Function\n",
    "def choose_holder(params, step, sL, s):\n",
    "    index = np.random.randint(2, s['n'])\n",
    "    print(\"Index to act on is %s\" % (index))\n",
    "    return ({'update_index': index})\n",
    "\n",
    "# def investor(params, step, sL, s):\n",
    "#     return()\n",
    "\n",
    "# def pers_burn(params, step, sL, s):\n",
    "#     return()\n",
    "\n",
    "# def DAOburn(params, step, sL, s):\n",
    "#     return()\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# State update functions\n",
    "def choose_action(params, step, sL, s):\n",
    "    p = np.random.randint(0, 100)\n",
    "    return ({'action': 'mint'})\n",
    "\n",
    "def update_BC_reserve_mint(params, step, sL, s, _input):\n",
    "    y = 'BC_reserve'\n",
    "    amount_to_mint = 0\n",
    "    if (_input['update_index'] > 1):\n",
    "        amount_to_mint = s['amount_to_mint']\n",
    "    x = s['BC_reserve'] + amount_to_mint # newly minted amount\n",
    "    print(\"New BC reserve is %s\" % (x))\n",
    "    return (y, x)\n",
    "\n",
    "def update_BC_reserve_burn(params, step, sL, s, _input):\n",
    "    y = 'BC_reserve'\n",
    "    update_index = _input['update_index']\n",
    "    amount_to_burn = s['amount_to_burn'] * s['token_holders'][update_index]\n",
    "    x = s['BC_reserve'] - amount_to_burn * (1 - s['burn_tax_rate'])\n",
    "    return (y, x)\n",
    "\n",
    "def update_total_tokens_mint(params, step, sL, s, _input):\n",
    "    y = 'total_tokens'\n",
    "    amount_to_mint = s['amount_to_mint']\n",
    "    x = s['total_tokens'] + amount_to_mint\n",
    "    return (y, x)\n",
    "\n",
    "def update_total_tokens_burn(params, step, sL, s, _input):\n",
    "    y = 'total_tokens'\n",
    "    token_holders = s['token_holders']\n",
    "    update_index = _input['update_index']\n",
    "    amount_to_burn = s['amount_to_burn'] * token_holders[update_index]\n",
    "    x = s['total_tokens'] - amount_to_burn\n",
    "    return (y, x)\n",
    "\n",
    "def update_token_holders_mint(params, step, sL, s, _input):\n",
    "    y = 'token_holders'\n",
    "    x = s['token_holders']\n",
    "    update_index = _input['update_index']\n",
    "    amount_to_mint = s['amount_to_mint'] * (1 - s['DAO_tax_rate'] - s['redist_tax_rate'])\n",
    "    x[update_index] = x[update_index] + amount_to_mint\n",
    "    DAO_tax_amount = s['amount_to_mint'] * s['DAO_tax_rate']\n",
    "    x[0] = x[0] + DAO_tax_amount\n",
    "    print(x)\n",
    "    return (y, x)\n",
    "\n",
    "def update_token_holders_burn(params, step, sL, s, _input):\n",
    "    y = 'token_holders'\n",
    "    x = s['token_holders']\n",
    "    update_index = _input['update_index']\n",
    "    amount_to_burn = s['amount_to_burn'] * x[update_index]\n",
    "    DAO_tax_amount = amount_to_burn * s['burn_tax_rate']\n",
    "    x[update_index] = x[update_index] - amount_to_burn\n",
    "    x[0] = x[0] + DAO_tax_amount\n",
    "    print(x)\n",
    "    return (y, x)\n",
    "\n",
    "def update_redistribution_amount_mint(params, step, sL, s, _input):\n",
    "    y = 'redist'\n",
    "    update_index = _input['update_index']\n",
    "    redist_tax_amount = 0\n",
    "    if (update_index > 1):\n",
    "        redist_tax_amount = s['amount_to_mint'] * s['redist_tax_rate']\n",
    "    print(redist_tax_amount)\n",
    "    return (y, redist_tax_amount)\n",
    "\n",
    "def update_redistribution_amount_burn(params, step, sL, s, _input):\n",
    "    y = 'redist'\n",
    "    redist_tax_amount = 0\n",
    "    return (y, redist_tax_amount)\n",
    "\n",
    "def redistribute(params, step, sL, s, _input):\n",
    "    y = 'token_holders'\n",
    "    x = s['token_holders']\n",
    "    n = s['n']\n",
    "    redist = s['redist']\n",
    "    total_tokens = s['total_tokens']\n",
    "    print(\"Redistribute %s based on total %s\" % (redist, total_tokens))\n",
    "    for i in range(0, n):\n",
    "        x[i] = x[i] + redist * x[i] / total_tokens\n",
    "    print(x)\n",
    "    return (y, x)\n",
    "\n",
    "# def upd8_DAOpool(params, step, sL, s, _input):\n",
    "#     y = 1\n",
    "#     x = 1\n",
    "#     return(y,x)\n",
    "\n",
    "# def upd8_BCreserve(params, step, sL, s, _input):\n",
    "#     y = 1\n",
    "#     x = 1\n",
    "#     return(y,x)\n",
    "\n",
    "# def upd8_M_circulating(params, step, sL, s, _input):\n",
    "#     y = 1\n",
    "#     x = 1\n",
    "#     return(y,x)\n",
    "\n",
    "# def upd8_x_userbalances(params, step, sL, s, _input):\n",
    "#     y = 1\n",
    "#     x = 1\n",
    "#     return(y,x)\n",
    "\n",
    "# def activeuser(params, step, sL, s, _input):\n",
    "#     actusr = rd.randint(1,7)\n",
    "#     return(actusr)\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# In the Partial State Update Blocks, \n",
    "# the user specifies if state update functions will be run in series or in parallel\n",
    "# and the policy functions that will be evaluated in that block\n",
    "\n",
    "# Multiple blocks: in series\n",
    "# All in one block: in parallel\n",
    "\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': {\n",
    "            'choose_holder': choose_holder, \n",
    "        },\n",
    "        'variables': {\n",
    "            'BC_reserve': update_BC_reserve_burn,\n",
    "            'token_holders': update_token_holders_burn,\n",
    "            'redist': update_redistribution_amount_burn,\n",
    "            'total_tokens': update_total_tokens_burn,\n",
    "        }\n",
    "    }\n",
    "]\n",
    "\n",
    "# partial_state_update_blocks = [\n",
    "#     { \n",
    "#         'policies': { # The following policy functions will be evaluated and their returns will be passed to the state update functions\n",
    "# #             '': ,\n",
    "# #             '':\n",
    "#         },\n",
    "#         'variables': { # The following state variables will be updated simultaneously\n",
    "#             'DAO_pool': upd8_DAOpool,\n",
    "#             'BC_reserve': upd8_BCreserve\n",
    "#         }\n",
    "#     }\n",
    "# ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "                            __________   ____ \n",
      "          ________ __ _____/ ____/   |  / __ \\\n",
      "         / ___/ __` / __  / /   / /| | / / / /\n",
      "        / /__/ /_/ / /_/ / /___/ ___ |/ /_/ / \n",
      "        \\___/\\__,_/\\__,_/\\____/_/  |_/_____/  \n",
      "        by BlockScience\n",
      "        \n",
      "Execution Mode: single_proc: [<cadCAD.configuration.Configuration object at 0x000002828803F948>]\n",
      "Configurations: [<cadCAD.configuration.Configuration object at 0x000002828803F948>]\n",
      "Index to act on is 3\n",
      "[1006 1000 1000  800 1000 1000 1000 1000]\n",
      "Index to act on is 2\n",
      "[1012 1000  800  800 1000 1000 1000 1000]\n",
      "Index to act on is 4\n",
      "[1018 1000  800  800  800 1000 1000 1000]\n",
      "Index to act on is 2\n",
      "[1022 1000  640  800  800 1000 1000 1000]\n",
      "Index to act on is 4\n",
      "[1026 1000  640  800  640 1000 1000 1000]\n",
      "Index to act on is 7\n",
      "[1032 1000  640  800  640 1000 1000  800]\n",
      "Index to act on is 7\n",
      "[1036 1000  640  800  640 1000 1000  640]\n",
      "Index to act on is 4\n",
      "[1039 1000  640  800  512 1000 1000  640]\n",
      "Index to act on is 4\n",
      "[1042 1000  640  800  409 1000 1000  640]\n",
      "Index to act on is 2\n",
      "[1045 1000  512  800  409 1000 1000  640]\n",
      "Index to act on is 3\n",
      "[1049 1000  512  640  409 1000 1000  640]\n",
      "Index to act on is 4\n",
      "[1051 1000  512  640  327 1000 1000  640]\n",
      "Index to act on is 3\n",
      "[1054 1000  512  512  327 1000 1000  640]\n",
      "Index to act on is 2\n",
      "[1057 1000  409  512  327 1000 1000  640]\n",
      "Index to act on is 7\n",
      "[1060 1000  409  512  327 1000 1000  512]\n",
      "Index to act on is 2\n",
      "[1062 1000  327  512  327 1000 1000  512]\n",
      "Index to act on is 3\n",
      "[1065 1000  327  409  327 1000 1000  512]\n",
      "Index to act on is 7\n",
      "[1068 1000  327  409  327 1000 1000  409]\n",
      "Index to act on is 6\n",
      "[1074 1000  327  409  327 1000  800  409]\n",
      "Index to act on is 7\n",
      "[1076 1000  327  409  327 1000  800  327]\n",
      "Index to act on is 4\n",
      "[1077 1000  327  409  261 1000  800  327]\n",
      "Index to act on is 5\n",
      "[1083 1000  327  409  261  800  800  327]\n",
      "Index to act on is 2\n",
      "[1084 1000  261  409  261  800  800  327]\n",
      "Index to act on is 7\n",
      "[1085 1000  261  409  261  800  800  261]\n",
      "Index to act on is 3\n",
      "[1087 1000  261  327  261  800  800  261]\n",
      "Index to act on is 6\n",
      "[1091 1000  261  327  261  800  640  261]\n",
      "Index to act on is 7\n",
      "[1092 1000  261  327  261  800  640  208]\n",
      "Index to act on is 7\n",
      "[1093 1000  261  327  261  800  640  166]\n",
      "Index to act on is 4\n",
      "[1094 1000  261  327  208  800  640  166]\n",
      "Index to act on is 2\n",
      "[1095 1000  208  327  208  800  640  166]\n",
      "Index to act on is 6\n",
      "[1098 1000  208  327  208  800  512  166]\n",
      "Index to act on is 6\n",
      "[1101 1000  208  327  208  800  409  166]\n",
      "Index to act on is 6\n",
      "[1103 1000  208  327  208  800  327  166]\n",
      "Index to act on is 6\n",
      "[1104 1000  208  327  208  800  261  166]\n",
      "Index to act on is 4\n",
      "[1105 1000  208  327  166  800  261  166]\n",
      "Index to act on is 7\n",
      "[1105 1000  208  327  166  800  261  132]\n",
      "Index to act on is 7\n",
      "[1105 1000  208  327  166  800  261  105]\n",
      "Index to act on is 6\n",
      "[1106 1000  208  327  166  800  208  105]\n",
      "Index to act on is 3\n",
      "[1107 1000  208  261  166  800  208  105]\n",
      "Index to act on is 2\n",
      "[1108 1000  166  261  166  800  208  105]\n",
      "Index to act on is 7\n",
      "[1108 1000  166  261  166  800  208   84]\n",
      "Index to act on is 3\n",
      "[1109 1000  166  208  166  800  208   84]\n",
      "Index to act on is 4\n",
      "[1109 1000  166  208  132  800  208   84]\n",
      "Index to act on is 3\n",
      "[1110 1000  166  166  132  800  208   84]\n",
      "Index to act on is 5\n",
      "[1114 1000  166  166  132  640  208   84]\n",
      "Index to act on is 2\n",
      "[1114 1000  132  166  132  640  208   84]\n",
      "Index to act on is 7\n",
      "[1114 1000  132  166  132  640  208   67]\n",
      "Index to act on is 5\n",
      "[1117 1000  132  166  132  512  208   67]\n",
      "Index to act on is 7\n",
      "[1117 1000  132  166  132  512  208   53]\n",
      "Index to act on is 3\n",
      "[1117 1000  132  132  132  512  208   53]\n",
      "Index to act on is 3\n",
      "[1117 1000  132  105  132  512  208   53]\n",
      "Index to act on is 7\n",
      "[1117 1000  132  105  132  512  208   42]\n",
      "Index to act on is 2\n",
      "[1117 1000  105  105  132  512  208   42]\n",
      "Index to act on is 4\n",
      "[1117 1000  105  105  105  512  208   42]\n",
      "Index to act on is 7\n",
      "[1117 1000  105  105  105  512  208   33]\n",
      "Index to act on is 7\n",
      "[1117 1000  105  105  105  512  208   26]\n",
      "Index to act on is 6\n",
      "[1118 1000  105  105  105  512  166   26]\n",
      "Index to act on is 2\n",
      "[1118 1000   84  105  105  512  166   26]\n",
      "Index to act on is 5\n",
      "[1121 1000   84  105  105  409  166   26]\n",
      "Index to act on is 7\n",
      "[1121 1000   84  105  105  409  166   20]\n",
      "Index to act on is 2\n",
      "[1121 1000   67  105  105  409  166   20]\n",
      "Index to act on is 4\n",
      "[1121 1000   67  105   84  409  166   20]\n",
      "Index to act on is 6\n",
      "[1121 1000   67  105   84  409  132   20]\n",
      "Index to act on is 3\n",
      "[1121 1000   67   84   84  409  132   20]\n",
      "Index to act on is 4\n",
      "[1121 1000   67   84   67  409  132   20]\n",
      "Index to act on is 7\n",
      "[1121 1000   67   84   67  409  132   16]\n",
      "Index to act on is 4\n",
      "[1121 1000   67   84   53  409  132   16]\n",
      "Index to act on is 2\n",
      "[1121 1000   53   84   53  409  132   16]\n",
      "Index to act on is 3\n",
      "[1121 1000   53   67   53  409  132   16]\n",
      "Index to act on is 5\n",
      "[1123 1000   53   67   53  327  132   16]\n",
      "Index to act on is 4\n",
      "[1123 1000   53   67   42  327  132   16]\n",
      "Index to act on is 5\n",
      "[1124 1000   53   67   42  261  132   16]\n",
      "Index to act on is 7\n",
      "[1124 1000   53   67   42  261  132   12]\n",
      "Index to act on is 3\n",
      "[1124 1000   53   53   42  261  132   12]\n",
      "Index to act on is 6\n",
      "[1124 1000   53   53   42  261  105   12]\n",
      "Index to act on is 3\n",
      "[1124 1000   53   42   42  261  105   12]\n",
      "Index to act on is 5\n",
      "[1125 1000   53   42   42  208  105   12]\n",
      "Index to act on is 4\n",
      "[1125 1000   53   42   33  208  105   12]\n",
      "Index to act on is 4\n",
      "[1125 1000   53   42   26  208  105   12]\n",
      "Index to act on is 6\n",
      "[1125 1000   53   42   26  208   84   12]\n",
      "Index to act on is 3\n",
      "[1125 1000   53   33   26  208   84   12]\n",
      "Index to act on is 7\n",
      "[1125 1000   53   33   26  208   84    9]\n",
      "Index to act on is 3\n",
      "[1125 1000   53   26   26  208   84    9]\n",
      "Index to act on is 4\n",
      "[1125 1000   53   26   20  208   84    9]\n",
      "Index to act on is 3\n",
      "[1125 1000   53   20   20  208   84    9]\n",
      "Index to act on is 3\n",
      "[1125 1000   53   16   20  208   84    9]\n",
      "Index to act on is 4\n",
      "[1125 1000   53   16   16  208   84    9]\n",
      "Index to act on is 3\n",
      "[1125 1000   53   12   16  208   84    9]\n",
      "Index to act on is 3\n",
      "[1125 1000   53    9   16  208   84    9]\n",
      "Index to act on is 6\n",
      "[1125 1000   53    9   16  208   67    9]\n",
      "Index to act on is 7\n",
      "[1125 1000   53    9   16  208   67    7]\n",
      "Index to act on is 3\n",
      "[1125 1000   53    7   16  208   67    7]\n",
      "Index to act on is 7\n",
      "[1125 1000   53    7   16  208   67    5]\n",
      "Index to act on is 2\n",
      "[1125 1000   42    7   16  208   67    5]\n",
      "Index to act on is 6\n",
      "[1125 1000   42    7   16  208   53    5]\n",
      "Index to act on is 6\n",
      "[1125 1000   42    7   16  208   42    5]\n",
      "Index to act on is 3\n",
      "[1125 1000   42    5   16  208   42    5]\n",
      "Index to act on is 2\n",
      "[1125 1000   33    5   16  208   42    5]\n",
      "Index to act on is 6\n",
      "[1125 1000   33    5   16  208   33    5]\n",
      "Index to act on is 6\n",
      "[1125 1000   33    5   16  208   26    5]\n"
     ]
    }
   ],
   "source": [
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "from cadCAD.configuration import Configuration\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "from cadCAD.engine import ExecutionMode, ExecutionContext, Executor\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'DAO_pool'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32mc:\\users\\dawg\\anaconda3\\envs\\cadcad\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m   2896\u001b[0m             \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2897\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2898\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'DAO_pool'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-20226227656c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m         \u001b[0mxticks\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'timestep'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdrop_duplicates\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m         \u001b[0mcolormap\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'RdYlGn'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m         yticks=list(range(1+(df['BC_reserve']+df['DAO_pool']).max())));\n\u001b[0m",
      "\u001b[1;32mc:\\users\\dawg\\anaconda3\\envs\\cadcad\\lib\\site-packages\\pandas\\core\\frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m   2993\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2994\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2995\u001b[1;33m             \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2996\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2997\u001b[0m                 \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\users\\dawg\\anaconda3\\envs\\cadcad\\lib\\site-packages\\pandas\\core\\indexes\\base.py\u001b[0m in \u001b[0;36mget_loc\u001b[1;34m(self, key, method, tolerance)\u001b[0m\n\u001b[0;32m   2897\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2898\u001b[0m             \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2899\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_maybe_cast_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2900\u001b[0m         \u001b[0mindexer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2901\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;32mor\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mKeyError\u001b[0m: 'DAO_pool'"
     ]
    }
   ],
   "source": [
    "df.plot('timestep', ['BC_reserve', 'DAO_pool'], grid=True, \n",
    "        xticks=list(df['timestep'].drop_duplicates()), \n",
    "        colormap = 'RdYlGn',\n",
    "        yticks=list(range(1+(df['BC_reserve']+df['DAO_pool']).max())));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot values of iteration\n",
    "df.set_index(['run', 'timestep', 'substep'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Non-determinism\n",
    "Non-deterministic systems exhibit different behaviors on different runs for the same input. The order of heads and tails in a series of 3 coin tosses, for example, is non deterministic. \n",
    "\n",
    "Our robots and marbles system is currently modelled as a deterministic system. Meaning that every time we run the simulation: none of the robots act on timestep 1; robot 1 acts on timestep 2; robot 2 acts on timestep 3; an so on. \n",
    "\n",
    "If however we were to define that at every timestep each robot would act with a probability P, then we would have a non-deterministic (probabilistic) system. Let's make the following changes to our system.\n",
    "* Robot 1: instead of acting once every two timesteps, there's a 50% chance it will act in any given timestep\n",
    "* Robot 2: instead of acting once every three timesteps, there's a 33.33% chance it will act in any given timestep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "from numpy.random import rand\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# We specify each of the robots logic in a Policy Function\n",
    "robots_probabilities = [0.5,1/3] # Robot 1 acts with a 50% probability; Robot 2, 33.33%\n",
    "\n",
    "def robot_arm_1(params, step, sL, s):\n",
    "    _robotId = 1\n",
    "    if rand()<robots_probabilities[_robotId-1]: # draw a random number between 0 and 1; if it's smaller than the robot's parameter, it acts\n",
    "        return robot_arm(params, step, sL, s)\n",
    "    else:\n",
    "        return({'add_to_A': 0, 'add_to_B': 0}) # otherwise, the robot doesn't interfere with the system\n",
    "\n",
    "def robot_arm_2(params, step, sL, s):\n",
    "    _robotId = 2\n",
    "    if rand()<robots_probabilities[_robotId-1]: # draw a random number between 0 and 1; if it's smaller than the robot's parameter, it acts\n",
    "        return robot_arm(params, step, sL, s)\n",
    "    else:\n",
    "        return({'add_to_A': 0, 'add_to_B': 0}) # otherwise, the robot doesn't interfere with the system\n",
    "\n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# In the Partial State Update Blocks, \n",
    "# the user specifies if state update functions will be run in series or in parallel\n",
    "# and the policy functions that will be evaluated in that block\n",
    "partial_state_update_blocks = [\n",
    "    { \n",
    "        'policies': { # The following policy functions will be evaluated and their returns will be passed to the state update functions\n",
    "            'robot_arm_1': robot_arm_1,\n",
    "            'robot_arm_2': robot_arm_2\n",
    "        },\n",
    "        'variables': { # The following state variables will be updated simultaneously\n",
    "            'box_A': increment_A,\n",
    "            'box_B': increment_B\n",
    "        }\n",
    "    }\n",
    "]\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we run the simulation with those configurations, the system is unlikely to exhibit the same behavior as it did in its deterministic version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot('timestep', ['box_A', 'box_B'], grid=True, \n",
    "        xticks=list(df['timestep'].drop_duplicates()), \n",
    "        colormap = 'RdYlGn',\n",
    "        yticks=list(range(1+(df['box_A']+df['box_B']).max())));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if we run it again, it returns yet another result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot('timestep', ['box_A', 'box_B'], grid=True, \n",
    "        xticks=list(df['timestep'].drop_duplicates()), \n",
    "        colormap = 'RdYlGn',\n",
    "        yticks=list(range(1+(df['box_A']+df['box_B']).max())));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to take advantage of cadCAD's Monte Carlo simulation features, we should modify the configuration file so as to define the number of times we want the same simulation to be run. This is done in the `N` key of the `simulation_parameters` dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \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 leave it empty\n",
    "simulation_parameters = {\n",
    "    'T': range(10),\n",
    "    'N': 50, # We'll run the same simulation 50 times; the random events in each simulation are independent\n",
    "    'M': {}\n",
    "}\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "\n",
    "# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # \n",
    "# The configurations above are then packaged into a `Configuration` object\n",
    "config = Configuration(initial_state=initial_conditions, #dict containing variable names and initial values\n",
    "                       partial_state_update_blocks=partial_state_update_blocks, #dict containing state update functions\n",
    "                       sim_config=simulation_parameters #dict containing simulation parameters\n",
    "                      )\n",
    "\n",
    "exec_mode = ExecutionMode()\n",
    "exec_context = ExecutionContext(exec_mode.single_proc)\n",
    "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n",
    "raw_result, tensor = executor.execute() # The `execute()` method returns a tuple; its first elements contains the raw results\n",
    "\n",
    "df = pd.DataFrame(raw_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display\n",
    "tmp_rows = pd.options.display.max_rows\n",
    "pd.options.display.max_rows = 10\n",
    "display(df.set_index(['run', 'timestep', 'substep']))\n",
    "pd.options.display.max_rows = tmp_rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting two of those runs allows us to see the different behaviors over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['run']==1].plot('timestep', ['box_A', 'box_B'], grid=True,\n",
    "                          xticks=list(df['timestep'].drop_duplicates()), \n",
    "                          yticks=list(range(11)),\n",
    "                          colormap = 'RdYlGn');\n",
    "df[df['run']==9].plot('timestep', ['box_A', 'box_B'], grid=True,\n",
    "                            xticks=list(df['timestep'].drop_duplicates()), \n",
    "                            yticks=list(range(11)),\n",
    "                            colormap = 'RdYlGn');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we plot all those runs onto a single chart, we can see every possible trajectory for the number of marbles in each box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = None\n",
    "for i in range(simulation_parameters['N']):\n",
    "    ax = df[df['run']==i+1].plot('timestep', ['box_A', 'box_B'],\n",
    "                                     grid=True,\n",
    "                                     xticks=list(df['timestep'].drop_duplicates()), \n",
    "                                     yticks=list(range(1+max(df['box_A'].max(),df['box_B'].max()))),\n",
    "                                     legend = (ax == None),\n",
    "                                     colormap = 'RdYlGn',\n",
    "                                     ax = ax\n",
    "                                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For some analyses, it might make sense to look at the data in aggregate. Take the median for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfmc_median = df.groupby(['timestep', 'substep']).median().reset_index()\n",
    "dfmc_median.plot('timestep', ['box_A', 'box_B'], \n",
    "                 grid=True,\n",
    "                 xticks=list(dfmc_median['timestep'].drop_duplicates()), \n",
    "                 yticks=list(range(int(1+max(dfmc_median['box_A'].max(),dfmc_median['box_B'].max())))),\n",
    "                 colormap = 'RdYlGn'\n",
    "                )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or look at edge cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_final_A = df[df['timestep']==df['timestep'].max()]['box_A'].max()\n",
    "# max_final_A\n",
    "slow_runs = df[(df['timestep']==df['timestep'].max()) & \n",
    "         (df['box_A']==max_final_A)]['run']\n",
    "slow_runs = list(slow_runs)\n",
    "slow_runs\n",
    "\n",
    "ax = None\n",
    "for i in slow_runs:\n",
    "    ax = df[df['run']==i].plot('timestep', ['box_A', 'box_B'],\n",
    "                                     grid=True,\n",
    "                                     xticks=list(df['timestep'].drop_duplicates()), \n",
    "                                     yticks=list(range(1+max(df['box_A'].max(),df['box_B'].max()))),\n",
    "                                     legend = (ax == None),\n",
    "                                     colormap = 'RdYlGn',\n",
    "                                     ax = ax\n",
    "                                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We invite the reader to fork this code and come up with answers for their other questions that might be interesting to look at. For example:\n",
    "* How often does box B momentarily contain more marbles than box A?\n",
    "* What's the frequency distribution of the time to reach equilibrium?\n",
    "* What's the probability distribution of the waiting times of each one of the robots?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}