Minsk_dilema(2) | Python Fiddle

# Ricardo Abreu (2015)
# Instituto Superior de Ciências Sociais e Políticas (ISCSP), Universidade de Lisboa
# ricardo.abreu@campus.ulisboa.pt
#
# O dilema de Minsk: O acordo de paz temporária no conflito ucraniano
#
# Aplicação da teoria dos jogos aos conflitos internacionais
#

#Adaptado:Gonçalves, Carlos Pedro (2015), “Game Theory Classes” http://pythonfiddle.com/game-theory-classes/, ISCSP, Universidade de Lisboa.
#Adaptado:Gonçalves, Carlos Pedro (2015), “Prisoner Dilemma”, http://pythonfiddle.com/prisoner-dilemma/, ISCSP, Universidade de Lisboa.

class player:
    
    def __init__(self,name,order,strategySpace,payoffs,choice,suboptimal,strategies,state,gameplay):
        self.name = name
        self.order = order
        self.strategySpace = strategySpace
        self.payoffs = payoffs
        self.choice = choice
        self.suboptimal = suboptimal
        self.strategies = strategies
        self.state = state
        self.gameplay = gameplay

def processGame(self,G):
        for i in range(0,len(G)):
            X = G[i]
            if X[0] == self.name:
                for j in range(1,len(X)):
                    Branch = X[j]
                    Alternative = list(Branch)
                    del Alternative[len(Alternative) - 1]
                    self.strategySpace = self.strategySpace + [tuple(Alternative)]
                    self.payoffs = self.payoffs + [Branch[len(Branch) - 1]]
        
    def evaluate(self):
        X = []
        for i in range(0,len(self.strategySpace)):            
            Alternative1 = self.strategySpace[i]
            for j in range(0,len(self.strategySpace)):
                Alternative2 = self.strategySpace[j]
                if Alternative1 != Alternative2:
                    if len(Alternative1) == len(Alternative2):
                        Compare = 0
                        for k in range(0,len(Alternative1) - 1):
                            if Alternative1[k] == Alternative2[k]:
                                Compare = Compare + 0
                            else:
                                Compare = Compare + 1
                        if Compare == 0:
                            PayoffCompare = [self.payoffs[i],self.payoffs[j]]
                            M = max(PayoffCompare)
                            if self.payoffs[i] == M:
                                self.choice = Alternative1
                                X = X + [self.choice]
                            else:
                                self.suboptimal = self.suboptimal + [Alternative1]
                            if self.payoffs[j] == M:
                                self.choice = Alternative2
                                X = X + [self.choice]
                            else:
                                self.suboptimal = self.suboptimal + [Alternative2]
            
        X = set(X)
        self.suboptimal = set(self.suboptimal)
        self.strategies = list(X - self.suboptimal)
        print "\nPosições estratégicas pela", self.name,":"
        print self.strategies
        for l in range(0,len(self.strategies)):
            strategy = self.strategies[l]
            for m in range(0,len(strategy)):
                O = self.order[m]
                self.state[O] = strategy[m]
            self.gameplay = self.gameplay + [tuple(self.state)]

class game:
    def __init__(self,players,structure,optimal):
        self.players = players
        self.structure = structure
        self.optimal = optimal

def Nash(self,GP):
        Y = set(GP[0])
        for i in range(0,len(GP)):
            X = set(GP[i])
            Y = Y & X
        self.optimal = list(Y)
        if len(self.optimal) != 0:
          print "\nAs posições estratégias puras do equilibrio de Nash são:"
          for k in range(0,len(self.optimal)):
              print self.optimal[k]
        else:
            print "\nEste jogo não tem posições estratégias puras do equilibrio de Nash"
            
#2 jogadores:

# Esta versão do jogo do prisioneiro é baseado no jogo da "galinha" entre dois actores internacionais, a União Europeia e a Russia.
# A União Europeia prepara-se para aumentar as sanções económicas à Russia.
# A Russia continua a militarizar os separatistas ucranianos alimentando a guerra.
# Em fevereiro de 2015 os actores internacionais reuniram-se na cidade de Minsk na Bielorrusia, para chegar a um acordo de paz.
# Os payoffs são medidos em unidades politicas consuante a posição em Ceder(C) ou Não Ceder (NC) de cada actor internacional 
# Os ganhos politicos são positivos quando ambos cedem nas suas posições e potenciam a paz (e.g 50,50)
# Os ganhos politicos são negativos quando ambos não cedem e potenciam a guerra (e.g -1000,-1000)
# Os ganhos politicos são diferenciados quando ambos tem posições opostas (e.g 100,-100)

#Game structure:

GameA = ['UE', # Player A
         ('Ceder','Ceder',50), # Quando Russia Cede: se UE Ceder, UE recebe 50 unidades de ganhos politicos
         ('Ceder','Não Ceder',100), # Quando Russia Cede: se UE não Ceder, UE recebe 100 unidades de ganhos politicos
         ('Não Ceder','Ceder',-100), # Quando Russia Não Cede: se UE Ceder, UE recebe -100 unidades de ganhos politicos
         ('Não Ceder','Não Ceder',-1000)] # Quando Russia Não Cede: se UE não Ceder, UE recebe -1000 unidades de ganhos politicos
GameB = ['Russia', # Player B
         ('Ceder','Ceder',50), # Quando UE Cede: se Russia Ceder, Russia recebe 50 unidades de ganhos politicos
         ('Ceder','Não Ceder',100), # Quando UE Cede: se Russia não Ceder, Russia recebe 100 unidades de ganhos politicos
         ('Não Ceder','Ceder',-100), # Quando UE Não Cede: se Russia Ceder, Russia recebe -100 unidades de ganhos politicos
         ('Não Ceder','Não Ceder',-1000)] # Quando UE Não Cede: se Russia não Ceder, Russia recebe -1000 unidades de ganhos politicos

#game(players,structure,plays,optimal)
Game = game(('UE','Russia'),[GameA,GameB],None)

#player(self,name,order,strategySpace,payoffs,choice,suboptimal,strategies,state,gameplay):
PlayerA = player('UE',(1,0), [], [], None, [], None, [0,0], [])
PlayerB = player('Russia',(0,1), [], [], None, [], None, [0,0], [])

Players = [PlayerA, PlayerB]

for i in range(0,len(Players)):
    Players[i].processGame(Game.structure)
    Players[i].evaluate()

GP = []

for i in range(0,len(Players)):
    X = Players[i].gameplay
    GP = GP + [X]

Game.Nash(GP)

Python Fiddle

Python Cloud IDE