FinForce.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pylab as pl\n",
    "from cadCAD.configuration import Configuration\n",
    "from cadCAD.engine import ExecutionMode, ExecutionContext, Executor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# general setup\n",
    "time_steps = 50 \n",
    "\n",
    "#special PATs, user specific\n",
    "spPAT = 3\n",
    "# 'vote' -\n",
    "# 'reputation' -\n",
    "# 'governance' -\n",
    "\n",
    "#PAT attributes, PAT specific\n",
    "PAT_atr = False\n",
    "PAT_flav = False\n",
    "#flavour - good [0, 5] - bad [6, 10] - randomly distributed\n",
    "# users are good [1, 5]\n",
    "good_users = 50 #%\n",
    "# users are bad [6, 10]\n",
    "bad_users = 20 #%\n",
    "# users are ignorant [4, 7]\n",
    "ignorant_users = 30 #%\n",
    "\n",
    "# 'difficulty' \n",
    "PAT_diff_constant = True\n",
    "PAT_controlled = False\n",
    "good_PAT = 5\n",
    "ignorant_PAT = 2\n",
    "bad_PAT = 1\n",
    "\n",
    "PAT_atr_max = False # not yet implemented\n",
    "# 'max' -\n",
    "# 'value' -\n",
    "\n",
    "#population settings\n",
    "community = False\n",
    "community_size_1 = 15\n",
    "community_series = True\n",
    "# not implemented yet\n",
    "community_size_2 = 15 \n",
    "# not implemented yet\n",
    "between_com = 15      \n",
    "\n",
    "#TCR settings - only voting implemented \n",
    "TCR = True          \n",
    "reputation_threshold_for_voting = 300 # reputation tokens\n",
    "voting_rate = False    # not imnplemented yet\n",
    "voting_rate_value = 20 #% not implemented yet\n",
    "\n",
    "#reputation token allocation\n",
    "\n",
    "# for proof of positive action\n",
    "rep_token_proof = True\n",
    "# for claiming/receiving a token\n",
    "rep_token_claim = True\n",
    "rep_PAT_creator = False\n",
    "\n",
    "#random OPATs\n",
    "# the PATs are selected randomly for voting from the existing PAT list \n",
    "random_OPATs = False\n",
    "# the selected PATs for voting are picked from fixed list of PAT ids [5, 10, 15, 20, 25, 30, 35, 40 etc.]\n",
    "fixed_OPAT_sugestion = True\n",
    "\n",
    "# the selected PATs from a fixed list [5, 10, 15, 20, 25, 30, 35, 40] become OPATs regardless of the vote results\n",
    "fixed_OPATs = False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulation_parameters = {\n",
    "    'T': range(time_steps),\n",
    "    'N': 1,\n",
    "    'M': {}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_update_name(variable_name):\n",
    "    return \"add_\" + variable_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#general constants\n",
    "TIMESTEP = 'timestep' # access to current timestep with s[TIMESTEP]\n",
    "USERS = \"users\"\n",
    "PATS = \"pats\"\n",
    "PAT_ARGUMENTS = \"pat_arguments\"\n",
    "OPATS = \"opats\"\n",
    "WALLET_GAINS = \"wallet_gains\"\n",
    "ADD_USERS = get_update_name(USERS)\n",
    "ADD_PATS = get_update_name(PATS)\n",
    "\n",
    "proposed_PAT_id = [5, 10, 15, 20, 25, 30, 35, 40]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "if PAT_flav:\n",
    "    initial_conditions = {\n",
    "        USERS: {0:{}},  # users are numerical ids and a dictionary of their current wallet\n",
    "        PATS: [0],      # pats are currently simply numerical ids\n",
    "        PAT_ARGUMENTS: [(0, 1, 1)], # PAT specific atributes\n",
    "        OPATS: ()\n",
    "    }\n",
    "else:\n",
    "    initial_conditions = {\n",
    "        USERS: {0:{}},  # users are numerical ids and a dictionary of their current wallet\n",
    "        PATS: [0],      # pats are currently simply numerical ids\n",
    "        PAT_ARGUMENTS: [(0, 1)], # PAT specific atributes\n",
    "        OPATS: ()\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Secondary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clear_PAT_list(pats):\n",
    "    for i in range(0, len(pats)-1):\n",
    "        try:\n",
    "            if pats[i] == \"vote\":\n",
    "                del pats[i]\n",
    "\n",
    "            if pats[i] == \"reputation\":\n",
    "                del pats[i]\n",
    "\n",
    "            if pats[i] == \"governance\":\n",
    "                del pats[i]\n",
    "        except:\n",
    "            pass\n",
    "    return pats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pat_proposal(users):\n",
    "    choice = None\n",
    "    p = users[PATS].copy()\n",
    "    op = users[OPATS]\n",
    "    ch_list_1 = clear_PAT_list(p)\n",
    "\n",
    "    if fixed_OPAT_sugestion:\n",
    "        if users[TIMESTEP] % 5 != 0:\n",
    "            pass\n",
    "        else:\n",
    "            choice = users[TIMESTEP]\n",
    "    else:\n",
    "        if len(op) > 0 and op[0] != None:\n",
    "            if ch_list_1 != None:\n",
    "                if len(ch_list_1) > 0:\n",
    "                    ch_list = set(ch_list_1) - set(list(op))\n",
    "                    choice = random.choice(list(ch_list))\n",
    "            else:\n",
    "                choice = None\n",
    "        else:\n",
    "            choice = random.choice(p)\n",
    "    return choice\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vote_result(users):\n",
    "    yes = 0\n",
    "    no = 0\n",
    "    for u in range(0, len(users)):\n",
    "        if 'vote' in users[u]:\n",
    "            if users[u].get(\"vote\") == 0:\n",
    "                no += 1\n",
    "            if users[u].get(\"vote\") == 1:\n",
    "                yes += 1\n",
    "        else:\n",
    "            pass\n",
    "    if no == 0 and yes == 0 or no == yes:\n",
    "        vote = None\n",
    "    elif no > yes:\n",
    "        vote = False\n",
    "    elif no < yes:\n",
    "        vote = True\n",
    "    return vote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def good_man(u, pats, arg, tstep, gain):\n",
    "    print (\"good man\")\n",
    "    good_PAT_list = []\n",
    "    for pat in pats:  \n",
    "        for i in arg:\n",
    "            if i[0] == pat:\n",
    "                if i[2] >= 1 and i[2] <= 3:\n",
    "                    good_PAT_list.append(pat)\n",
    "\n",
    "    for p in random.sample(good_PAT_list, random.randint(0, len(good_PAT_list))):\n",
    "        for i in arg:\n",
    "            if i[0] == p:\n",
    "                if tstep % i[1] == 0:\n",
    "                    gain[(u, p)] = 1\n",
    "    print(\"good, gain: \", gain)\n",
    "    return gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ignorant_man(u, pats, arg, tstep, gain):\n",
    "    print (\"ignorant man\")\n",
    "    ignorant_PAT_list = []\n",
    "    for pat in pats: \n",
    "        for i in arg:\n",
    "            if i[0] == pat:\n",
    "                if i[2] >= 4 and i[2] <= 7:\n",
    "                    ignorant_PAT_list.append(pat)\n",
    "                    \n",
    "    for p in random.sample(ignorant_PAT_list, random.randint(0, len(ignorant_PAT_list))):\n",
    "        for i in arg:\n",
    "            if i[0] == p:\n",
    "                if tstep % i[1] == 0:\n",
    "                    gain[(u, p)] = 1\n",
    "    print(\"ignorant, gain: \", gain)\n",
    "    return gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bad_man(u, pats, arg, tstep, gain):\n",
    "    print (\"bad man\")\n",
    "    bad_PAT_list = []\n",
    "    for pat in pats:\n",
    "        for i in arg:\n",
    "            if i[0] == pat:\n",
    "                if i[2] >= 7:\n",
    "                    bad_PAT_list.append(pat)\n",
    "\n",
    "    for p in random.sample(bad_PAT_list, random.randint(0, len(bad_PAT_list))):\n",
    "        for i in arg:\n",
    "            if i[0] == p:\n",
    "                if tstep % i[1] == 0:\n",
    "                    gain[(u, p)] = 1\n",
    "    print(\"bad, gain: \", gain)\n",
    "    return gain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distribute_tokens_pat_attributes(s, gain, extra_gain):\n",
    "    pats = s[PATS]\n",
    "    p = pats[3:]\n",
    "    users = s[USERS]\n",
    "    tstep = s[TIMESTEP]\n",
    "    arg = s[PAT_ARGUMENTS]\n",
    "    print(\"arguments: \", arg)\n",
    "    opats = s[OPATS]\n",
    "    # at most all the PATs of a person get a token\n",
    "    for u in users:\n",
    "        # for each pat in a list of paths of random length and random values\n",
    "        if arg[u][2] <= 3:\n",
    "            good_man(u, pats, arg, tstep, gain)\n",
    "            #print(\"good man\")\n",
    "        if arg[u][2] >= 4 and arg[u][2] <= 7:\n",
    "            ignorant_man(u, pats, arg, tstep, gain)\n",
    "            #print(\"ignorant man\")\n",
    "        if arg[u][2] >=8 and arg[u][2]<=10:\n",
    "            bad_man(u, pats, arg, tstep, gain)\n",
    "            #print(\"bad man\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distribute_tokens(s, gain, extra_gain):\n",
    "    users = s[USERS]\n",
    "    pats = s[PATS]\n",
    "    opats = s[OPATS]\n",
    "    p = pats[3:]\n",
    "    # at most all the PATs of a person get a token\n",
    "    for u in users:\n",
    "        # for each pat in a list of paths of random length and random values\n",
    "        for pat in random.sample(p, random.randint(0, len(p))):\n",
    "            gain[(u, pat)] = 1\n",
    "        if opats != None:\n",
    "            # if OPATs exist, every user will be allocated a token for each OPAT\n",
    "            for opa in range(0, len(opats)):\n",
    "                gain[(u, opats[opa])] = 1\n",
    "    return gain\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rep_token(wallet, gain, n):\n",
    "    if 'reputation' in wallet:\n",
    "        wallet[\"reputation\"] = wallet.get(\"reputation\") + n * gain\n",
    "    else :\n",
    "        d = {\"reputation\": n}\n",
    "        wallet.update(d)\n",
    "    return wallet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_fixed_opat(timestep, opats):\n",
    "    if timestep % 5 != 0:\n",
    "        pass\n",
    "    else:\n",
    "        proposed_PAT_id = timestep\n",
    "        opats = opats + tuple([proposed_PAT_id])\n",
    "    return opats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_vote_add_opat(prop_id, vote, opats):\n",
    "    if prop_id == None:\n",
    "        print(\"No proposed PAT id given\")\n",
    "        pass\n",
    "    \n",
    "    if vote == None:\n",
    "        print(\"Inconclusive vote\")\n",
    "        pass \n",
    "    \n",
    "    if vote == False: \n",
    "        print(\"Negative vote\")\n",
    "        pass\n",
    "    else:\n",
    "        opats = opats + tuple([prop_id])\n",
    "        \n",
    "    if opats != None:\n",
    "        if has_duplicates(opats):\n",
    "            opats = get_rid_of_duplicates(opats)\n",
    "            \n",
    "    return opats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_duplicates(iterable):\n",
    "    l = list(iterable)\n",
    "    try:\n",
    "        return len(set(iterable)) != len(iterable)\n",
    "    except:\n",
    "        l = list(iterable)\n",
    "        return len(set(l)) != len(l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rid_of_duplicates(opats):\n",
    "    l = list(opats)\n",
    "    cleaned_list = list(dict.fromkeys(l))\n",
    "    return tuple(cleaned_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def identify_PAT_flavour(structure, treshold):\n",
    "    if list(structure.keys())[list(structure.values()).index(treshold)] == \"b\":\n",
    "        flav = random.randint(8, 10)\n",
    "    elif list(structure.keys())[list(structure.values()).index(treshold)] == \"g\":\n",
    "        flav = random.randint(1, 3)\n",
    "    else:\n",
    "        flav = random.randint(4, 7)\n",
    "    return flav"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Main Functions - to update at every time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_users(params, step, sL, s):\n",
    "    next_user_id = len(s[USERS])\n",
    "    x = {ADD_USERS:[\n",
    "        (next_user_id, {}),\n",
    "    ]}\n",
    "    if next_user_id == 1:\n",
    "        u = s[USERS].copy()\n",
    "        d = {\"reputation\": 1}\n",
    "        u[0].update(d)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_pat(params, step, sL, s):\n",
    "    next_pat_id = len(s[PATS])\n",
    "    if next_pat_id >= (spPAT - 1):\n",
    "        next_pat_id = len(s[PATS]) - spPAT\n",
    "    x = {ADD_PATS:[next_pat_id,]}\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_pat_arguments(params, step, sL, s):\n",
    "    next_pat_id = len(s[PAT_ARGUMENTS])\n",
    "    flav = 1\n",
    "\n",
    "    if PAT_flav:\n",
    "        community_structure = {\"g\": good_users, \"i\": ignorant_users, \"b\": bad_users}\n",
    "        percentages = (bad_users, ignorant_users, good_users)\n",
    "        print(\"percentages\", percentages)\n",
    "        top = max(percentages)\n",
    "        print(\"top\", top)\n",
    "        bottom = min(percentages)\n",
    "        print(\"bottom\", bottom)\n",
    "        middle1 = [x for x in percentages if x != top]\n",
    "        print (\"middle1\", middle1)\n",
    "        try:\n",
    "            middle = [x for x in middle1 if x != bottom][0]\n",
    "        except:\n",
    "            middle = middle1[0]\n",
    "        choice = random.randint(1, 100)\n",
    "        print(\"choice\", choice)\n",
    "        if choice <= top:\n",
    "            #print(\"type of user: \", list(community_structure.keys())[list(community_structure.values()).index(top)])\n",
    "            flav = identify_PAT_flavour(community_structure, top)\n",
    "        if choice <= top + middle and choice > top:\n",
    "            #print(\"type of user: \", list(community_structure.keys())[list(community_structure.values()).index(middle)])\n",
    "            flav = identify_PAT_flavour(community_structure, middle)\n",
    "        if choice > top + middle:\n",
    "            #print(\"type of user: \", list(community_structure.keys())[list(community_structure.values()).index(bottom)])\n",
    "            flav = identify_PAT_flavour(community_structure, bottom)\n",
    "\n",
    "        if PAT_diff_constant:\n",
    "            difficulty = 1\n",
    "        if PAT_controlled:\n",
    "            if flav <= 3:\n",
    "                difficulty = good_PAT\n",
    "            if flav >= 4 and flav <=7:\n",
    "                difficulty = ignorant_PAT\n",
    "            if flav >= 8:\n",
    "                difficulty = bad_PAT\n",
    "        if PAT_diff_constant == False and PAT_controlled == False:\n",
    "            difficulty = random.randint(1, 10)\n",
    "        return ({'ID': next_pat_id, 'dif': difficulty, \"flav\": flav})\n",
    "    else:\n",
    "        if PAT_diff_constant:\n",
    "            difficulty = 1\n",
    "        else:\n",
    "            difficulty = random.randint(1, 10)\n",
    "        return ({'ID': next_pat_id, 'dif': difficulty})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def user_actions(params, step, sL, s):\n",
    "    gain = {}\n",
    "    gain_ext = {}\n",
    "    if community:\n",
    "        if s[TIMESTEP] <= community_size_1:\n",
    "            pass\n",
    "        elif community_size_2 > 0:\n",
    "            if s[TIMESTEP] > (community_size_1 + between_com) and s[TIMESTEP] <= (community_size_1 + between_com + community_size_2):\n",
    "                pass\n",
    "            else:\n",
    "                if PAT_atr:\n",
    "                    distribute_tokens_pat_attributes(s, gain, gain_ext)\n",
    "                else:\n",
    "                    distribute_tokens(s, gain, gain_ext)        \n",
    "        else:\n",
    "            if PAT_atr:\n",
    "                distribute_tokens_pat_attributes(s, gain, gain_ext)\n",
    "            else:\n",
    "                distribute_tokens(s, gain, gain_ext)\n",
    "    else:\n",
    "        if PAT_atr:\n",
    "            distribute_tokens_pat_attributes(s, gain, gain_ext)\n",
    "        else:\n",
    "            distribute_tokens(s, gain, gain_ext)\n",
    "    return {WALLET_GAINS: gain}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def user_vote(params, step, sL, s):\n",
    "    x = s[USERS].copy()\n",
    "    pat = pat_proposal(s)\n",
    "    for u in range(0, len(x)-1):\n",
    "        # ---------------F4-----fixed threshold or percentage\n",
    "        if 'reputation' in x[u] and x[u].get(\"reputation\") > reputation_threshold_for_voting:\n",
    "            if \"vote\" in x[u]:\n",
    "                v = random.randint(0, 1)\n",
    "                d = {\"vote\": v}\n",
    "                x[u].update(d)\n",
    "            else:\n",
    "                d = {\"vote\": 0}\n",
    "                x[u].update(d)\n",
    "\n",
    "    return ({'Vote':x, 'Proposed_pat':pat})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Functions - to update the variables at every time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_users(params, step, sL, s, _input):\n",
    "    x = s[USERS].copy()\n",
    "    for new_user_id, wallet in _input[ADD_USERS]:\n",
    "        x[new_user_id] = wallet\n",
    "    return (USERS, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_pat(params, step, sL, s, _input):\n",
    "    x = s[PATS].copy()\n",
    "    if len(x) <=2:\n",
    "        initial = x\n",
    "        spec = ['vote', 'reputation', 'governance']\n",
    "        x = spec + initial\n",
    "    x.extend(_input[ADD_PATS])\n",
    "    #if setup.rep_PAT_owner:\n",
    "    # ---------------F3-------------------------------------\n",
    "    #add activity token to the user who comes up with the added token     - PAT_owner\n",
    "        #u = s[USERS].copy()\n",
    "        #matching_user = _input[ADD_PATS][0]\n",
    "        #x = get_rep_token(u[user], 1, 1)\n",
    "        #if u[matching_user].get(\"reputation\", 0) == 0:\n",
    "        #    d = {\"reputation\": 1}\n",
    "        #    u[matching_user].update(d)\n",
    "        #else:\n",
    "        #    u[matching_user][\"reputation\"] = u[matching_user].get(\"reputation\") + 1\n",
    "    return (PATS, x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_pat_arguments(params, step, sL, s, _input):\n",
    "    x = s[PAT_ARGUMENTS].copy()\n",
    "    if PAT_flav:\n",
    "        d = (_input[\"ID\"], _input[\"dif\"], _input[\"flav\"])\n",
    "        x.append(d)\n",
    "    else:\n",
    "        d = (_input[\"ID\"], _input[\"dif\"])\n",
    "        x.append(d)\n",
    "    return (PAT_ARGUMENTS, x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_user_wallets(params, step, sL, s, _input):\n",
    "    x = s[USERS].copy()\n",
    "    changes = _input[WALLET_GAINS]\n",
    "    for (user, pat), gain in changes.items():\n",
    "        #add the token itself\n",
    "        x[user][pat] = x[user].get(pat, 0) + gain\n",
    "        if rep_token_claim:\n",
    "            if rep_token_proof:\n",
    "                # gain one reputation token for the proof of positive action\n",
    "                # and one for receiving a token (of any kind)\n",
    "                x[user] = get_rep_token(x[user], gain, 1)\n",
    "                x[user] = get_rep_token(x[user], gain, 1)\n",
    "            else:\n",
    "                x[user] = get_rep_token(x[user], gain, 1)\n",
    "        if rep_PAT_creator:\n",
    "            x[user] = get_rep_token(x[user], gain, 1)\n",
    "    return (USERS, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def opats(params, step, sL, s, _input):\n",
    "    result = vote_result(_input[\"Vote\"])\n",
    "    proposed_PAT_id = None\n",
    "    updated_opats = s[OPATS]\n",
    "    if random_OPATs or fixed_OPAT_sugestion:\n",
    "        proposed_PAT_id = _input[\"Proposed_pat\"]\n",
    "        updated_opats = evaluate_vote_add_opat(proposed_PAT_id, result, updated_opats)\n",
    "    if fixed_OPATs:\n",
    "        updated_opats = add_fixed_opat(s[TIMESTEP], s[OPATS])\n",
    "    return (OPATS, updated_opats)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "if TCR:\n",
    "    partial_state_update_blocks = [\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_users': create_users,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: add_users,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_pat': create_pat,\n",
    "            },\n",
    "            'variables': {\n",
    "                PATS: add_pat,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'user_actions': user_actions,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: update_user_wallets,\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            'policies': {\n",
    "                'user_vote': user_vote,\n",
    "            },\n",
    "            'variables': {\n",
    "                OPATS: opats,\n",
    "            }\n",
    "        },\n",
    "    ]\n",
    "if PAT_atr:\n",
    "    partial_state_update_blocks = [\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_users': create_users,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: add_users,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_pat': create_pat,\n",
    "            },\n",
    "            'variables': {\n",
    "                PATS: add_pat,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_pat_arguments': create_pat_arguments,\n",
    "            },\n",
    "            'variables': {\n",
    "                PAT_ARGUMENTS: add_pat_arguments,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'user_actions': user_actions,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: update_user_wallets,\n",
    "            }\n",
    "        },\n",
    "    ]\n",
    "if TCR==False and PAT_atr==False:\n",
    "    partial_state_update_blocks = [\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_users': create_users,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: add_users,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'create_pat': create_pat,\n",
    "            },\n",
    "            'variables': {\n",
    "                PATS: add_pat,\n",
    "            }\n",
    "        },\n",
    "\n",
    "        {\n",
    "            'policies': {\n",
    "                'user_actions': user_actions,\n",
    "            },\n",
    "            'variables': {\n",
    "                USERS: update_user_wallets,\n",
    "            }\n",
    "        },\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "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 0x000002845517E710>]\n",
      "Configurations: [<cadCAD.configuration.Configuration object at 0x000002845517E710>]\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n",
      "Inconclusive vote\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "No proposed PAT id given\n",
      "Negative vote\n",
      "No proposed PAT id given\n"
     ]
    }
   ],
   "source": [
    "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()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Name construction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "if TCR:\n",
    "    name = \"tcr_\"\n",
    "else:\n",
    "    name = \"s_\"\n",
    "name = name + \"t\" + str(time_steps) + \"_c\"\n",
    "if community and community_size_1:\n",
    "    if community_size_2:\n",
    "        name = name + \"11_\"\n",
    "    name = name + \"1_\"\n",
    "else:\n",
    "    name = name + \"0_\"\n",
    "name = name + \"vt\" + str(reputation_threshold_for_voting)\n",
    "if random_OPATs:\n",
    "    name = name + \"_rOPATs\"\n",
    "if fixed_OPATs:\n",
    "    name = name + \"_fOPATs\"\n",
    "if fixed_OPAT_sugestion:\n",
    "    name = name + \"_fsOPATs\"\n",
    "if PAT_flav:\n",
    "    name = name + \"_flav\" + str(good_users) + str(ignorant_users) + str(bad_users)\n",
    "else:\n",
    "    name = name + \"_simplePATs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Data analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(raw_result)\n",
    "t_step = raw_result[len(raw_result)-1][\"timestep\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_PATS_of_special_tokens(s):\n",
    "    if s.get(\"reputation\", 0) != 0 or s.get(\"reputation\") == 0:\n",
    "        s.pop(\"reputation\")\n",
    "\n",
    "    if s.get(\"activity\", 0) != 0 or s.get(\"activity\") == 0:\n",
    "        s.pop(\"activity\")\n",
    "\n",
    "    if s.get(\"vote\", 0) != 0 or s.get(\"vote\") == 0:\n",
    "        s.pop(\"vote\")\n",
    "\n",
    "    if s.get(\"governance\", 0) != 0 or s.get(\"governance\") == 0:\n",
    "        s.pop(\"governance\")\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_total_tokens_per_pat(state):\n",
    "    distribution = {pat:0 for pat in state[PATS]}\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != None:\n",
    "                distribution[pat] += number_of_tokens\n",
    "    dist = clean_PATS_of_special_tokens(distribution)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_number_of_tokens_per_person(state):\n",
    "    distribution = {user: 0 for user in state[USERS].keys()}\n",
    "    user = 0\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                distribution[user] += number_of_tokens\n",
    "            else:\n",
    "                pass\n",
    "        user += 1\n",
    "    return distribution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_effort_per_person(state):\n",
    "    distribution = {user: 0 for user in state[USERS].keys()}\n",
    "    user = 0\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                distribution[user] += number_of_tokens * raw_result[-1][PAT_ARGUMENTS][pat][-1]\n",
    "            else:\n",
    "                pass\n",
    "        user += 1\n",
    "    return distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "if PAT_flav:\n",
    "    from tabulate import tabulate\n",
    "    headers = ['Pat id', 'difficulty', 'flavour']\n",
    "    data = sorted([(k,v,u) for k,v, u in raw_result[-1][PAT_ARGUMENTS]])\n",
    "    print(tabulate(data, headers=headers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt1 = pl.scatter(calculate_total_tokens_per_pat(raw_result[-1]).keys(),\n",
    "           calculate_total_tokens_per_pat(raw_result[-1]).values())\n",
    "\n",
    "pl.xticks(np.arange(0, t_step+1, 5))\n",
    "pl.title(\"Number of tokens per type with 300 reputation token voting threshold\")   #(\"tokens_PAT_\" + name)\n",
    "pl.xlabel(\"Type of tokens (id)\")\n",
    "pl.ylabel(\"Number of tokens\")\n",
    "pl.savefig(\"Number of tokens per type with 300 reputation token voting threshold\")   #(\"tokens_PAT_\" + name + \".png\")\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt1 = pl.scatter(calculate_number_of_tokens_per_person(raw_result[-1]).keys(),\n",
    "                  calculate_number_of_tokens_per_person(raw_result[-1]).values())\n",
    "\n",
    "pl.xticks(np.arange(0, time_steps+1, 5))\n",
    "pl.title(\"tokens_user_\" + name)\n",
    "pl.xlabel(\"user id\")\n",
    "pl.ylabel(\"nr. of tokens\")\n",
    "pl.savefig(\"tokens_user_\" + name + \".png\")\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "if PAT_atr:\n",
    "    U1 = calculate_number_of_tokens_per_person(raw_result[-1]).keys()\n",
    "    T = calculate_number_of_tokens_per_person(raw_result[-1]).values()\n",
    "    U2 = calculate_effort_per_person(raw_result[-1]).keys()\n",
    "    E = calculate_effort_per_person(raw_result[-1]).values()\n",
    "\n",
    "    fig = pl.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "\n",
    "    N = len(U1)\n",
    "\n",
    "    ind = np.arange(N)\n",
    "    width = 0.6\n",
    "\n",
    "    ## the bars\n",
    "    rects1 = ax.bar(ind, T, width,\n",
    "                color='purple',\n",
    "                #yerr=TStd,\n",
    "                error_kw=dict(elinewidth=2,ecolor='pink'))\n",
    "\n",
    "    rects2 = ax.bar(ind+width, E, width,\n",
    "                    color='green',\n",
    "                    #yerr=EStd,\n",
    "                    error_kw=dict(elinewidth=2,ecolor='blue'))\n",
    "\n",
    "    # axes and labels\n",
    "    ax.set_xlim(-width,len(ind)+width)\n",
    "    ax.set_ylabel('Tokens')\n",
    "    ax.set_title(\"tokens&effort_user_\" +name)\n",
    "    xTickMarks = [np.arange(0, time_steps+1, 5)]\n",
    "    ax.set_xlabel('User id')\n",
    "    \n",
    "    ## add a legend\n",
    "    ax.legend( (rects1[0], rects2[0]), ('Tokens', 'Effort') )\n",
    "\n",
    "    pl.savefig(\"tokens&effort_user_\" + name + \".png\")\n",
    "    pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_flavour_distribution(state):\n",
    "    distribution = {pat:0 for pat in state[PATS]}\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                distribution[pat] = raw_result[-1][PAT_ARGUMENTS][pat][-1]\n",
    "    dist = clean_PATS_of_special_tokens(distribution)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flavours():\n",
    "    arguments = raw_result[-1][PAT_ARGUMENTS]\n",
    "    flavours = []\n",
    "    for a in range(0, len(arguments)):\n",
    "        flavours.append(raw_result[-1][PAT_ARGUMENTS][a][2])\n",
    "    return flavours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "if PAT_flav:\n",
    "    plt1 = pl.scatter(calculate_flavour_distribution(raw_result[-1]).keys(),\n",
    "                  flavours())\n",
    "\n",
    "    pl.axhline(3)\n",
    "    pl.axhline(7)\n",
    "    pl.xticks(np.arange(0, time_steps+1, 5))\n",
    "    pl.title(\"flavour_distribution\" + name)\n",
    "    pl.xlabel(\"PAT id\")\n",
    "    pl.ylabel(\"flavour\")\n",
    "    pl.savefig(\"flavour_distribution\" + name + \".png\")\n",
    "    pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_good_tokens_per_pat(state):\n",
    "    distribution = {pat:0 for pat in state[PATS]}\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                #print(\"pat\", pat)\n",
    "                #print(\"the flavour of the PAT: \", setup.raw_result[-1][setup.PAT_ARGUMENTS][pat])\n",
    "                if raw_result[-1][PAT_ARGUMENTS][pat][-1] <= 3:\n",
    "                    distribution[pat] += number_of_tokens\n",
    "    dist = clean_PATS_of_special_tokens(distribution)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_bad_tokens_per_pat(state):\n",
    "    distribution = {pat:0 for pat in state[PATS]}\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                #print(pat)\n",
    "                #print(setup.raw_result[-1][setup.PAT_ARGUMENTS][pat][-1])\n",
    "                if raw_result[-1][PAT_ARGUMENTS][pat][-1] > 7:\n",
    "                    distribution[pat] += number_of_tokens\n",
    "    dist = clean_PATS_of_special_tokens(distribution)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_ok_tokens_per_pat(state):\n",
    "    distribution = {pat:0 for pat in state[PATS]}\n",
    "    for user_wallet in state[USERS].values():\n",
    "        for pat, number_of_tokens in user_wallet.items():\n",
    "            if pat != \"reputation\":\n",
    "                if raw_result[-1][PAT_ARGUMENTS][pat][-1] > 3 and raw_result[-1][PAT_ARGUMENTS][pat][-1] <=7:\n",
    "                    distribution[pat] += number_of_tokens\n",
    "    dist = clean_PATS_of_special_tokens(distribution)\n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "if PAT_flav:\n",
    "    GT = calculate_good_tokens_per_pat(raw_result[-1]).keys()\n",
    "    P1 = calculate_good_tokens_per_pat(raw_result[-1]).values()\n",
    "    BT = calculate_bad_tokens_per_pat(raw_result[-1]).keys()\n",
    "    P2 = calculate_bad_tokens_per_pat(raw_result[-1]).values()\n",
    "    IT = calculate_ok_tokens_per_pat(raw_result[-1]).keys()\n",
    "    P3 = calculate_ok_tokens_per_pat(raw_result[-1]).values()\n",
    "\n",
    "    pl.scatter(GT, P1, color='g')\n",
    "    pl.scatter(BT, P2, color='r')\n",
    "    pl.scatter(IT, P3, color='y')\n",
    "\n",
    "    pl.xticks(np.arange(0, time_steps+1, 5))\n",
    "    pl.title(\"new_stuff\" + name)\n",
    "    pl.xlabel(\"PAT\")\n",
    "    pl.ylabel(\"total nr. of tokens\")\n",
    "    pl.savefig(\"new_stuff\" + name + \".png\")\n",
    "    pl.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}