Iterated Prisoner's Dilemma.ipynb

Kernel: Python 2 (Ubuntu Linux)

Iterated Prisoner's Dilemma

Game class for 2-player Iterated Prisoner's Dilemma. One can modify the number of rounds and the miscommunication chance.

import numpy as np

class game:
    def __init__(self,player0,player1):
        self.player0 = player0
        self.player1 = player1
        self.decisions = []
        self.scores = []

    def play(self,n=10,m=0,p=1):
        misc = lambda x: int(not x) if np.random.random() <= m/100. else x
        for i in range(n):
            newDecisions = [misc(self.player0.decision(0,self.decisions)),misc(self.player1.decision(1,self.decisions))]
            self.decisions.append(newDecisions)
            if newDecisions == [0,0]:
                newScores = [0,0]
            elif newDecisions == [1,0]:
                newScores = [-1,3]
            elif newDecisions == [0,1]:
                newScores = [3,-1]
            else:
                newScores = [2,2]
            self.scores.append(newScores)
        player0Score = sum([a for a,b in self.scores])
        player1Score = sum([b for a,b in self.scores])
        if p:
            print('Number of rounds: ' + str(n))
            print('Miscommunication chance: ' + str(m) + '%')
            print(self.player0.name + ' score: ' + str(player0Score))
            print(self.player1.name + ' score: ' + str(player1Score))
        return [player0Score,player1Score]

Nice player always cooperates.

class nicePlayer:
    def __init__(self):
        self.name = 'Nice Player'
    def decision(self,n,decisions):
        return 1

Mean player always cheats.

class meanPlayer:
    def __init__(self):
        self.name = 'Mean Player'
    def decision(self,n,decisions):
        return 0

Grudge player starts by cooperating, but if you cheat, it will cheat back forever.

class grudgePlayer:
    def __init__(self):
        self.name = 'Grudge Player'
    def decision(self,n,decisions):
        if 0 in [b for a,b in decisions]:
            return 0
        else:
            return 1

Copycat player starts by cooperating and then repeats whatever the other player did last.

class copycatPlayer:
    def __init__(self):
        self.name = 'Copycat Player'
    def decision(self,n,decisions):
        if len(decisions):
            return decisions[-1][int(not n)]
        else:
            return 1

Forgiving copycat player starts by cooperating and then cheats back only if cheated twice in a row.

class forgivingCopycatPlayer:
    def __init__(self):
        self.name = 'Forgiving Copycat Player'
    def decision(self,n,decisions):
        if len(decisions)>1 and (decisions[-1][int(not n)] == 0 and decisions[-2][int(not n)] == 0):
            return 0
        else:
            return 1

Simple copycat player starts by cooperating. If you cheat, it does the opposite of what it did last. If you cooperate, it repeats whatever it did last.

class simpleCopycatPlayer:
    def __init__(self):
        self.name = 'Simple Copycat Player'
    def decision(self,n,decisions):
        if len(decisions):
            if decisions[-1][int(not n)]:
                return decisions[-1][n]
            else:
                return int(not decisions[-1][n])
        else:
            return 1

game(copycatPlayer(),forgivingCopycatPlayer()).play(m=5)

Number of rounds: 10
Miscommunication chance: 5%
Copycat Player score: 21
Forgiving Copycat Player score: 17

[21, 17]

players = [copycatPlayer(),copycatPlayer(),copycatPlayer(),copycatPlayer(),copycatPlayer(),
           meanPlayer(),meanPlayer(),meanPlayer(),meanPlayer(),meanPlayer(),
           nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),
           nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),
           nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),nicePlayer(),]
N = len(players)
scores = [0 for i in range(N)]
M = 0

for i in range(N-1):
    for j in range(i+1,N):
        a,b = game(players[i],players[j]).play(m=M,p=0)
        scores[i] += a
        scores[j] += b
for output in [[name.name,score] for name,score in sorted(zip(players,scores),key=lambda x: x[1])[::-1]]:
    print(output)

['Mean Player', 465]
['Mean Player', 465]
['Mean Player', 465]
['Mean Player', 465]
['Mean Player', 465]
['Copycat Player', 375]
['Copycat Player', 375]
['Copycat Player', 375]
['Copycat Player', 375]
['Copycat Player', 375]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]
['Nice Player', 330]