Evolution-of-Trust.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0TZAVTzq_-M6"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from numba import jit\n",
        "from itertools import combinations\n",
        "import statistics\n",
        "import ctypes\n",
        "import time\n",
        "import sys\n",
        "import random\n",
        "import math\n",
        "import cProfile\n",
        "\n",
        "class Gamer:\n",
        "  __slots__ = ['former_round', 'output', 'points']\n",
        "  def __init__(self):\n",
        "    self.former_round = None\n",
        "    self.output = None\n",
        "    self.points = 0\n",
        "  def end_of_turns(self):\n",
        "    self.former_round, self.output = None, None\n",
        "  def make_decision(self):\n",
        "    raise NotImplementedError"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_6iQFfnSb8hp"
      },
      "outputs": [],
      "source": [
        "class copycat(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self): #copycat copies the other's decision\n",
        "    if self.former_round == None:\n",
        "      self.output = 1\n",
        "      return self.output\n",
        "    else:\n",
        "      self.output = self.former_round\n",
        "      return self.output\n",
        "\n",
        "class the_believer(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self): #the_believer always trusts\n",
        "    self.output = 1\n",
        "    return self.output\n",
        "\n",
        "class the_selfish(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self): #the_selfish always betrays\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "\n",
        "class the_chaos(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self): #the_choas returns random value\n",
        "    self.output = random.randint(0, 1)\n",
        "    return self.output\n",
        "\n",
        "class the_stubborn(Gamer):\n",
        "  __slots__ = ['is_betrayed']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.is_betrayed = 0\n",
        "  def make_decision(self): #trust until betrayed, and then always betray\n",
        "    if self.former_round == None or self.former_round == 1 and self.is_betrayed == 0:\n",
        "      self.output = 1\n",
        "      return self.output\n",
        "    self.is_betrayed = 1\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.is_betrayed = 0\n",
        "\n",
        "class the_generous_copycat(Gamer):\n",
        "  __slots__ = ['tolerance', 'betrayed_times']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.tolerance = 2\n",
        "    self.betrayed_times = 0\n",
        "  def make_decision(self): #trust unless betrayed for consecutive tolerance times\n",
        "    if self.former_round == 0:\n",
        "      self.betrayed_times += 1\n",
        "    else:\n",
        "      self.betrayed_times = 0\n",
        "    if self.former_round == None or self.betrayed_times < self.tolerance:\n",
        "      self.output = 1\n",
        "      return self.output\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.betrayed_times = 0\n",
        "\n",
        "class pavlov(Gamer):\n",
        "  __slots__ = ['default_output']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.default_output =1\n",
        "  def make_decision(self): #if former_round == output, cooperate, else defect\n",
        "    if self.former_round == None:\n",
        "      self.output = self.default_output\n",
        "      return self.output\n",
        "    if self.former_round == self.output:\n",
        "      self.output = 1\n",
        "      return self.output\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "\n",
        "class majority_follower(Gamer):\n",
        "  __slots__ = ['oppo_total', 'default_output']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.oppo_total = 0\n",
        "    self.default_output = 1\n",
        "  def make_decision(self):\n",
        "    if self.former_round == 1:\n",
        "      self.oppo_total += 1\n",
        "    elif self.former_round == 0:\n",
        "      self.oppo_total += -1\n",
        "    if self.former_round == None or self.oppo_total == 0:\n",
        "      self.output = self.default_output\n",
        "      return self.output\n",
        "    if self.oppo_total > 0:\n",
        "      self.output = 1\n",
        "      return self.output\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.oppo_total = 0\n",
        "\n",
        "class the_mean_copycat(Gamer):\n",
        "  __slots__ = ['revenge_times', 'revenge_count']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.revenge_times = 2 #default\n",
        "    self.revenge_count = 0\n",
        "  def make_decision(self):\n",
        "    if self.revenge_count > 0:\n",
        "      self.output = 0\n",
        "      self.revenge_count += 1\n",
        "      if self.revenge_count == self.revenge_times:\n",
        "        self.revenge_count =0\n",
        "      return self.output\n",
        "    if self.former_round == 0:\n",
        "      self.output = 0\n",
        "      self.revenge_count += 1\n",
        "      return self.output\n",
        "    self.output = 1\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.revenge_count = 0\n",
        "\n",
        "\n",
        "class the_vicious_copycat(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self):\n",
        "    if self.former_round == None:\n",
        "      self.output = 0\n",
        "      return self.output\n",
        "    else:\n",
        "      self.output = self.former_round\n",
        "      return self.output\n",
        "\n",
        "class operator_gamer(Gamer):\n",
        "  __slots__ = ['default_output' ,'operator']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.default_output = 1\n",
        "    self.operator = 10\n",
        "    # self.operator default value is 10, namely a copycat\n",
        "    # self.operator must be an integer in range(16), namely 0 to 15\n",
        "  def make_decision(self):\n",
        "    if self.operator > 15 or self.operator < 0:\n",
        "      raise ValueError('operator must be an integer in range(16)')\n",
        "    if self.former_round == None:\n",
        "      self.output = self.default_output\n",
        "      return self.output\n",
        "    temp1 = self.output\n",
        "    temp2 = self.former_round\n",
        "    if temp1 and temp2:\n",
        "      self.output = (self.operator >> 3) & 1\n",
        "    elif not (temp1 or temp2):\n",
        "      self.output = self.operator & 1\n",
        "    elif temp1:\n",
        "      self.output = (self.operator >> 2) & 1\n",
        "    else:\n",
        "      self.output = (self.operator >> 1) & 1\n",
        "    return self.output\n",
        "\n",
        "class the_tricker(Gamer):\n",
        "  __slots__ = ['cooperate_times']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.cooperate_times = 1\n",
        "  def make_decision(self):\n",
        "    if self.cooperate_times > 0:\n",
        "      self.output = 1\n",
        "      self.cooperate_times -= 1\n",
        "      return self.output\n",
        "    self.output = 0\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.cooperate_times = 1\n",
        "\n",
        "class detective(Gamer):\n",
        "  __slots__ = ['sequence_deci', 'is_betrayed', 'count_turns']\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.sequence_deci = 13 #default is 13, namely [1, 1, 0, 1]\n",
        "    self.is_betrayed = 0\n",
        "    self.count_turns = 0\n",
        "  def make_decision(self):\n",
        "    if len(format(self.sequence_deci, 'b')) > self.count_turns:\n",
        "      self.output = self.sequence_deci>>(len(format(self.sequence_deci, 'b'))-self.count_turns-1) & 1\n",
        "      self.count_turns += 1\n",
        "      if self.former_round == 0:\n",
        "        self.is_betrayed = 1\n",
        "      return self.output\n",
        "    if self.is_betrayed == 1:\n",
        "      temp = copycat()\n",
        "      temp.former_round, temp.output = self.former_round, self.output\n",
        "      self.output = temp.make_decision()\n",
        "      return self.output\n",
        "    self.output = the_selfish().make_decision() #the_selfish is independent on former_round so no updating\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()\n",
        "    self.count_turns = 0\n",
        "    self.is_betrayed = 0\n",
        "\n",
        "class remote_controller(Gamer):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  def make_decision(self):\n",
        "    print('former output:', self.output)\n",
        "    print('former return:', self.former_round)\n",
        "    self.output = int(input('Enter your decision: '))\n",
        "    self.output = 0 if self.output == 0 else 1\n",
        "    return self.output\n",
        "  def end_of_turns(self):\n",
        "    super().end_of_turns()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The following five columns are the old game_type_list currently abandoned"
      ],
      "metadata": {
        "id": "l3RSE7Fn7b1r"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uYfEcNyedy4m"
      },
      "outputs": [],
      "source": [
        "class type_list:\n",
        "  def __init__(self, type):\n",
        "    self.type = type\n",
        "    self.list = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mu3gvIwrMdZi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae80bb94-21c8-4fd4-8de8-0c31f1b666f4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n"
          ]
        }
      ],
      "source": [
        "def get_pairs(listx):\n",
        "  return [(i, j) for i in range(len(listx)) for j in range(i+1, len(listx))]\n",
        "print(get_pairs([1, 2, 3, 4, 5]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_pJEi7urnvhs"
      },
      "outputs": [],
      "source": [
        "class game_type_list():\n",
        "  def __init__(self):\n",
        "    attributes_game = {'gamers': [], 'num_of_gamers': 0, 'num_of_turns': 10,\n",
        "              'TT': [2,2], 'TB': [-1, 3], 'BB': [0, 0]}\n",
        "    for name, value in attributes_game.items():\n",
        "      setattr(self, name, value)\n",
        "  # use list of lists to store gamers instead of a plain list\n",
        "  def one_round(self, input1, input2):\n",
        "    if input1 == input2 == 1: #(1, 1)\n",
        "      return self.TT\n",
        "    elif input1 == 1: #(1, 0)\n",
        "      return self.TB\n",
        "    elif input2 == 1: #(0, 1)\n",
        "      return [self.TB[1], self.TB[0]]\n",
        "    else: #(0, 0)\n",
        "      return self.BB\n",
        "\n",
        "  def add_gamer(self, gamer_type, n):\n",
        "    for type_listx in self.gamers:\n",
        "      if type(gamer_type()) == type_listx.type:\n",
        "        for i in range(n):\n",
        "          type_listx.list.append(gamer_type())\n",
        "        self.num_of_gamers += n\n",
        "        return\n",
        "    self.gamers.append(type_list(type(gamer_type())))\n",
        "    for i in range(n):\n",
        "      self.gamers[-1].list.append(gamer_type())\n",
        "    self.num_of_gamers += n\n",
        "\n",
        "  def remove_gamer_a(self, gamer_type, n):\n",
        "    for type_listx in self.gamers:\n",
        "      if type_listx.type == type(gamer_type()):\n",
        "        if n > len(type_listx.list):\n",
        "          print('removals out of range')\n",
        "          return\n",
        "        else:\n",
        "          del type_listx.list[-n:]\n",
        "          self.num_of_gamers -= n\n",
        "          return\n",
        "    print('No such gamer')\n",
        "\n",
        "  def run_matches(self):\n",
        "    for type_listx in self.gamers:\n",
        "      self.game_iteration(type_listx)\n",
        "    pairs_x = get_pairs(self.gamers)\n",
        "    for l in pairs_x:\n",
        "      for gamer1 in self.gamers[l[0]].list:\n",
        "        for gamer2 in self.gamers[l[1]].list:\n",
        "          self.play_match(gamer1, gamer2)\n",
        "\n",
        "  def play_match(self, gamer1, gamer2):\n",
        "    for i in range(self.num_of_turns):\n",
        "      outcome = self.one_round(gamer1.make_decision(), gamer2.make_decision())\n",
        "      gamer1.points += outcome[0]\n",
        "      gamer2.points += outcome[1]\n",
        "      gamer1.former_round = gamer2.output\n",
        "      gamer2.former_round = gamer1.output\n",
        "    gamer1.end_of_turns()\n",
        "    gamer2.end_of_turns()\n",
        "\n",
        "\n",
        "  def game_iteration(self, type_listx):\n",
        "    pairs = get_pairs(type_listx.list)\n",
        "    for l in pairs:\n",
        "      self.play_match(type_listx.list[l[0]], type_listx.list[l[1]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LJGJ211JKSwW"
      },
      "outputs": [],
      "source": [
        "def old_test_case():\n",
        "  game2 = game_type_list()\n",
        "  game2.num_of_turns = 10\n",
        "  game2.add_gamer(copycat, 100)\n",
        "  game2.add_gamer(the_believer, 100)\n",
        "  game2.add_gamer(the_selfish, 100)\n",
        "  game2.add_gamer(pavlov, 100)\n",
        "  game2.add_gamer(the_stubborn, 100)\n",
        "  game2.add_gamer(the_generous_copycat, 100)\n",
        "  game2.add_gamer(majority_follower, 100)\n",
        "  game2.add_gamer(the_tricker, 100)\n",
        "  game2.add_gamer(the_vicious_copycat, 0)\n",
        "  print(game2.num_of_gamers)\n",
        "  game2.run_matches()\n",
        "  for i in game2.gamers:\n",
        "    if len(i.list) > 0:\n",
        "      print(i.type, ': ', i.list[0].points, end='\\n')\n",
        "  print('\\n')\n",
        "  game2.remove_gamer_a(the_selfish, 10)\n",
        "  print(game2.num_of_gamers, len(game2.gamers[4].list))\n",
        "  print(len(game2.gamers))\n",
        "  for i in game2.gamers:\n",
        "    print(i.type, ':', len(i.list), end='\\n')\n",
        "  print('\\n')\n",
        "  print(game2.gamers[0].type)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "old_test_case()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-Xh6TN4E6b0",
        "outputId": "f412cd6d-3c00-4e7a-f263-6ff3f404f194"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "800\n",
            "<class '__main__.copycat'> :  11980\n",
            "<class '__main__.the_believer'> :  10280\n",
            "<class '__main__.the_selfish'> :  6300\n",
            "<class '__main__.pavlov'> :  11180\n",
            "<class '__main__.the_stubborn'> :  11980\n",
            "<class '__main__.the_generous_copycat'> :  11780\n",
            "<class '__main__.majority_follower'> :  11880\n",
            "<class '__main__.the_tricker'> :  7298\n",
            "\n",
            "\n",
            "790 100\n",
            "9\n",
            "<class '__main__.copycat'> : 100\n",
            "<class '__main__.the_believer'> : 100\n",
            "<class '__main__.the_selfish'> : 90\n",
            "<class '__main__.pavlov'> : 100\n",
            "<class '__main__.the_stubborn'> : 100\n",
            "<class '__main__.the_generous_copycat'> : 100\n",
            "<class '__main__.majority_follower'> : 100\n",
            "<class '__main__.the_tricker'> : 100\n",
            "<class '__main__.the_vicious_copycat'> : 0\n",
            "\n",
            "\n",
            "<class '__main__.copycat'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **The following are the new game() definition with a dctionary to store types and gamers**"
      ],
      "metadata": {
        "id": "vM5brjUVrhGW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class IncoherenceError(Exception):\n",
        "  def __init__(self, message):\n",
        "    super().__init__(message)"
      ],
      "metadata": {
        "id": "xnzs6UqPmMBI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "from collections import defaultdict\n",
        "\n",
        "def round_half_up(n):\n",
        "    return math.floor(n + 0.5)\n",
        "\n",
        "\n",
        "#for those to be replaced, collect their gamer_type and list_index\n",
        "#for those to be duplicated. collect their gamer_type and nums\n",
        "\n",
        "def get_replacement(tuples, t):\n",
        "  sorted_tuples = sorted(tuples, key=lambda x: x[2])\n",
        "  top_border_value = sorted_tuples[-t][2]\n",
        "  bottom_border_value = sorted_tuples[t-1][2]\n",
        "\n",
        "  top_tied_tuples = [i for i in sorted_tuples if i[2] == top_border_value]\n",
        "  bottom_tied_tuples = [j for j in sorted_tuples if j[2] == bottom_border_value]\n",
        "  temp_a = len(bottom_tied_tuples)\n",
        "  temp_b = len(top_tied_tuples)\n",
        "\n",
        "  to_be_replaced = [i for i in sorted_tuples if i[2] < bottom_border_value]\n",
        "  to_be_duplicated = [j for j in sorted_tuples if j[2] > top_border_value]\n",
        "  # count to_be_duplicated but not to_be_replaced\n",
        "  to_be_duplicated_count = Counter(i[0] for i in to_be_duplicated)\n",
        "\n",
        "\n",
        "  bottom_tied_counts = list(Counter(i[0] for i in bottom_tied_tuples).items())\n",
        "  top_tied_counts = list(Counter(i[0] for i in top_tied_tuples).items())\n",
        "  bottom_true_counts = []\n",
        "\n",
        "  for i in top_tied_counts:\n",
        "    to_be_duplicated_count[i[0]] += round_half_up((t-len(to_be_duplicated))*(i[1]/temp_b))\n",
        "  for j in bottom_tied_counts:\n",
        "    bottom_true_counts.append((j[0], round_half_up((t-len(to_be_replaced))*(j[1]/temp_a))))\n",
        "\n",
        "  grouped_bottom_tuples = defaultdict(list)\n",
        "  for l in bottom_tied_tuples:\n",
        "    grouped_bottom_tuples[l[0]].append(l)\n",
        "\n",
        "  for n in bottom_true_counts:\n",
        "    if n[0] in grouped_bottom_tuples:\n",
        "      if len(grouped_bottom_tuples[n[0]]) > n[1]:\n",
        "        for j in range(n[1]):\n",
        "          to_be_replaced.append(grouped_bottom_tuples[n[0]][j])\n",
        "      else:\n",
        "        to_be_replaced.extend(grouped_bottom_tuples[n[0]])\n",
        "\n",
        "  to_be_replaced = sorted(to_be_replaced, key=lambda x: x[1], reverse=True)\n",
        "  #reverse the order so the obj of list_index can be deleted from the rear\n",
        "  return to_be_replaced, to_be_duplicated_count"
      ],
      "metadata": {
        "id": "IWgLwnXzG5iJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class game():\n",
        "  __slots__ = ['num_of_gamers', 'num_of_turns', 'TT', 'TB', 'BB', 'gamers_dict', 'dict_keys', 'clear_points', 'replacement_n', 'mistake_rate']\n",
        "  def __init__(self):\n",
        "    attributes_game = {'num_of_gamers': 0, 'num_of_turns': 10,\n",
        "               'TT': [2,2], 'TB': [-1, 3], 'BB': [0, 0],\n",
        "               'gamers_dict': {}, 'dict_keys': [], 'clear_points': 1,\n",
        "               'replacement_n': 30, 'mistake_rate': 0}\n",
        "    for name, value in attributes_game.items():\n",
        "      setattr(self, name, value)\n",
        "\n",
        "  def one_round(self, input1, input2):\n",
        "    if input1 == input2 == 1: #(1, 1)\n",
        "      return self.TT\n",
        "    elif input1 == 1: #(1, 0)\n",
        "      return self.TB\n",
        "    elif input2 == 1: #(0, 1)\n",
        "      return [self.TB[1], self.TB[0]]\n",
        "    else: #(0, 0)\n",
        "      return self.BB\n",
        "\n",
        "  def add_gamer(self, gamer_type, n):\n",
        "    if n <= 0:\n",
        "      return\n",
        "    if gamer_type not in self.dict_keys:\n",
        "      self.dict_keys.append(type(gamer_type()))\n",
        "      self.gamers_dict[type(gamer_type())] = []\n",
        "    for _ in range(n):\n",
        "      self.gamers_dict[type(gamer_type())].append(gamer_type())\n",
        "    self.num_of_gamers += n\n",
        "    return\n",
        "\n",
        "  def remove_gamer_back(self, gamer_type, n):\n",
        "    if n <= 0:\n",
        "      return\n",
        "    if type(gamer_type()) not in self.dict_keys:\n",
        "      print('No such gamer')\n",
        "      return\n",
        "    if n > len(self.gamers_dict[type(gamer_type())]):\n",
        "      print('Removal out of range')\n",
        "      return\n",
        "    del self.gamers_dict[type(gamer_type())][-n:]\n",
        "    self.num_of_gamers -= n\n",
        "    return\n",
        "\n",
        "  def remove_gamer_index(self, gamer_type, n):\n",
        "    if gamer_type not in self.dict_keys:\n",
        "      print('No such gamer')\n",
        "      return\n",
        "    if n >= len(self.gamers_dict[gamer_type]) or n < -(len(self.gamers_dict[gamer_type])):\n",
        "      print('Removal out of range')\n",
        "      return\n",
        "    del self.gamers_dict[gamer_type][n]\n",
        "    self.num_of_gamers -= 1\n",
        "    return\n",
        "\n",
        "  def perturb(self, value): #mistake_rate_function\n",
        "    if random.random() < self.mistake_rate:\n",
        "      return 1 if value ==0 else 0\n",
        "    return value\n",
        "\n",
        "  def run_matches(self):\n",
        "    #check if self.dict_keys is correct\n",
        "    if self.dict_keys != list(self.gamers_dict.keys()):\n",
        "      raise IncoherenceError('dict_keys isn\\'t coherent with real keys')\n",
        "    for list_x in self.gamers_dict.values():\n",
        "      pairs = list(combinations(range(len(list_x)), 2))\n",
        "      for pair in pairs:\n",
        "        self.play_match(list_x[pair[0]], list_x[pair[1]])\n",
        "    pairs = list(combinations(range(len(self.dict_keys)), 2))\n",
        "    for pair in pairs:\n",
        "      for gamer1 in self.gamers_dict[self.dict_keys[pair[0]]]:\n",
        "        for gamer2 in self.gamers_dict[self.dict_keys[pair[1]]]:\n",
        "          self.play_match(gamer1, gamer2)\n",
        "    return\n",
        "\n",
        "  def play_match(self, gamer1, gamer2):\n",
        "    for i in range(self.num_of_turns):\n",
        "      if self.mistake_rate == 0:\n",
        "        outcome = self.one_round(gamer1.make_decision(), gamer2.make_decision())\n",
        "      else:\n",
        "        gamer1.output = self.perturb(gamer1.make_decision())\n",
        "        gamer2.output = self.perturb(gamer2.make_decision())\n",
        "        outcome = self.one_round(gamer1.output, gamer2.output)\n",
        "      gamer1.points += outcome[0]\n",
        "      gamer2.points += outcome[1]\n",
        "      gamer1.former_round = gamer2.output\n",
        "      gamer2.former_round = gamer1.output\n",
        "    gamer1.end_of_turns()\n",
        "    gamer2.end_of_turns()\n",
        "\n",
        "  def print_points(self, n):\n",
        "    for key in self.gamers_dict:\n",
        "      print(f\"{key}[{n}] value: {self.gamers_dict[key][n].points}\")\n",
        "\n",
        "  def print_points_extreme(self, max_or_min):\n",
        "    if max_or_min:\n",
        "      for key in self.gamers_dict:\n",
        "        print(key, 'max_value:', max([i.points for i in self.gamers_dict[key]]))\n",
        "    else:\n",
        "      for key in self.gamers_dict:\n",
        "        print(key, 'max_value:', min([i.points for i in self.gamers_dict[key]]))\n",
        "    return\n",
        "\n",
        "  def print_points_avg(self):\n",
        "    for key in self.gamers_dict:\n",
        "      print(key, 'avg: ', round(sum([i.points for i in self.gamers_dict[key]])/len(self.gamers_dict[key])))\n",
        "\n",
        "  def print_points_stdev(self):\n",
        "    for key in self.gamers_dict:\n",
        "      print(key, ' stdev: ', np.std([i.points for i in self.gamers_dict[key]]))\n",
        "\n",
        "  def print_gamer_nums(self):\n",
        "    for key in self.gamers_dict:\n",
        "      print(key, ':', len(self.gamers_dict[key]))\n",
        "\n",
        "  def replacement_process(self):\n",
        "    gamer_tuples = []\n",
        "    for listx in self.gamers_dict.values():\n",
        "      for i in range(len(listx)):\n",
        "        gamer_tuples.append((type(listx[i]), i, listx[i].points))\n",
        "        if self.clear_points:\n",
        "          listx[i].points = 0\n",
        "    to_be_replaced, to_be_duplicated = get_replacement(gamer_tuples, self.replacement_n)\n",
        "    for i in to_be_replaced:\n",
        "      self.remove_gamer_index(i[0], i[1])\n",
        "    for key, value in to_be_duplicated.items():\n",
        "      self.add_gamer(key, value)\n",
        "    for key in list(self.gamers_dict.keys()):\n",
        "      if self.gamers_dict[key] == []:\n",
        "        del self.gamers_dict[key]\n",
        "    self.dict_keys = list(self.gamers_dict.keys())\n",
        "    return\n",
        "\n",
        "  def complete_round(self):\n",
        "    self.run_matches()\n",
        "    self.replacement_process()\n",
        "    return"
      ],
      "metadata": {
        "id": "VbXc4c6JQeW_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def new_test_case():\n",
        "  game1 = game()\n",
        "  game1.num_of_turns = 10\n",
        "  game1.mistake_rate = 0.05\n",
        "  game1.add_gamer(copycat, 100)\n",
        "  game1.add_gamer(the_believer, 100)\n",
        "  game1.add_gamer(the_selfish, 100)\n",
        "  game1.add_gamer(pavlov, 100)\n",
        "  game1.add_gamer(the_stubborn, 100)\n",
        "  game1.add_gamer(the_generous_copycat, 100)\n",
        "  game1.add_gamer(majority_follower, 100)\n",
        "  game1.add_gamer(the_tricker, 100)\n",
        "  game1.add_gamer(the_mean_copycat, 100)\n",
        "  game1.add_gamer(detective, 100)\n",
        "  tmp_round = 10\n",
        "  for i in range(tmp_round):\n",
        "    if i == tmp_round-1:\n",
        "      game1.clear_points = 0\n",
        "    game1.complete_round()\n",
        "  print(game1.num_of_gamers)\n",
        "  game1.print_gamer_nums()\n",
        "  print('\\n')\n",
        "  game1.print_points(0)\n",
        "  print('\\n')\n",
        "  game1.print_points_stdev()\n",
        "  print('\\n')\n",
        "  game1.print_points_avg()"
      ],
      "metadata": {
        "id": "qXb16IsnzkDE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "start_time = time.time()\n",
        "new_test_case()\n",
        "end_time = time.time()\n",
        "print(f\"Time taken: {end_time - start_time} seconds\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ETNahSeL8Ao",
        "outputId": "ec6e7452-e31d-4b8f-9ebd-d7f26d4783bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1001\n",
            "<class '__main__.copycat'> : 116\n",
            "<class '__main__.the_believer'> : 100\n",
            "<class '__main__.pavlov'> : 100\n",
            "<class '__main__.the_stubborn'> : 123\n",
            "<class '__main__.the_generous_copycat'> : 302\n",
            "<class '__main__.majority_follower'> : 158\n",
            "<class '__main__.the_mean_copycat'> : 102\n",
            "\n",
            "\n",
            "<class '__main__.copycat'>[0] value: 16504\n",
            "<class '__main__.the_believer'>[0] value: 16976\n",
            "<class '__main__.pavlov'>[0] value: 16378\n",
            "<class '__main__.the_stubborn'>[0] value: 16339\n",
            "<class '__main__.the_generous_copycat'>[0] value: 17076\n",
            "<class '__main__.majority_follower'>[0] value: 16729\n",
            "<class '__main__.the_mean_copycat'>[0] value: 16248\n",
            "\n",
            "\n",
            "<class '__main__.copycat'>  stdev:  124.85222269503497\n",
            "<class '__main__.the_believer'>  stdev:  146.39333693853695\n",
            "<class '__main__.pavlov'>  stdev:  132.4677908021418\n",
            "<class '__main__.the_stubborn'>  stdev:  163.75200098530235\n",
            "<class '__main__.the_generous_copycat'>  stdev:  4682.743009154755\n",
            "<class '__main__.majority_follower'>  stdev:  2959.901059150989\n",
            "<class '__main__.the_mean_copycat'>  stdev:  130.35615491484475\n",
            "\n",
            "\n",
            "<class '__main__.copycat'> avg:  16651\n",
            "<class '__main__.the_believer'> avg:  16700\n",
            "<class '__main__.pavlov'> avg:  16353\n",
            "<class '__main__.the_stubborn'> avg:  16275\n",
            "<class '__main__.the_generous_copycat'> avg:  15583\n",
            "<class '__main__.majority_follower'> avg:  16358\n",
            "<class '__main__.the_mean_copycat'> avg:  16383\n",
            "Time taken: 63.48392081260681 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "k = game()\n",
        "k.add_gamer(the_mean_copycat, 1)\n",
        "k.add_gamer(copycat, 1)\n",
        "k.run_matches()\n",
        "k.print_points(0)"
      ],
      "metadata": {
        "id": "F6Krr8tWCVlA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a4882952-7868-4f1d-a792-1d3a85eed734"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.the_mean_copycat'>[0] value: 20\n",
            "<class '__main__.copycat'>[0] value: 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cProfile.run('new_test_case()')"
      ],
      "metadata": {
        "id": "ZB97h9BHDiyg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c4f9810-b54b-4dfe-9c7a-6f352985fe48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1000\n",
            "<class '__main__.copycat'> : 116\n",
            "<class '__main__.the_believer'> : 100\n",
            "<class '__main__.pavlov'> : 100\n",
            "<class '__main__.the_stubborn'> : 116\n",
            "<class '__main__.the_generous_copycat'> : 280\n",
            "<class '__main__.majority_follower'> : 188\n",
            "<class '__main__.the_mean_copycat'> : 100\n",
            "\n",
            "\n",
            "<class '__main__.copycat'>[0] value: 16655\n",
            "<class '__main__.the_believer'>[0] value: 16758\n",
            "<class '__main__.pavlov'>[0] value: 16479\n",
            "<class '__main__.the_stubborn'>[0] value: 16244\n",
            "<class '__main__.the_generous_copycat'>[0] value: 17000\n",
            "<class '__main__.majority_follower'>[0] value: 17030\n",
            "<class '__main__.the_mean_copycat'>[0] value: 16401\n",
            "\n",
            "\n",
            "<class '__main__.copycat'>  stdev:  152.40013079466394\n",
            "<class '__main__.the_believer'>  stdev:  129.5383383404311\n",
            "<class '__main__.pavlov'>  stdev:  153.77006990958935\n",
            "<class '__main__.the_stubborn'>  stdev:  152.74349578738457\n",
            "<class '__main__.the_generous_copycat'>  stdev:  4765.49295329942\n",
            "<class '__main__.majority_follower'>  stdev:  2974.8537488540633\n",
            "<class '__main__.the_mean_copycat'>  stdev:  138.73990197488249\n",
            "\n",
            "\n",
            "<class '__main__.copycat'> avg:  16661\n",
            "<class '__main__.the_believer'> avg:  16735\n",
            "<class '__main__.pavlov'> avg:  16316\n",
            "<class '__main__.the_stubborn'> avg:  16277\n",
            "<class '__main__.the_generous_copycat'> avg:  15560\n",
            "<class '__main__.majority_follower'> avg:  16366\n",
            "<class '__main__.the_mean_copycat'> avg:  16431\n",
            "         411771895 function calls in 145.354 seconds\n",
            "\n",
            "   Ordered by: standard name\n",
            "\n",
            "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
            "  5277340    1.113    0.000    1.113    0.000 <ipython-input-1-04952d6bedcf>:14(__init__)\n",
            "  9990000    1.658    0.000    1.658    0.000 <ipython-input-1-04952d6bedcf>:18(end_of_turns)\n",
            "        1    0.000    0.000    0.001    0.001 <ipython-input-10-f478c680a80b>:104(print_points_avg)\n",
            "        7    0.000    0.000    0.000    0.000 <ipython-input-10-f478c680a80b>:106(<listcomp>)\n",
            "        1    0.000    0.000    0.002    0.002 <ipython-input-10-f478c680a80b>:108(print_points_stdev)\n",
            " 49950000    8.990    0.000    8.990    0.000 <ipython-input-10-f478c680a80b>:11(one_round)\n",
            "        7    0.000    0.000    0.000    0.000 <ipython-input-10-f478c680a80b>:110(<listcomp>)\n",
            "        1    0.000    0.000    0.001    0.001 <ipython-input-10-f478c680a80b>:112(print_gamer_nums)\n",
            "       10    0.004    0.000    0.011    0.001 <ipython-input-10-f478c680a80b>:116(replacement_process)\n",
            "       10    0.000    0.000  145.348   14.535 <ipython-input-10-f478c680a80b>:134(complete_round)\n",
            "       41    0.001    0.000    0.004    0.000 <ipython-input-10-f478c680a80b>:21(add_gamer)\n",
            "        1    0.000    0.000    0.000    0.000 <ipython-input-10-f478c680a80b>:3(__init__)\n",
            "      300    0.000    0.000    0.000    0.000 <ipython-input-10-f478c680a80b>:45(remove_gamer_index)\n",
            " 99900000   22.919    0.000   29.333    0.000 <ipython-input-10-f478c680a80b>:56(perturb)\n",
            "       10    1.143    0.114  145.336   14.534 <ipython-input-10-f478c680a80b>:61(run_matches)\n",
            "  4995000   64.067    0.000  144.193    0.000 <ipython-input-10-f478c680a80b>:76(play_match)\n",
            "        1    0.000    0.000    0.000    0.000 <ipython-input-10-f478c680a80b>:91(print_points)\n",
            "        1    0.000    0.000  145.354  145.354 <ipython-input-17-3d9c711f332f>:1(new_test_case)\n",
            "  1506492    0.639    0.000    0.883    0.000 <ipython-input-2-bdc938805a8e>:103(end_of_turns)\n",
            "      202    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:109(__init__)\n",
            "  9990000    2.436    0.000    2.436    0.000 <ipython-input-2-bdc938805a8e>:113(make_decision)\n",
            "   999000    0.419    0.000    0.577    0.000 <ipython-input-2-bdc938805a8e>:126(end_of_turns)\n",
            "      202    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:13(__init__)\n",
            "  9990000    1.284    0.000    1.284    0.000 <ipython-input-2-bdc938805a8e>:15(make_decision)\n",
            "      202    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:170(__init__)\n",
            "  5494500    0.961    0.000    0.961    0.000 <ipython-input-2-bdc938805a8e>:173(make_decision)\n",
            "   549450    0.239    0.000    0.327    0.000 <ipython-input-2-bdc938805a8e>:180(end_of_turns)\n",
            "      202    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:186(__init__)\n",
            "  8791200    8.551    0.000   15.908    0.000 <ipython-input-2-bdc938805a8e>:191(make_decision)\n",
            "  1755468    0.675    0.000    1.036    0.000 <ipython-input-2-bdc938805a8e>:2(__init__)\n",
            "  3519688    1.395    0.000    2.146    0.000 <ipython-input-2-bdc938805a8e>:20(__init__)\n",
            "   879120    0.432    0.000    0.580    0.000 <ipython-input-2-bdc938805a8e>:205(end_of_turns)\n",
            "  5717286    0.835    0.000    0.835    0.000 <ipython-input-2-bdc938805a8e>:22(make_decision)\n",
            "      234    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:35(__init__)\n",
            " 11298690    2.615    0.000    2.615    0.000 <ipython-input-2-bdc938805a8e>:38(make_decision)\n",
            " 12814164    2.301    0.000    2.301    0.000 <ipython-input-2-bdc938805a8e>:4(make_decision)\n",
            "  1129869    0.514    0.000    0.713    0.000 <ipython-input-2-bdc938805a8e>:45(end_of_turns)\n",
            "      562    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:51(__init__)\n",
            " 16023960    4.567    0.000    4.567    0.000 <ipython-input-2-bdc938805a8e>:55(make_decision)\n",
            "  1602396    0.722    0.000    0.995    0.000 <ipython-input-2-bdc938805a8e>:65(end_of_turns)\n",
            "      202    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:71(__init__)\n",
            "  9990000    2.078    0.000    2.078    0.000 <ipython-input-2-bdc938805a8e>:74(make_decision)\n",
            "      378    0.000    0.000    0.000    0.000 <ipython-input-2-bdc938805a8e>:86(__init__)\n",
            " 15064920    5.082    0.000    5.082    0.000 <ipython-input-2-bdc938805a8e>:90(make_decision)\n",
            "       10    0.000    0.000    0.005    0.001 <ipython-input-9-a1b49b5ada4a>:11(get_replacement)\n",
            "    10000    0.001    0.000    0.001    0.000 <ipython-input-9-a1b49b5ada4a>:12(<lambda>)\n",
            "       10    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:16(<listcomp>)\n",
            "       10    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:17(<listcomp>)\n",
            "       10    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:21(<listcomp>)\n",
            "       10    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:22(<listcomp>)\n",
            "      298    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:24(<genexpr>)\n",
            "       27    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:27(<genexpr>)\n",
            "       26    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:28(<genexpr>)\n",
            "       21    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:4(round_half_up)\n",
            "      300    0.000    0.000    0.000    0.000 <ipython-input-9-a1b49b5ada4a>:48(<lambda>)\n",
            "        1    0.000    0.000  145.354  145.354 <string>:1(<module>)\n",
            "       30    0.000    0.000    0.000    0.000 __init__.py:565(__init__)\n",
            "       30    0.000    0.000    0.000    0.000 __init__.py:640(update)\n",
            "        7    0.000    0.000    0.001    0.000 _methods.py:135(_var)\n",
            "        7    0.000    0.000    0.001    0.000 _methods.py:204(_std)\n",
            "        7    0.000    0.000    0.000    0.000 _methods.py:67(_count_reduce_items)\n",
            "       14    0.000    0.000    0.000    0.000 _ufunc_config.py:452(_no_nep50_warning)\n",
            "       30    0.000    0.000    0.000    0.000 abc.py:117(__instancecheck__)\n",
            "        7    0.000    0.000    0.000    0.000 contextlib.py:102(__init__)\n",
            "        7    0.000    0.000    0.000    0.000 contextlib.py:130(__enter__)\n",
            "        7    0.000    0.000    0.000    0.000 contextlib.py:139(__exit__)\n",
            "        7    0.000    0.000    0.000    0.000 contextlib.py:279(helper)\n",
            "        7    0.000    0.000    0.000    0.000 fromnumeric.py:3508(_std_dispatcher)\n",
            "        7    0.000    0.000    0.001    0.000 fromnumeric.py:3513(std)\n",
            "      149    0.000    0.000    0.001    0.000 iostream.py:195(schedule)\n",
            "      148    0.000    0.000    0.000    0.000 iostream.py:308(_is_master_process)\n",
            "      148    0.000    0.000    0.000    0.000 iostream.py:321(_schedule_flush)\n",
            "      148    0.000    0.000    0.002    0.000 iostream.py:384(write)\n",
            "      149    0.000    0.000    0.000    0.000 iostream.py:91(_event_pipe)\n",
            "      149    0.001    0.000    0.001    0.000 socket.py:545(send)\n",
            "      149    0.000    0.000    0.000    0.000 threading.py:1102(_wait_for_tstate_lock)\n",
            "      149    0.000    0.000    0.000    0.000 threading.py:1169(is_alive)\n",
            "      149    0.000    0.000    0.000    0.000 threading.py:553(is_set)\n",
            "       30    0.000    0.000    0.000    0.000 {built-in method _abc._abc_instancecheck}\n",
            "       30    0.000    0.000    0.000    0.000 {built-in method _collections._count_elements}\n",
            "        1    0.000    0.000  145.354  145.354 {built-in method builtins.exec}\n",
            " 12307680    2.452    0.000    2.452    0.000 {built-in method builtins.format}\n",
            "        7    0.000    0.000    0.000    0.000 {built-in method builtins.getattr}\n",
            "       14    0.000    0.000    0.000    0.000 {built-in method builtins.hasattr}\n",
            "      199    0.000    0.000    0.000    0.000 {built-in method builtins.isinstance}\n",
            "       14    0.000    0.000    0.000    0.000 {built-in method builtins.issubclass}\n",
            " 12308537    0.837    0.000    0.837    0.000 {built-in method builtins.len}\n",
            "       14    0.000    0.000    0.000    0.000 {built-in method builtins.next}\n",
            "       32    0.000    0.000    0.002    0.000 {built-in method builtins.print}\n",
            "        7    0.000    0.000    0.000    0.000 {built-in method builtins.round}\n",
            "       10    0.000    0.000    0.000    0.000 {built-in method builtins.setattr}\n",
            "       20    0.002    0.000    0.003    0.000 {built-in method builtins.sorted}\n",
            "        7    0.000    0.000    0.000    0.000 {built-in method builtins.sum}\n",
            "       21    0.000    0.000    0.000    0.000 {built-in method math.floor}\n",
            "       14    0.000    0.000    0.000    0.000 {built-in method numpy.asanyarray}\n",
            "        7    0.000    0.000    0.000    0.000 {built-in method numpy.core._multiarray_umath.normalize_axis_index}\n",
            "      148    0.000    0.000    0.000    0.000 {built-in method posix.getpid}\n",
            "      149    0.000    0.000    0.000    0.000 {method 'acquire' of '_thread.lock' objects}\n",
            "      149    0.000    0.000    0.000    0.000 {method 'append' of 'collections.deque' objects}\n",
            "    11342    0.001    0.000    0.001    0.000 {method 'append' of 'list' objects}\n",
            "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\n",
            "        7    0.000    0.000    0.000    0.000 {method 'extend' of 'list' objects}\n",
            "       31    0.000    0.000    0.000    0.000 {method 'items' of 'dict' objects}\n",
            "       30    0.000    0.000    0.000    0.000 {method 'keys' of 'dict' objects}\n",
            " 99900000    6.414    0.000    6.414    0.000 {method 'random' of '_random.Random' objects}\n",
            "       14    0.000    0.000    0.000    0.000 {method 'reduce' of 'numpy.ufunc' objects}\n",
            "        7    0.000    0.000    0.000    0.000 {method 'reset' of '_contextvars.ContextVar' objects}\n",
            "        7    0.000    0.000    0.000    0.000 {method 'set' of '_contextvars.ContextVar' objects}\n",
            "       20    0.000    0.000    0.000    0.000 {method 'values' of 'dict' objects}\n",
            "\n",
            "\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "l3RSE7Fn7b1r"
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}