Dice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import pandas as pd\n",
    "import nashpy as nash\n",
    "import numpy as np\n",
    "import time\n",
    "directory = \"C:/Users/Sergio/Documents/python projects/Dice/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Die: # \n",
    "    def __init__(self,sides): \n",
    "        self.sides = sides #sides specified as an array at initialization\n",
    "        self.score = 0\n",
    "        \n",
    "        self.wins = 0 #how many MUs it wins/draws/loses\n",
    "        self.losses = 0\n",
    "        self.contests = 0\n",
    "        \n",
    "        self.possWins = 0 #how many possible interactions it wins/draws/loses\n",
    "        self.possLosses = 0\n",
    "        self.possContests = 0\n",
    "        \n",
    "    def show(self): #print info for die\n",
    "        draws = self.contests - (self.wins + self.losses)\n",
    "        possDraws = self.possContests - (self.possWins + self.possLosses)\n",
    "        \n",
    "        winPercent = str(100*self.wins/self.contests)[0:6] + \"%\"\n",
    "        drawPercent = str(100*draws/self.contests)[0:6] + \"%\"\n",
    "        lossPercent = str(100*self.losses/self.contests)[0:6] + \"%\"\n",
    "        \n",
    "        possWinPercent = str(100*self.possWins/self.possContests)[0:6] + \"%\"\n",
    "        possDrawPercent = str(100*possDraws/self.possContests)[0:6] + \"%\"\n",
    "        possLossPercent = str(100*self.possLosses/self.possContests)[0:6] + \"%\"\n",
    "               \n",
    "        \n",
    "        print(self.sides,end = \"\\t\")\n",
    "        print(str(self.wins) + \"\\t\" + str(draws) + \"\\t\" + str(self.losses),end = \"\\t\")\n",
    "        print(winPercent + \"\\t\" + drawPercent + \"\\t\" + lossPercent,end = \"\\t\")\n",
    "        \n",
    "        print(str(self.possWins) + \"\\t\" + str(possDraws) + \"\\t\" + str(self.possLosses),end = \"\\t\")\n",
    "        print(possWinPercent + \"\\t\" + possDrawPercent + \"\\t\" + possLossPercent,end = \"\\t\")\n",
    "        \n",
    "        print()\n",
    "\n",
    "        \n",
    "    def play(self):\n",
    "        self.contests = self.contests + 1\n",
    "    \n",
    "    def win(self):\n",
    "        self.wins = self.wins+1\n",
    "        \n",
    "    def lose(self):\n",
    "        self.losses = self.losses+1\n",
    "        \n",
    "    def roll(self):\n",
    "        return random.choice(self.sides)\n",
    "    \n",
    "    def half(self): # divides attributes by 2 since all values are doubled when calculated\n",
    "        self.wins /= 2\n",
    "        self.losses /= 2\n",
    "        self.contests /= 2\n",
    "        \n",
    "        self.possWins /= 2\n",
    "        self.possLosses /= 2\n",
    "        self.possContests /= 2\n",
    "        \n",
    "    def clearMatches(self): # reset matches data\n",
    "        self.wins = 0\n",
    "        self.losses = 0\n",
    "        self.contests = 0\n",
    "        \n",
    "        self.possWins = 0\n",
    "        self.possLosses = 0\n",
    "        self.possContests = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AllDice:# set of dice\n",
    "    def __init__(self):\n",
    "        self.dice = [] # dice in set as array of dice\n",
    "        self.build() # build a set of every possible die\n",
    "        #self.show()\n",
    "        \n",
    "    def build(self):# every [possible 6-sided die with 21 total]\n",
    "        for a in range(4,22):# largest number in the dice can only be between 4 and 21 ([4,4,4,3,3,3] to [21,0,0,0,0,0])\n",
    "            for b in range(11):# second largest number can only be as high as 10 [11,10,0,0,0,0]\n",
    "                if a<b:\n",
    "                    break # if the 2nd number is greater than the 1st, quit out of loop\n",
    "                for c in range(8):# 3rd number goes up to 7 [7,7,7,0,0,0]\n",
    "                    if b<c:\n",
    "                        break\n",
    "                    for d in range(6):# 4th number goes to 5 [6,5,5,5,0,0]\n",
    "                        if c<d:\n",
    "                            break\n",
    "                        for e in range(5):# and so on [5,4,4,4,4,0]\n",
    "                            if d<e:\n",
    "                                break\n",
    "                            for f in range(4):# [4,4,4,3,3,3]\n",
    "                                if e<f:\n",
    "                                    break\n",
    "                                if (a+b+c+d+e+f)==21:# only add to list if numbers add to 21\n",
    "                                    self.dice.append(Die([a,b,c,d,e,f]))\n",
    "                                    \n",
    "    def show(self):# print data for every die in table-friendly manner\n",
    "        #print(len(self.dice))\n",
    "        print(\"sides\",end = \"\\t\")\n",
    "        \n",
    "        print(\"MU wins\",end = \"\\t\")\n",
    "        print(\"MU draws\",end = \"\\t\")\n",
    "        print(\"MU losses\",end = \"\\t\")\n",
    "        print(\"MU win %\",end = \"\\t\")\n",
    "        print(\"MU draw %\",end = \"\\t\")\n",
    "        print(\"MU loss %\",end = \"\\t\")\n",
    "        \n",
    "        print(\"total wins\",end = \"\\t\")\n",
    "        print(\"total draw\",end = \"\\t\")\n",
    "        print(\"total losses\",end = \"\\t\")\n",
    "        print(\"total win %\",end = \"\\t\")\n",
    "        print(\"total draws %\",end = \"\\t\")\n",
    "        print(\"total loss %\")\n",
    "        for i in self.dice:\n",
    "            i.half()\n",
    "            i.show()\n",
    "            \n",
    "    def clearMatches(self):\n",
    "        for i in self.dice:\n",
    "            i.clearMatches()       \n",
    "            \n",
    "    def fightAll(self): # analyze all dice by comparing them to each other twice\n",
    "        for i in self.dice:\n",
    "            for j in self.dice:\n",
    "                Contest(i,j)\n",
    "                \n",
    "    def limitMU(self,limit): # removes dice below a certain MU win % (not used)\n",
    "        passList = []\n",
    "        for i in self.dice:\n",
    "            if (i.wins/i.contests) >= limit:\n",
    "                passList.append(i)\n",
    "            self.dice = passList\n",
    "            \n",
    "    def limitTotal(self,limit): # removes dice below a certain possible interaction win % (not used)\n",
    "        passList = []\n",
    "        for i in self.dice:\n",
    "            if (i.possWins/i.possContests) >= limit:\n",
    "                passList.append(i)\n",
    "            self.dice = passList\n",
    "            \n",
    "    def removeObsolete(self): # removes obsolete dice (dice that win no MUs or only win MUs against other obsolete dice)\n",
    "        passList = []\n",
    "        count = 0\n",
    "        \n",
    "        for i in self.dice:\n",
    "            if i.wins > 0:\n",
    "                passList.append(i)\n",
    "            else:\n",
    "                count += 1\n",
    "                \n",
    "            self.dice = passList\n",
    "        \n",
    "        if count > 0:\n",
    "            self.clearMatches()\n",
    "            self.fightAll()\n",
    "            self.removeObsolete()\n",
    "            \n",
    "    def removeDominated(self):\n",
    "        continue\n",
    "            \n",
    "    def removeNumber(self,number):\n",
    "        passList = []\n",
    "        for d in self.dice:\n",
    "            if number not in d.sides:\n",
    "                passList.append(d)\n",
    "        self.dice = passList\n",
    "            \n",
    "    def showMUs(self,die): # print every MU within the set for a given die\n",
    "        print(die.sides,end = \"\\t\")\n",
    "        print(\"Matchups\")\n",
    "        for d in self.dice:\n",
    "            winner,margin = Contest(die,d)\n",
    "            print(d.sides,end = \"\\t\")\n",
    "            if (winner == die) or (not winner):\n",
    "                print(\"+\" + str(margin))\n",
    "            else:\n",
    "                print(\"-\" + str(margin))\n",
    "                \n",
    "    def saveMUs(self,die): # print every MU within the set for a given die into txt file\n",
    "        MUfolder = directory + \"MUs/\" # MU txt folder\n",
    "        \n",
    "        try:\n",
    "            f = open(MUfolder + str(die.sides) + \".txt\", 'w')\n",
    "            \n",
    "            f.write(\"Matchup\\tValue\\n\")\n",
    "        \n",
    "            for d in self.dice:\n",
    "                winner,margin = Contest(die,d)\n",
    "                f.write(str(d.sides) + \"\\t\")\n",
    "                if (winner == die) or (not winner):\n",
    "                    f.write(\"+\" + str(margin))\n",
    "                else:\n",
    "                    f.write(\"-\" + str(margin))\n",
    "                f.write(\"\\n\")\n",
    "                    \n",
    "        finally:\n",
    "            f.close()\n",
    "            \n",
    "    def saveAllMUs(self):\n",
    "        for d in self.dice:\n",
    "            self.saveMUs(d)\n",
    "            \n",
    "    def tableMUs(self):\n",
    "        try:\n",
    "            f = open(\"MU Table.csv\",'w')\n",
    "            \n",
    "            f.write(\"Die\")\n",
    "            \n",
    "            for d in self.dice:\n",
    "                f.write(\"\\t\" + str(d.sides))\n",
    "            \n",
    "            for d in self.dice:\n",
    "                f.write(\"\\n\")\n",
    "                f.write(str(d.sides))\n",
    "                \n",
    "                for e in self.dice:\n",
    "                    f.write(\"\\t\")\n",
    "                    winner,margin = Contest(d,e)\n",
    "                    \n",
    "                    if (winner == d) or (not winner):\n",
    "                        f.write(\"+\" + str(margin))\n",
    "                    else:\n",
    "                        f.write(\"-\" + str(margin))\n",
    "                        \n",
    "        finally:\n",
    "            f.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player: # a player within a competitive scene with a main die\n",
    "    def __init__(self,dice):\n",
    "        self.dice = dice # set of dice to choose from\n",
    "        self.mainDie = random.choice(self.dice) # start with a random main die\n",
    "        self.wins = 0\n",
    "        self.intelligent = False\n",
    "        self.attach = 5 # starting attachment value\n",
    "        self.attachCap = 500\n",
    "        self.scene = 0\n",
    "    \n",
    "    def show(self):\n",
    "        print(\"Main: \",end = \"\\t\")\n",
    "        print(self.mainDie.sides,end = \"\\t\")\n",
    "        print(self.attach)\n",
    "        \n",
    "    def showWins(self):\n",
    "        print(\"Main: \",end = \"\\t\")\n",
    "        print(self.mainDie.sides,end = \"\\t\")\n",
    "        print(self.wins)\n",
    "        \n",
    "    def changeMains(self): # pick a random new main\n",
    "        if self.intelligent:\n",
    "            self.scene.evaluateMeta()\n",
    "            topDice = []\n",
    "            topScore = 0\n",
    "            for d in self.dice:\n",
    "                if d.score >= topScore:\n",
    "                    if d.score > topScore:\n",
    "                        topScore = d.score\n",
    "                        topDice = []\n",
    "                    topDice.append(d)\n",
    "            self.mainDie = random.choice(topDice)\n",
    "            self.attach = 1\n",
    "        else:\n",
    "            self.mainDie = random.choice(self.dice)\n",
    "            self.attach = 5\n",
    "        \n",
    "         # reset attachment\n",
    "        \n",
    "    def lose(self): # if a player loses a fight, their attachment goes down\n",
    "        self.attach -= 1\n",
    "        if self.attach < 1: # change mains if attachment reaches 0\n",
    "            self.changeMains()\n",
    "    \n",
    "    def win(self):\n",
    "        if self.attach < self.attachCap: #attachment cannot exceed 1000 (done to ensure metagame does not slow down due to inertia)\n",
    "            self.attach += 1\n",
    "        \n",
    "    def roll(self): # roll its main die\n",
    "        return self.mainDie.roll()\n",
    "    \n",
    "    def chooseMain(self,die):\n",
    "        self.mainDie = die\n",
    "        \n",
    "    def winTournament(self):\n",
    "        self.wins += 1\n",
    "    \n",
    "    def makeIntelligent(self):\n",
    "        self.intelligent = True\n",
    "        self.attachCap = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Scene:# competitive scene full of players\n",
    "    def __init__(self,popSize,dice):\n",
    "        self.players = [] # players in scene\n",
    "        self.popSize = popSize # number of players in scene\n",
    "        self.dice = dice # set of dice available in scene\n",
    "        self.day = 0 # current generation (1 day per tournament)\n",
    "        \n",
    "        for i in range(self.popSize): # populate scene\n",
    "            self.players.append(Player(self.dice))\n",
    "            \n",
    "    def tournament(self): # each player fights 1 random other player\n",
    "        bracket = self.players.copy()\n",
    "        random.shuffle(bracket)\n",
    "        while len(bracket) > 0:\n",
    "            playerA = bracket.pop()\n",
    "            playerB = bracket.pop()\n",
    "            Fight(playerA,playerB)\n",
    "        \n",
    "            \n",
    "    def show(self):\n",
    "        for i in self.players:\n",
    "            i.show()\n",
    "            \n",
    "    def countDie(self,die): # count how many players currently main a given die\n",
    "        count = 0\n",
    "        for p in self.players:\n",
    "            if p.mainDie == die:\n",
    "                count += 1\n",
    "        return count\n",
    "    \n",
    "    def stabilize(self):\n",
    "        while (len(self.players) % len(self.dice)) > 0:\n",
    "            self.players.append(Player(self.dice))\n",
    "        \n",
    "        for i in range(len(self.players)):\n",
    "            j = i\n",
    "            if j >= len(self.dice):\n",
    "                j -= len(self.dice)\n",
    "            p = self.players[i]\n",
    "            d = self.dice[j]\n",
    "            p.chooseMain(d)\n",
    "            \n",
    "    def makePlayersIntelligent(self):\n",
    "        for p in self.players:\n",
    "            p.makeIntelligent()\n",
    "            p.scene = self\n",
    "            \n",
    "    def evaluateDie(self,die):\n",
    "        dieScore = 0\n",
    "        for p in self.players:\n",
    "            dieScore += matchups.at[str(die.sides),str(p.mainDie.sides)]\n",
    "        die.score = dieScore\n",
    "        return dieScore\n",
    "    \n",
    "    def evaluateMeta(self):\n",
    "        for d in self.dice:\n",
    "            dieScore = self.evaluateDie(d)\n",
    "            \n",
    "    def choosePlayerMain(self,die):\n",
    "        for p in self.players:\n",
    "            p.chooseMain(die)\n",
    "            \n",
    "    def runSceneSim(self,duration,interval): # run simulation\n",
    "        try:\n",
    "            f = open(directory + \"SimulationData.csv\", 'w')\n",
    "            \n",
    "            f.write(\"Day\\t\")\n",
    "            for d in self.dice:\n",
    "                f.write(str(d.sides))\n",
    "                f.write(\"\\t\")\n",
    "            f.write(\"\\n\")\n",
    "            percent = duration / 100\n",
    "            \n",
    "            for i in range(duration):\n",
    "#                 self.evaluateMeta()\n",
    "                self.tournament()\n",
    "                if self.day % interval == 0:\n",
    "                    f.write(str(self.day))\n",
    "                    f.write(str(\"\\t\"))\n",
    "                    for d in self.dice:\n",
    "                        f.write(str(self.countDie(d)))\n",
    "                        f.write(\"\\t\")\n",
    "                    f.write(\"\\n\")\n",
    "                self.day += 1\n",
    "                \n",
    "                if (i % percent) == 0:\n",
    "                    print(str((i/duration)*100) + \"%\")\n",
    "        finally:        \n",
    "            f.close()\n",
    "            print(\"done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bracket:\n",
    "    def __init__(self,bestOf,size,dice):\n",
    "        self.bestOf = bestOf\n",
    "        self.size = size\n",
    "        self.dice = dice\n",
    "        number = len(self.dice)\n",
    "        self.players = []\n",
    "        \n",
    "        for i in range(number):\n",
    "            self.players.append(Player(self.dice))\n",
    "            \n",
    "        for i in range(number):\n",
    "            p = self.players[i]\n",
    "            d = self.dice[i]\n",
    "            p.chooseMain(d)\n",
    "            \n",
    "    def show(self):\n",
    "        for p in self.players:\n",
    "            p.showWins()\n",
    "            \n",
    "    def tournament(self): \n",
    "        bracket = self.players.copy()\n",
    "        winBracket = []\n",
    "        loseBracket = []\n",
    "        dead = []\n",
    "        random.shuffle(bracket)\n",
    "        \n",
    "        while len(bracket) > self.size:\n",
    "            bracket.pop()\n",
    "        \n",
    "        winBracket, loseBracket = Split(bracket, self.bestOf)\n",
    "        \n",
    "        while (len(winBracket) != 1) or (len(loseBracket) != 1): \n",
    "            random.shuffle(winBracket)\n",
    "            random.shuffle(loseBracket)\n",
    "            \n",
    "            bracket = loseBracket.copy()\n",
    "            \n",
    "            loseBracket, dead = Split(bracket, self.bestOf)\n",
    "            \n",
    "            bracket = winBracket.copy()\n",
    "            winBracket, bracket = Split(bracket, self.bestOf)\n",
    "            for p in bracket:\n",
    "                loseBracket.append(p)\n",
    "\n",
    "            random.shuffle(loseBracket)\n",
    "            \n",
    "            bracket = loseBracket.copy()\n",
    "            loseBracket, dead = Split(bracket, self.bestOf)\n",
    "        \n",
    "        playerA = winBracket[0]\n",
    "        playerB = loseBracket[0]\n",
    "        \n",
    "        winner, loser = Match(playerA,playerB,self.bestOf)\n",
    "        \n",
    "        if winner == playerB:\n",
    "                winner, loser = Match(winner,loser,self.bestOf)\n",
    "        \n",
    "        winner.winTournament()\n",
    "        \n",
    "    def series(self, iterations):\n",
    "        for i in range(iterations):\n",
    "            self.tournament()\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Split(bracket, bestOf):\n",
    "    winners = []\n",
    "    losers = []\n",
    "    \n",
    "    while len(bracket) > 0:\n",
    "        playerA = bracket.pop()\n",
    "        playerB = bracket.pop()\n",
    "        winner,loser = Match(playerA,playerB,bestOf)\n",
    "        winners.append(winner)\n",
    "        losers.append(loser)\n",
    "        \n",
    "    return winners, losers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Match(playerA,playerB,bestOf):\n",
    "    \n",
    "    targetScore = (bestOf+1)/2\n",
    "    scoreA = 0\n",
    "    scoreB = 0\n",
    "    \n",
    "    while (scoreA < targetScore) and (scoreB < targetScore):\n",
    "        if Game(playerA,playerB) == playerA:\n",
    "            scoreA += 1\n",
    "        else:\n",
    "            scoreB += 1\n",
    "            \n",
    "    if scoreA == targetScore:\n",
    "        return playerA,playerB\n",
    "    else:\n",
    "        return playerB,playerA\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Game(playerA,playerB):\n",
    "    \n",
    "    rollA = playerA.roll()\n",
    "    rollB = playerB.roll()\n",
    "    \n",
    "    while rollA == rollB:    \n",
    "        rollA = playerA.roll()\n",
    "        rollB = playerB.roll()\n",
    "    \n",
    "    if rollA>rollB:\n",
    "        return playerA\n",
    "    else:\n",
    "        return playerB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulateSeries(dice, size):\n",
    "    try:\n",
    "        f = open(\"Tournament Series.txt\",'w')\n",
    "        \n",
    "        f.write(\"size\\tBest of\")\n",
    "        for d in dice:\n",
    "            f.write(\"\\t\")\n",
    "            f.write(str(d.sides))\n",
    "        f.write(\"\\n\")\n",
    "        \n",
    "        for s in range(1,9):\n",
    "            s = 2**s\n",
    "            print(s)\n",
    "            \n",
    "            for b in [1,3,5,7]:\n",
    "                bra = Bracket(b,s,everyDie.dice)\n",
    "                bra.series(size)\n",
    "                \n",
    "                f.write(str(s) + \"\\t\" + str(b))\n",
    "                \n",
    "                for p in bra.players:\n",
    "                    f.write(\"\\t\")\n",
    "                    f.write(str(p.wins))\n",
    "                f.write(\"\\n\")       \n",
    "        \n",
    "    finally:\n",
    "        print(\"done!\")\n",
    "        f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Contest(dieA,dieB): # analytical comparison between 2 dice\n",
    "    contests = 0\n",
    "    winsA = 0\n",
    "    lossA = 0\n",
    "    winsB = 0\n",
    "    lossB = 0\n",
    "    \n",
    "    dieA.play() # appends die.Contests\n",
    "    dieB.play()\n",
    "    \n",
    "    for a in dieA.sides:\n",
    "        for b in dieB.sides:\n",
    "            contests = contests + 1\n",
    "            if a>b:\n",
    "                winsA = winsA + 1\n",
    "                lossB = lossB + 1\n",
    "            elif b>a:\n",
    "                winsB = winsB + 1\n",
    "                lossA = lossA + 1\n",
    "                \n",
    "    dieA.possWins += winsA\n",
    "    dieA.possLosses += lossA\n",
    "    dieA.possContests += contests\n",
    "    \n",
    "    dieB.possWins += winsB\n",
    "    dieB.possLosses += lossB\n",
    "    dieB.possContests += contests\n",
    "    \n",
    "                \n",
    "    if winsA>winsB:\n",
    "        dieA.win()\n",
    "        dieB.lose()\n",
    "        return dieA,winsA-winsB\n",
    "    elif winsB>winsA:\n",
    "        dieA.lose()\n",
    "        dieB.win()\n",
    "        return dieB,winsB-winsA\n",
    "    else:\n",
    "        return False,0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Fight(playerA,playerB): # both players compete by rolling their main dice\n",
    "    rollA = playerA.roll()\n",
    "    rollB = playerB.roll()\n",
    "    \n",
    "    if rollA>rollB:\n",
    "        playerA.win()\n",
    "        playerB.lose()\n",
    "    elif rollB>rollA:\n",
    "        playerA.lose()\n",
    "        playerB.win()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "matchups = pd.read_csv(\"MU Table.csv\",delimiter = \"\\t\")\n",
    "matchups = matchups.set_index(\"Die\")\n",
    "matchups_np = matchups.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "matchups_good = matchups[[\"[6, 6, 6, 1, 1, 1]\", \"[6, 5, 5, 5, 0, 0]\", \"[5, 5, 5, 5, 1, 0]\", \"[7, 6, 2, 2, 2, 2]\", \"[7, 7, 2, 2, 2, 1]\", \"[5, 4, 4, 4, 4, 0]\",\"[7, 7, 4, 1, 1, 1]\", \n",
    "                          \"[4, 4, 4, 3, 3, 3]\", \"[7, 7, 7, 0, 0, 0]\", \"[6, 6, 6, 3, 0, 0]\", \"[5, 5, 5, 2, 2, 2]\", \"[4, 4, 4, 4, 4, 1]\", \"[6, 3, 3, 3, 3, 3]\"]]\n",
    "\n",
    "matchups_good = matchups_good.loc[[\"[6, 6, 6, 1, 1, 1]\", \"[6, 5, 5, 5, 0, 0]\", \"[5, 5, 5, 5, 1, 0]\", \"[7, 6, 2, 2, 2, 2]\", \"[7, 7, 2, 2, 2, 1]\", \"[5, 4, 4, 4, 4, 0]\",\"[7, 7, 4, 1, 1, 1]\",\n",
    "                                   \"[4, 4, 4, 3, 3, 3]\", \"[7, 7, 7, 0, 0, 0]\", \"[6, 6, 6, 3, 0, 0]\", \"[5, 5, 5, 2, 2, 2]\", \"[4, 4, 4, 4, 4, 1]\", \"[6, 3, 3, 3, 3, 3]\"]]\n",
    "\n",
    "np_good = matchups_good.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "test1 = np.array([[0,30,-30,-10],[-30,0,30,-10],[30,-30,0,1],[10,10,-1,0]])\n",
    "test2 = np.array([[0,30,-30],[-30,0,30],[30,-30,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "testGame = nash.Game(test1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Zero sum game with payoff matrices:\n",
       "\n",
       "Row player:\n",
       "[[  0  30 -30 -10]\n",
       " [-30   0  30 -10]\n",
       " [ 30 -30   0   1]\n",
       " [ 10  10  -1   0]]\n",
       "\n",
       "Column player:\n",
       "[[  0 -30  30  10]\n",
       " [ 30   0 -30  10]\n",
       " [-30  30   0  -1]\n",
       " [-10 -10   1   0]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testGame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(array([-2.60208521e-17,  2.43902439e-02,  2.43902439e-01,  7.31707317e-01]), array([-2.60208521e-17,  2.43902439e-02,  2.43902439e-01,  7.31707317e-01]))]\n",
      "0.0910487174987793\n"
     ]
    }
   ],
   "source": [
    "startTime = time.time()\n",
    "eqs = testGame.vertex_enumeration()\n",
    "print(list(eqs))\n",
    "endTime = time.time()\n",
    "print(endTime-startTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   9,   9,  -9,  -9,   6,  -3,   0,   0,   3,   0,   3,  -3],\n",
       "       [ -9,   0,   2,  -3,  -4,  11,  -4,  12,  -6,  -5,   3,  12,   5],\n",
       "       [ -9,  -2,   0,  -4,  -3,  11,  -1,  12,  -3,  -6,   0,  13,   4],\n",
       "       [  9,   3,   4,   0,   2,  -4,   6, -12,   3,   1,   0,  -4, -13],\n",
       "       [  9,   4,   3,  -2,   0,  -4,   5, -12,   6,   4,  -3,  -5, -12],\n",
       "       [ -6, -11, -11,   4,   4,   0,   0,  12,  -3,  -4,  -3,   4,  14],\n",
       "       [  3,   4,   1,  -6,  -5,   0,   0,  -3,   6,   6,  -6,  -2,  -2],\n",
       "       [  0, -12, -12,  12,  12, -12,   3,   0,   0,  -3,   0,  -9,   9],\n",
       "       [  0,   6,   3,  -3,  -6,   3,  -6,   0,   0,   6,   0,   0,   0],\n",
       "       [ -3,   5,   6,  -1,  -4,   4,  -6,   3,  -6,   0,   6,   2,   2],\n",
       "       [  0,  -3,   0,   0,   3,   3,   6,   0,   0,  -6,   0,   6,  -6],\n",
       "       [ -3, -12, -13,   4,   5,  -4,   2,   9,   0,  -2,  -6,   0,  14],\n",
       "       [  3,  -5,  -4,  13,  12, -14,   2,  -9,   0,  -2,   6, -14,   0]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_good"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "subSize = 20\n",
    "sub_matchups = matchups_np[:subSize,:subSize]\n",
    "#print(sub_matchups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "diceGame = nash.Game(matchups_np)\n",
    "diceGameSub = nash.Game(sub_matchups)\n",
    "diceGameGood = nash.Game(np_good)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(array([1.65625000e-01, 5.12874767e-17, 1.40625000e-01, 1.03125000e-01,\n",
      "       1.12500000e-01, 1.87500000e-01, 0.00000000e+00, 8.35188782e-18,\n",
      "       1.40625000e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.50000000e-01]), array([1.65625000e-01, 5.12874767e-17, 1.40625000e-01, 1.03125000e-01,\n",
      "       1.12500000e-01, 1.87500000e-01, 0.00000000e+00, 8.35188782e-18,\n",
      "       1.40625000e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.50000000e-01])), (array([1.37500000e-01, 2.46716228e-17, 1.87500000e-01, 1.87500000e-01,\n",
      "       1.33860661e-16, 1.20439373e-17, 0.00000000e+00, 2.26192887e-17,\n",
      "       1.87500000e-01, 0.00000000e+00, 0.00000000e+00, 1.50000000e-01,\n",
      "       1.50000000e-01]), array([ 2.39006346e-17,  1.07142857e-01,  1.07142857e-01, -0.00000000e+00,\n",
      "        2.50000000e-01,  3.25260652e-18,  1.25000000e-01,  1.78571429e-01,\n",
      "        0.00000000e+00,  2.14285714e-01,  0.00000000e+00,  1.78571429e-02,\n",
      "        0.00000000e+00])), (array([1.07142857e-01, 6.01370805e-17, 1.78571429e-01, 3.27606794e-17,\n",
      "       2.50000000e-01, 3.57142857e-02, 4.45289782e-18, 2.02380952e-01,\n",
      "       8.33333333e-02, 1.42857143e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([ 4.93432455e-17,  7.50000000e-02,  1.25000000e-01, -0.00000000e+00,\n",
      "        2.50000000e-01,  2.50000000e-02,  1.25000000e-01,  1.75000000e-01,\n",
      "        0.00000000e+00,  2.25000000e-01,  0.00000000e+00,  0.00000000e+00,\n",
      "        0.00000000e+00])), (array([ 2.31296463e-18,  1.07142857e-01,  1.07142857e-01, -0.00000000e+00,\n",
      "        2.50000000e-01,  6.04055496e-18,  1.25000000e-01,  1.78571429e-01,\n",
      "        0.00000000e+00,  2.14285714e-01,  0.00000000e+00,  1.78571429e-02,\n",
      "        0.00000000e+00]), array([2.10736778e-17, 1.54197642e-18, 1.53061224e-01, 1.87500000e-01,\n",
      "       1.41269116e-17, 1.37755102e-01, 1.98979592e-01, 3.84679377e-18,\n",
      "       5.48469388e-02, 1.47321429e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.20535714e-01])), (array([1.57607753e-01, 9.62069639e-02, 6.84697771e-02, 3.09697771e-02,\n",
      "       2.08706964e-01, 1.87500000e-01, 0.00000000e+00, 1.09546948e-17,\n",
      "       1.00538765e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.50000000e-01]), array([1.57607753e-01, 9.62069639e-02, 6.84697771e-02, 3.09697771e-02,\n",
      "       2.08706964e-01, 1.87500000e-01, 0.00000000e+00, 1.09546948e-17,\n",
      "       1.00538765e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.50000000e-01])), (array([1.35589111e-01, 1.38429038e-01, 8.36782216e-02, 1.87500000e-01,\n",
      "       4.63751387e-17, 1.13968132e-17, 8.65181486e-02, 2.21160617e-01,\n",
      "       1.29821234e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.73036297e-02]), array([2.64705953e-17, 6.01370805e-17, 1.50891805e-01, 1.07773831e-01,\n",
      "       1.06301559e-01, 1.46432780e-01, 1.64268879e-01, 1.02852862e-17,\n",
      "       3.36950980e-02, 1.75795060e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.14840988e-01])), (array([1.38843819e-01, 1.94354304e-01, 9.57913517e-17, 1.86925305e-17,\n",
      "       2.50000000e-01, 1.66937087e-01, 2.78228479e-02, 1.81429343e-02,\n",
      "       6.47847681e-02, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.39114239e-01]), array([2.12073036e-01, 6.06831427e-02, 7.67078321e-17, 4.55123570e-02,\n",
      "       9.80883210e-17, 3.53807689e-18, 3.79269642e-02, 2.37357679e-01,\n",
      "       2.09544572e-01, 0.00000000e+00, 1.89316857e-01, 0.00000000e+00,\n",
      "       7.58539284e-03])), (array([1.84205270e-01, 2.31296463e-17, 1.80439864e-01, 1.74791756e-01,\n",
      "       1.69443255e-02, 2.82405424e-02, 0.00000000e+00, 2.12345943e-01,\n",
      "       1.80439864e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       2.25924339e-02]), array([1.84205270e-01, 2.31296463e-17, 1.80439864e-01, 1.74791756e-01,\n",
      "       1.69443255e-02, 2.82405424e-02, 0.00000000e+00, 2.12345943e-01,\n",
      "       1.80439864e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       2.25924339e-02])), (array([1.28923633e-01, 1.99408990e-17, 1.40625000e-01, 2.05469245e-02,\n",
      "       2.22604101e-01, 1.87500000e-01, 0.00000000e+00, 3.52147703e-17,\n",
      "       9.47482914e-02, 6.88150629e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.36236987e-01]), array([1.44182164e-01, 9.24907710e-17, 1.76363059e-01, 1.67453507e-01,\n",
      "       2.67286578e-02, 4.45477630e-02, 0.00000000e+00, 3.02821972e-17,\n",
      "       1.76363059e-01, 0.00000000e+00, 0.00000000e+00, 1.14361790e-01,\n",
      "       1.50000000e-01])), (array([1.46373547e-01, 4.78012691e-17, 1.72710756e-01, 1.60879360e-01,\n",
      "       3.54941860e-02, 5.91569767e-02, 0.00000000e+00, 1.93627085e-17,\n",
      "       1.72710756e-01, 0.00000000e+00, 0.00000000e+00, 1.02674419e-01,\n",
      "       1.50000000e-01]), array([2.37171095e-01, 2.16405561e-16, 3.84867161e-02, 3.84867161e-02,\n",
      "       9.27813368e-17, 6.29000673e-18, 1.07552856e-16, 2.50000000e-01,\n",
      "       2.37171095e-01, 0.00000000e+00, 1.98684379e-01, 0.00000000e+00,\n",
      "       0.00000000e+00])), (array([1.44182164e-01, 9.24907710e-17, 1.76363059e-01, 1.67453507e-01,\n",
      "       2.67286578e-02, 4.45477630e-02, 0.00000000e+00, 3.02821972e-17,\n",
      "       1.76363059e-01, 0.00000000e+00, 0.00000000e+00, 1.14361790e-01,\n",
      "       1.50000000e-01]), array([1.28923633e-01, 1.99408990e-17, 1.40625000e-01, 2.05469245e-02,\n",
      "       2.22604101e-01, 1.87500000e-01, 0.00000000e+00, 3.52147703e-17,\n",
      "       9.47482914e-02, 6.88150629e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.36236987e-01])), (array([1.68827095e-01, 1.07938350e-17, 5.06615720e-02, 9.35187148e-02,\n",
      "       0.00000000e+00, 1.71428571e-01, 6.42857143e-02, 1.87834091e-18,\n",
      "       1.75969952e-01, 0.00000000e+00, 1.25308380e-01, 0.00000000e+00,\n",
      "       1.50000000e-01]), array([2.06677865e-01, 4.95623882e-20, 3.24916009e-02, 6.47558541e-17,\n",
      "       9.74748027e-02, 1.62458005e-01, 3.40728123e-19, 3.33893272e-02,\n",
      "       1.85016798e-01, 0.00000000e+00, 1.52525197e-01, 0.00000000e+00,\n",
      "       1.29966404e-01])), (array([2.37239324e-01, 2.75628286e-17, 1.59508453e-02, 2.16968484e-17,\n",
      "       2.23311834e-02, 3.19016905e-03, 3.06996055e-17, 2.45746441e-01,\n",
      "       2.35112544e-01, 1.27606762e-02, 2.27668817e-01, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([1.85037171e-17, 2.50000000e-01, 4.20159591e-18, 1.19407895e-01,\n",
      "       9.07894737e-02, 1.58454678e-17, 2.19736842e-01, 1.76754386e-01,\n",
      "       3.17982456e-03, 1.20230263e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.99013158e-02])), (array([1.54197642e-17, 2.50000000e-01, 2.61730209e-17, 1.87500000e-01,\n",
      "       1.55086707e-17, 1.09846824e-17, 2.16371531e-01, 9.73380974e-03,\n",
      "       4.32523129e-02, 6.01215307e-02, 0.00000000e+00, 1.00885408e-01,\n",
      "       1.32135408e-01]), array([1.50938749e-01, 8.63506797e-17, 1.42723036e-01, 1.47183753e-01,\n",
      "       5.37549954e-02, 1.79107856e-01, 3.35685741e-02, 1.37552712e-17,\n",
      "       1.42723036e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       1.50000000e-01])), (array([0.1691001 , 0.14057521, 0.06774294, 0.05628243, 0.17495676,\n",
      "       0.05730259, 0.        , 0.17359655, 0.11460135, 0.        ,\n",
      "       0.        , 0.        , 0.04584207]), array([1.74569392e-01, 4.98863790e-02, 1.50085216e-01, 1.72645412e-01,\n",
      "       1.98061172e-02, 2.25944979e-19, 1.88001636e-02, 2.43733279e-01,\n",
      "       1.66714009e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       3.76003273e-03])), (array([0.18074397, 0.02128139, 0.160862  , 0.15232044, 0.04690608,\n",
      "       0.04270781, 0.        , 0.19305625, 0.1679558 , 0.        ,\n",
      "       0.        , 0.        , 0.03416625]), array([2.23586581e-17, 8.89981227e-02, 5.32865108e-02, 5.32865108e-02,\n",
      "       8.89981227e-02, 2.26014865e-17, 2.02571789e-01, 1.82476070e-01,\n",
      "       3.78578887e-02, 2.02571789e-01, 8.99531963e-02, 0.00000000e+00,\n",
      "       0.00000000e+00])), (array([1.58612877e-01, 1.82292369e-01, 5.07807234e-02, 5.07807234e-02,\n",
      "       1.82292369e-01, 8.49766326e-18, 1.36960927e-02, 2.45434636e-01,\n",
      "       1.02414118e-01, 1.36960927e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([1.58612877e-01, 1.82292369e-01, 5.07807234e-02, 5.07807234e-02,\n",
      "       1.82292369e-01, 8.49766326e-18, 1.36960927e-02, 2.45434636e-01,\n",
      "       1.02414118e-01, 1.36960927e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00])), (array([1.47715211e-01, 5.68106533e-02, 1.44892010e-01, 1.44892010e-01,\n",
      "       5.68106533e-02, 1.09271015e-18, 3.50505679e-02, 2.38316477e-01,\n",
      "       1.40461849e-01, 3.50505679e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([1.62175633e-01, 1.50584140e-01, 7.45618950e-02, 7.45618950e-02,\n",
      "       1.50584140e-01, 1.16207842e-17, 0.00000000e+00, 1.86121555e-01,\n",
      "       1.24756608e-01, 0.00000000e+00, 0.00000000e+00, 3.83270669e-02,\n",
      "       3.83270669e-02])), (array([1.74569392e-01, 4.98863790e-02, 1.50085216e-01, 1.72645412e-01,\n",
      "       1.98061172e-02, 2.25944979e-19, 1.88001636e-02, 2.43733279e-01,\n",
      "       1.66714009e-01, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
      "       3.76003273e-03]), array([0.1691001 , 0.14057521, 0.06774294, 0.05628243, 0.17495676,\n",
      "       0.05730259, 0.        , 0.17359655, 0.11460135, 0.        ,\n",
      "       0.        , 0.        , 0.04584207])), (array([1.62175633e-01, 1.50584140e-01, 7.45618950e-02, 7.45618950e-02,\n",
      "       1.50584140e-01, 1.16207842e-17, 0.00000000e+00, 1.86121555e-01,\n",
      "       1.24756608e-01, 0.00000000e+00, 0.00000000e+00, 3.83270669e-02,\n",
      "       3.83270669e-02]), array([1.47715211e-01, 5.68106533e-02, 1.44892010e-01, 1.44892010e-01,\n",
      "       5.68106533e-02, 1.09271015e-18, 3.50505679e-02, 2.38316477e-01,\n",
      "       1.40461849e-01, 3.50505679e-02, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00])), (array([1.84179518e-01, 2.08681478e-02, 1.71848889e-01, 1.71848889e-01,\n",
      "       2.08681478e-02, 1.98084318e-19, 0.00000000e+00, 2.42092652e-01,\n",
      "       1.78804938e-01, 0.00000000e+00, 0.00000000e+00, 4.74440877e-03,\n",
      "       4.74440877e-03]), array([1.87511714e-01, 3.74648582e-02, 3.36492084e-02, 4.92852127e-17,\n",
      "       1.44573750e-01, 1.86729842e-01, 3.08063328e-03, 7.91865110e-18,\n",
      "       1.51563744e-01, 0.00000000e+00, 1.05426250e-01, 0.00000000e+00,\n",
      "       1.50000000e-01])), (array([1.67918427e-01, 3.09731946e-02, 1.64270104e-01, 1.87500000e-01,\n",
      "       5.05928335e-17, 4.22354317e-18, 1.93582466e-02, 2.03714125e-01,\n",
      "       1.74594502e-01, 0.00000000e+00, 0.00000000e+00, 2.38998759e-02,\n",
      "       2.77715252e-02]), array([0.1757835 , 0.10740637, 0.10101815, 0.09627649, 0.12163135,\n",
      "       0.02370831, 0.        , 0.21838892, 0.13682027, 0.        ,\n",
      "       0.        , 0.        , 0.01896665])), (array([9.92374527e-02, 1.00849505e-01, 1.06536068e-01, 7.21751106e-18,\n",
      "       2.50000000e-01, 2.13072136e-02, 3.19171914e-02, 2.10951318e-01,\n",
      "       6.20552057e-02, 1.17146046e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([5.51256571e-17, 1.48732122e-02, 1.05464799e-01, 1.16619708e-01,\n",
      "       1.92201429e-18, 8.93084581e-18, 2.14845067e-01, 1.78384978e-01,\n",
      "       6.78967193e-02, 2.05549309e-01, 9.45070557e-02, 0.00000000e+00,\n",
      "       1.85915153e-03])), (array([1.87511714e-01, 3.74648582e-02, 3.36492084e-02, 4.92852127e-17,\n",
      "       1.44573750e-01, 1.86729842e-01, 3.08063328e-03, 7.91865110e-18,\n",
      "       1.51563744e-01, 0.00000000e+00, 1.05426250e-01, 0.00000000e+00,\n",
      "       1.50000000e-01]), array([1.84179518e-01, 2.08681478e-02, 1.71848889e-01, 1.71848889e-01,\n",
      "       2.08681478e-02, 1.98084318e-19, 0.00000000e+00, 2.42092652e-01,\n",
      "       1.78804938e-01, 0.00000000e+00, 0.00000000e+00, 4.74440877e-03,\n",
      "       4.74440877e-03])), (array([9.30193519e-02, 2.13703454e-01, 4.19909986e-18, 1.07238490e-01,\n",
      "       1.07015346e-01, 1.08889638e-01, 1.07513682e-01, 5.11133454e-18,\n",
      "       7.12344846e-02, 0.00000000e+00, 0.00000000e+00, 4.13855529e-02,\n",
      "       1.50000000e-01]), array([1.56642283e-17, 5.40443668e-17, 1.59774374e-01, 7.07626971e-02,\n",
      "       1.55649737e-01, 1.10902503e-01, 1.44858630e-01, 5.38437865e-02,\n",
      "       2.60735232e-02, 2.00551277e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       7.75834728e-02])), (array([8.47132571e-02, 2.50000000e-01, 1.54197642e-17, 1.62561285e-01,\n",
      "       3.32516204e-02, 3.35323172e-18, 1.35467737e-01, 1.11168427e-01,\n",
      "       8.33333333e-02, 0.00000000e+00, 0.00000000e+00, 5.62053965e-02,\n",
      "       8.32989439e-02]), array([1.90436332e-01, 1.77327289e-17, 1.11912349e-01, 8.96527965e-02,\n",
      "       6.67786563e-02, 1.11297760e-01, 0.00000000e+00, 1.01602986e-01,\n",
      "       1.75596630e-01, 0.00000000e+00, 6.36842818e-02, 0.00000000e+00,\n",
      "       8.90382083e-02])), (array([1.43228780e-01, 2.31296463e-17, 1.50877621e-01, 1.70313661e-01,\n",
      "       2.29151181e-02, 1.46489517e-01, 4.06116199e-02, 8.05805244e-18,\n",
      "       1.50877621e-01, 0.00000000e+00, 0.00000000e+00, 2.46860628e-02,\n",
      "       1.50000000e-01]), array([3.95082019e-02, 1.53504082e-17, 1.79962153e-01, 1.87500000e-01,\n",
      "       4.12556319e-17, 3.01513888e-02, 1.50504414e-01, 1.59630010e-01,\n",
      "       8.71637241e-02, 1.39197643e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       2.63824652e-02])), (array([2.23586581e-17, 8.89981227e-02, 5.32865108e-02, 5.32865108e-02,\n",
      "       8.89981227e-02, 2.26014865e-17, 2.02571789e-01, 1.82476070e-01,\n",
      "       3.78578887e-02, 2.02571789e-01, 8.99531963e-02, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([0.18074397, 0.02128139, 0.160862  , 0.15232044, 0.04690608,\n",
      "       0.04270781, 0.        , 0.19305625, 0.1679558 , 0.        ,\n",
      "       0.        , 0.        , 0.03416625])), (array([1.56642283e-17, 5.40443668e-17, 1.59774374e-01, 7.07626971e-02,\n",
      "       1.55649737e-01, 1.10902503e-01, 1.44858630e-01, 5.38437865e-02,\n",
      "       2.60735232e-02, 2.00551277e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       7.75834728e-02]), array([9.30193519e-02, 2.13703454e-01, 4.19909986e-18, 1.07238490e-01,\n",
      "       1.07015346e-01, 1.08889638e-01, 1.07513682e-01, 5.11133454e-18,\n",
      "       7.12344846e-02, 0.00000000e+00, 0.00000000e+00, 4.13855529e-02,\n",
      "       1.50000000e-01])), (array([1.41441328e-01, 4.73465099e-02, 1.17947273e-01, 1.28329507e-01,\n",
      "       7.88939905e-02, 1.36171380e-01, 3.13470921e-02, 4.96754029e-17,\n",
      "       1.33729443e-01, 0.00000000e+00, 0.00000000e+00, 3.47934777e-02,\n",
      "       1.50000000e-01]), array([6.16790569e-18, 2.67492877e-02, 1.15600522e-01, 7.06398122e-03,\n",
      "       1.78700445e-01, 2.17073083e-02, 1.51899677e-01, 1.70423697e-01,\n",
      "       2.72452577e-02, 2.38728910e-01, 6.18809129e-02, 0.00000000e+00,\n",
      "       0.00000000e+00])), (array([3.66508040e-02, 4.87982399e-02, 1.50901320e-01, 1.03991281e-01,\n",
      "       1.11344959e-01, 3.10387863e-18, 1.23327656e-01, 1.95860215e-01,\n",
      "       5.88878296e-02, 1.62419356e-01, 0.00000000e+00, 7.81833986e-03,\n",
      "       0.00000000e+00]), array([2.39284111e-02, 1.46119542e-01, 7.79103433e-02, 8.24215221e-02,\n",
      "       1.40104637e-01, 1.86423466e-18, 1.53399929e-01, 1.98866690e-01,\n",
      "       2.68564487e-02, 1.49640613e-01, 0.00000000e+00, 0.00000000e+00,\n",
      "       7.51863141e-04])), (array([6.16790569e-18, 2.67492877e-02, 1.15600522e-01, 7.06398122e-03,\n",
      "       1.78700445e-01, 2.17073083e-02, 1.51899677e-01, 1.70423697e-01,\n",
      "       2.72452577e-02, 2.38728910e-01, 6.18809129e-02, 0.00000000e+00,\n",
      "       0.00000000e+00]), array([1.41441328e-01, 4.73465099e-02, 1.17947273e-01, 1.28329507e-01,\n",
      "       7.88939905e-02, 1.36171380e-01, 3.13470921e-02, 4.96754029e-17,\n",
      "       1.33729443e-01, 0.00000000e+00, 0.00000000e+00, 3.47934777e-02,\n",
      "       1.50000000e-01]))]\n",
      "13060.861739635468\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sergio\\anaconda3\\lib\\site-packages\\nashpy\\algorithms\\support_enumeration.py:247: RuntimeWarning: \n",
      "An even number of (32) equilibria was returned. This\n",
      "indicates that the game is degenerate. Consider using another algorithm\n",
      "to investigate.\n",
      "                  \n",
      "  warnings.warn(warning, RuntimeWarning)\n"
     ]
    }
   ],
   "source": [
    "startTime = time.time()\n",
    "eqs = diceGameGood.support_enumeration()\n",
    "print(list(eqs))\n",
    "endTime = time.time()\n",
    "print(endTime-startTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object support_enumeration at 0x000001E4F8491A50>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eqs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>[6, 6, 6, 1, 1, 1]</th>\n",
       "      <th>[6, 5, 5, 5, 0, 0]</th>\n",
       "      <th>[5, 5, 5, 5, 1, 0]</th>\n",
       "      <th>[7, 6, 2, 2, 2, 2]</th>\n",
       "      <th>[7, 7, 2, 2, 2, 1]</th>\n",
       "      <th>[5, 4, 4, 4, 4, 0]</th>\n",
       "      <th>[7, 7, 4, 1, 1, 1]</th>\n",
       "      <th>[4, 4, 4, 3, 3, 3]</th>\n",
       "      <th>[7, 7, 7, 0, 0, 0]</th>\n",
       "      <th>[6, 6, 6, 3, 0, 0]</th>\n",
       "      <th>[5, 5, 5, 2, 2, 2]</th>\n",
       "      <th>[4, 4, 4, 4, 4, 1]</th>\n",
       "      <th>[6, 3, 3, 3, 3, 3]</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Die</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>[6, 6, 6, 1, 1, 1]</th>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>-9</td>\n",
       "      <td>-9</td>\n",
       "      <td>6</td>\n",
       "      <td>-3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>-3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[6, 5, 5, 5, 0, 0]</th>\n",
       "      <td>-9</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>-3</td>\n",
       "      <td>-4</td>\n",
       "      <td>11</td>\n",
       "      <td>-4</td>\n",
       "      <td>12</td>\n",
       "      <td>-6</td>\n",
       "      <td>-5</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[5, 5, 5, 5, 1, 0]</th>\n",
       "      <td>-9</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>-4</td>\n",
       "      <td>-3</td>\n",
       "      <td>11</td>\n",
       "      <td>-1</td>\n",
       "      <td>12</td>\n",
       "      <td>-3</td>\n",
       "      <td>-6</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[7, 6, 2, 2, 2, 2]</th>\n",
       "      <td>9</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>-4</td>\n",
       "      <td>6</td>\n",
       "      <td>-12</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>-4</td>\n",
       "      <td>-13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[7, 7, 2, 2, 2, 1]</th>\n",
       "      <td>9</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>-4</td>\n",
       "      <td>5</td>\n",
       "      <td>-12</td>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "      <td>-3</td>\n",
       "      <td>-5</td>\n",
       "      <td>-12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[5, 4, 4, 4, 4, 0]</th>\n",
       "      <td>-6</td>\n",
       "      <td>-11</td>\n",
       "      <td>-11</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>12</td>\n",
       "      <td>-3</td>\n",
       "      <td>-4</td>\n",
       "      <td>-3</td>\n",
       "      <td>4</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[7, 7, 4, 1, 1, 1]</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>-6</td>\n",
       "      <td>-5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>-6</td>\n",
       "      <td>-2</td>\n",
       "      <td>-2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[4, 4, 4, 3, 3, 3]</th>\n",
       "      <td>0</td>\n",
       "      <td>-12</td>\n",
       "      <td>-12</td>\n",
       "      <td>12</td>\n",
       "      <td>12</td>\n",
       "      <td>-12</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "      <td>0</td>\n",
       "      <td>-9</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[7, 7, 7, 0, 0, 0]</th>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "      <td>-3</td>\n",
       "      <td>-6</td>\n",
       "      <td>3</td>\n",
       "      <td>-6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[6, 6, 6, 3, 0, 0]</th>\n",
       "      <td>-3</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>-1</td>\n",
       "      <td>-4</td>\n",
       "      <td>4</td>\n",
       "      <td>-6</td>\n",
       "      <td>3</td>\n",
       "      <td>-6</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[5, 5, 5, 2, 2, 2]</th>\n",
       "      <td>0</td>\n",
       "      <td>-3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-6</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>-6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[4, 4, 4, 4, 4, 1]</th>\n",
       "      <td>-3</td>\n",
       "      <td>-12</td>\n",
       "      <td>-13</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>-4</td>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>-6</td>\n",
       "      <td>0</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>[6, 3, 3, 3, 3, 3]</th>\n",
       "      <td>3</td>\n",
       "      <td>-5</td>\n",
       "      <td>-4</td>\n",
       "      <td>13</td>\n",
       "      <td>12</td>\n",
       "      <td>-14</td>\n",
       "      <td>2</td>\n",
       "      <td>-9</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>6</td>\n",
       "      <td>-14</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    [6, 6, 6, 1, 1, 1]  [6, 5, 5, 5, 0, 0]  \\\n",
       "Die                                                          \n",
       "[6, 6, 6, 1, 1, 1]                   0                   9   \n",
       "[6, 5, 5, 5, 0, 0]                  -9                   0   \n",
       "[5, 5, 5, 5, 1, 0]                  -9                  -2   \n",
       "[7, 6, 2, 2, 2, 2]                   9                   3   \n",
       "[7, 7, 2, 2, 2, 1]                   9                   4   \n",
       "[5, 4, 4, 4, 4, 0]                  -6                 -11   \n",
       "[7, 7, 4, 1, 1, 1]                   3                   4   \n",
       "[4, 4, 4, 3, 3, 3]                   0                 -12   \n",
       "[7, 7, 7, 0, 0, 0]                   0                   6   \n",
       "[6, 6, 6, 3, 0, 0]                  -3                   5   \n",
       "[5, 5, 5, 2, 2, 2]                   0                  -3   \n",
       "[4, 4, 4, 4, 4, 1]                  -3                 -12   \n",
       "[6, 3, 3, 3, 3, 3]                   3                  -5   \n",
       "\n",
       "                    [5, 5, 5, 5, 1, 0]  [7, 6, 2, 2, 2, 2]  \\\n",
       "Die                                                          \n",
       "[6, 6, 6, 1, 1, 1]                   9                  -9   \n",
       "[6, 5, 5, 5, 0, 0]                   2                  -3   \n",
       "[5, 5, 5, 5, 1, 0]                   0                  -4   \n",
       "[7, 6, 2, 2, 2, 2]                   4                   0   \n",
       "[7, 7, 2, 2, 2, 1]                   3                  -2   \n",
       "[5, 4, 4, 4, 4, 0]                 -11                   4   \n",
       "[7, 7, 4, 1, 1, 1]                   1                  -6   \n",
       "[4, 4, 4, 3, 3, 3]                 -12                  12   \n",
       "[7, 7, 7, 0, 0, 0]                   3                  -3   \n",
       "[6, 6, 6, 3, 0, 0]                   6                  -1   \n",
       "[5, 5, 5, 2, 2, 2]                   0                   0   \n",
       "[4, 4, 4, 4, 4, 1]                 -13                   4   \n",
       "[6, 3, 3, 3, 3, 3]                  -4                  13   \n",
       "\n",
       "                    [7, 7, 2, 2, 2, 1]  [5, 4, 4, 4, 4, 0]  \\\n",
       "Die                                                          \n",
       "[6, 6, 6, 1, 1, 1]                  -9                   6   \n",
       "[6, 5, 5, 5, 0, 0]                  -4                  11   \n",
       "[5, 5, 5, 5, 1, 0]                  -3                  11   \n",
       "[7, 6, 2, 2, 2, 2]                   2                  -4   \n",
       "[7, 7, 2, 2, 2, 1]                   0                  -4   \n",
       "[5, 4, 4, 4, 4, 0]                   4                   0   \n",
       "[7, 7, 4, 1, 1, 1]                  -5                   0   \n",
       "[4, 4, 4, 3, 3, 3]                  12                 -12   \n",
       "[7, 7, 7, 0, 0, 0]                  -6                   3   \n",
       "[6, 6, 6, 3, 0, 0]                  -4                   4   \n",
       "[5, 5, 5, 2, 2, 2]                   3                   3   \n",
       "[4, 4, 4, 4, 4, 1]                   5                  -4   \n",
       "[6, 3, 3, 3, 3, 3]                  12                 -14   \n",
       "\n",
       "                    [7, 7, 4, 1, 1, 1]  [4, 4, 4, 3, 3, 3]  \\\n",
       "Die                                                          \n",
       "[6, 6, 6, 1, 1, 1]                  -3                   0   \n",
       "[6, 5, 5, 5, 0, 0]                  -4                  12   \n",
       "[5, 5, 5, 5, 1, 0]                  -1                  12   \n",
       "[7, 6, 2, 2, 2, 2]                   6                 -12   \n",
       "[7, 7, 2, 2, 2, 1]                   5                 -12   \n",
       "[5, 4, 4, 4, 4, 0]                   0                  12   \n",
       "[7, 7, 4, 1, 1, 1]                   0                  -3   \n",
       "[4, 4, 4, 3, 3, 3]                   3                   0   \n",
       "[7, 7, 7, 0, 0, 0]                  -6                   0   \n",
       "[6, 6, 6, 3, 0, 0]                  -6                   3   \n",
       "[5, 5, 5, 2, 2, 2]                   6                   0   \n",
       "[4, 4, 4, 4, 4, 1]                   2                   9   \n",
       "[6, 3, 3, 3, 3, 3]                   2                  -9   \n",
       "\n",
       "                    [7, 7, 7, 0, 0, 0]  [6, 6, 6, 3, 0, 0]  \\\n",
       "Die                                                          \n",
       "[6, 6, 6, 1, 1, 1]                   0                   3   \n",
       "[6, 5, 5, 5, 0, 0]                  -6                  -5   \n",
       "[5, 5, 5, 5, 1, 0]                  -3                  -6   \n",
       "[7, 6, 2, 2, 2, 2]                   3                   1   \n",
       "[7, 7, 2, 2, 2, 1]                   6                   4   \n",
       "[5, 4, 4, 4, 4, 0]                  -3                  -4   \n",
       "[7, 7, 4, 1, 1, 1]                   6                   6   \n",
       "[4, 4, 4, 3, 3, 3]                   0                  -3   \n",
       "[7, 7, 7, 0, 0, 0]                   0                   6   \n",
       "[6, 6, 6, 3, 0, 0]                  -6                   0   \n",
       "[5, 5, 5, 2, 2, 2]                   0                  -6   \n",
       "[4, 4, 4, 4, 4, 1]                   0                  -2   \n",
       "[6, 3, 3, 3, 3, 3]                   0                  -2   \n",
       "\n",
       "                    [5, 5, 5, 2, 2, 2]  [4, 4, 4, 4, 4, 1]  [6, 3, 3, 3, 3, 3]  \n",
       "Die                                                                             \n",
       "[6, 6, 6, 1, 1, 1]                   0                   3                  -3  \n",
       "[6, 5, 5, 5, 0, 0]                   3                  12                   5  \n",
       "[5, 5, 5, 5, 1, 0]                   0                  13                   4  \n",
       "[7, 6, 2, 2, 2, 2]                   0                  -4                 -13  \n",
       "[7, 7, 2, 2, 2, 1]                  -3                  -5                 -12  \n",
       "[5, 4, 4, 4, 4, 0]                  -3                   4                  14  \n",
       "[7, 7, 4, 1, 1, 1]                  -6                  -2                  -2  \n",
       "[4, 4, 4, 3, 3, 3]                   0                  -9                   9  \n",
       "[7, 7, 7, 0, 0, 0]                   0                   0                   0  \n",
       "[6, 6, 6, 3, 0, 0]                   6                   2                   2  \n",
       "[5, 5, 5, 2, 2, 2]                   0                   6                  -6  \n",
       "[4, 4, 4, 4, 4, 1]                  -6                   0                  14  \n",
       "[6, 3, 3, 3, 3, 3]                   6                 -14                   0  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matchups_good"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# everyDie = AllDice()\n",
    "dice = AllDice() # generate dice\n",
    "\n",
    "# dice.fightAll()\n",
    "# dice.removeObsolete()\n",
    "#dice.show() # set of non-obsolete dice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# b = Bracket(5,256,everyDie.dice)\n",
    "# b.series(100000)\n",
    "# simulateSeries(everyDie.dice,100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compScene = Scene(500,dice.dice) # generate scene of players\n",
    "compScene.stabilize()\n",
    "# compScene.choosePlayerMain(dice.dice[93])\n",
    "compScene.makePlayersIntelligent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compScene.runSceneSim(20,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"SimulationData.csv\",delimiter = \"\\t\")\n",
    "df = df.dropna(axis='columns')\n",
    "df = df.set_index('Day')\n",
    "\n",
    "\n",
    "# df_max = df.cummax()\n",
    "# df_max = df_max.drop(range(499))\n",
    "# df_max.rename(index)\n",
    "\n",
    "# df_diff = df.diff()\n",
    "\n",
    "display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt = df.plot(figsize=[20,15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compScene.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}