Kann die evolutionäre Spieltheorie die Entstehung von Kooperation erklären?
Studie über die Schwächen eines formalen Ansatzes

Eckhart Arnold

1 Einleitung
2 Die Theorie der „Evolution der Kooperation“
3 Die Erklärungsdefizite der Theorie der „Evolution der Kooperation“
4 Fazit
5 Anhang: Quellcodes und Beispielsimulationen
    5.1 Axelrod: Evolution der Kooperation
    5.2 Schuessler: Kooperation auf Anonymen Märkten
    5.3 Skyrms: Hirschjagdspiel und Gesellschaftsvertrag
            Listing: Beispiel_StagHunt_1.py
6 Revisionsgeschichte
Literaturverzeichnis

Listing: Beispiel_StagHunt_1.py

import random
import Gfx
from Compatibility import *
GfxDriver = GetDriver()


StagHuntGame = [[[3, 3], [4, 0]],\
                [[0, 4], [5, 5]]]

NEIGHBOURHOOD = (1,1) #change this to (2,2) to see the difference!


class Cell:
    """Cell Player: Either a cooperator or a defector.
    """
    def __init__(self):
        self.cooperate = 0
        self.update = 0     # cooperate in the next round
        self.neighbours = []
        self.reference = []  # usually the same as neighbours
        self.score = 0.0

    def play(self, Game = StagHuntGame):
        """Play two person Stag Hunt with all neighbours.
        """
        self.score = 0.0
        for n in self.neighbours:
            self.score += Game[self.cooperate][n.cooperate][0]
        self.score /= float(len(self.neighbours))

    def copyTheBest(self):
        """Set the strategy (to cooperate or not to cooperate) to
        the strategy of the best player in the neighbourhood.
        """
        score = self.score
        self.update = self.cooperate
        for n in self.reference:
            if n.score > score:
                score = n.score
                self.update = n.cooperate
        return self.update != self.cooperate

    def commit(self):
        self.cooperate = self.update



class PlayField:
    """Playfield, where players are placed.
    """
    def __init__(self, gfx, size = (40, 30), nhood = (1,1),
                 game = StagHuntGame):
        self.gfx = gfx
        self.size = size
        self.game = game
        self.changeOccured = True
        self.field = [[Cell() for x in xrange(size[0])] \
                      for y in xrange(size[1])]
        self.genNhoods(nhood[0], nhood[1])
        self.clearSetup()

    def clearSetup(self):
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                self.field[row][col].cooperate = 0        

    def randomSetup(self, weight=0.5):
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                self.field[row][col].cooperate = int(random.random()+weight)

    def blockSetup(self, x, y, d = 1):
        for row in xrange(y-d, y+d):
            for col in xrange(x-d, x+d):
                self.field[row%self.size[1]][col%self.size[0]].cooperate = 1

    def spotSetup(self, x, y, d = 1):
        if d < 1: return
        else:
            self.field[y % self.size[1]][x % self.size[0]].cooperate = 1
            if d > 1:
                self.spotSetup(x-1, y, d-1)
                self.spotSetup(x+1, y, d-1)
                self.spotSetup(x, y-1, d-1)
                self.spotSetup(x, y+1, d-1)

    def invertSetup(self):
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                if self.field[row][col].cooperate == 1:
                    self.field[row][col].cooperate = 0
                else:
                    self.field[row][col].cooperate = 1

    def nHood(self, x, y, d = 1):
        n = []
        for dy in xrange(-d, d+1):
            for dx in xrange(-d, d+1):
                if not (dx == 0 and dy == 0):
                    n.append(self.field[(y+dy) % self.size[1]] \
                                       [(x+dx) % self.size[0]])
        return n
        
    def genNhoods(self, dn = 1, dr = 1):
        for y in xrange(self.size[1]):
            for x in xrange(self.size[0]):
                self.field[y][x].neighbours = self.nHood(x, y, dn)
                if dn == dr:
                    self.field[y][x].reference = self.field[y][x].neighbours
                else:
                    self.field[y][x].reference = self.nHood(x, y, dr)
              
    def playRound(self):
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                self.field[row][col].play(self.game)
        self.changeOccured = False
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                if self.field[row][col].copyTheBest():
                    self.changeOccured = True
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                self.field[row][col].commit()

    def plot(self):
        width, height = self.gfx.getSize()
        pen = Gfx.RED_PEN
        self.gfx.applyPen(pen)
        for row in xrange(self.size[1]):
            for col in xrange(self.size[0]):
                x = width * col / self.size[0]
                y = height * row / self.size[1]
                w = width * (col+1) / self.size[0] - x + 1
                h = height * (row+1) / self.size[1] - y + 1
                if self.field[row][col].cooperate == 1 and \
                   pen != Gfx.GREEN_PEN:
                    pen = Gfx.GREEN_PEN
                    self.gfx.applyPen(pen)
                elif self.field[row][col].cooperate == 0 and \
                     pen != Gfx.RED_PEN:
                    pen = Gfx.RED_PEN
                    self.gfx.applyPen(pen)
                self.gfx.fillRect(x, y, w, h)

        
    
def RunStagHuntGame():
    """A simulation of the Stag Hunt game (2 player) on a 2D plane.
    """
    
    # Open a window for graphics output.
    
    gfx = GfxDriver.Window(size=(800,600), title="2 Person Stag Hunt")   
    
    #  Setup play field

    playfield = PlayField(gfx, size=(80,60), nhood=NEIGHBOURHOOD)
    playfield.clearSetup()
    playfield.spotSetup(10, 10, 5)
    playfield.plot()
    gfx.refresh()

    # run the simulation

    while playfield.changeOccured:
        playfield.playRound()
        playfield.plot()
        gfx.refresh()

    # wait until user closes the window

    gfx.waitUntilClosed()
    

if __name__ == "__main__":
    print __doc__
    RunStagHuntGame()


t g+ f @