Conflito geopolitics | Python Fiddle

# Miguel Teixeira Luis Fialho Medinas
#
# Modelo decisional com base na teoria de jogos 
#para analisar a complexidade actual das dinamicas geopoliticas fruto da crise energética e da revolução do Shale Gas

#Aplicação da teoria de jogos classica para encontrar os equilibrios de Nash, admitindo que o jogo consiste apenas na
#cooperação, ou não cooperacção entre os vários estados e organizações em causa
#
# Os payoffs são estabelecidos de forma subjectiva com base naquilo que se consideram as potenciais perdas e ganhos
# de cada entidade/estado e com a ajuda de uma 4 matrizes SWOT que permitem analisar quais as vantagens e desvantagens de cada um destes

#Adaptado de (Gonçalves, Carlos Pedro , 2015)

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 "\nStrategies selected by ", 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 "\nThe pure strategies Nash equilibria are:"
          for k in range(0,len(self.optimal)):
              print self.optimal[k]
        else:
            print "\nThis game has no pure strategies Nash equilibria!"

#Game structure:

#4 Person Prisoner's Dilemma

#Game structure:

GameA = ['USA', # Game para USA
         ('C','C','C','C',4.5),
         ('C','C','C','D',3.5),
         ('C','C','D','D',3.5),
         ('C','D','D','D',2),
         ('C','C','D','C',4),
         ('C','D','C','C',3),
         ('C','D','D','C',3),
         ('C','D','C','D',3),        
         ('D','C','C','C',2),
         ('D','C','C','D',1),
         ('D','C','D','D',4),
         ('D','D','D','D',1),
         ('D','C','D','C',3),
         ('D','D','C','C',3),
         ('D','D','D','C',2),
         ('D','D','C','D',2.5) ]
GameB = ['ArabiaSaudita', # Game para ArabiaSaudita
         ('C','C','C','C',3),
         ('C','C','C','D',3),
         ('C','C','D','D',2.5),
         ('C','D','D','D',4.5),
         ('C','C','D','C',4),
         ('C','D','C','C',5),
         ('C','D','D','C',4),
         ('C','D','C','D',4),        
         ('D','C','C','C',4.5),
         ('D','C','C','D',4),
         ('D','C','D','D',4),
         ('D','D','D','D',4.5),
         ('D','C','D','C',4),
         ('D','D','C','C',4),
         ('D','D','D','C',3),
         ('D','D','C','D',4) ]
GameC = ['Russia', # Game para Russia
         ('C','C','C','C',3.5),
         ('C','C','C','D',1),
         ('C','C','D','D',2.5),
         ('C','D','D','D',3),
         ('C','C','D','C',3.5),
         ('C','D','C','C',2.5),
         ('C','D','D','C',4),
         ('C','D','C','D',3),        
         ('D','C','C','C',4),
         ('D','C','C','D',3),
         ('D','C','D','D',3),
         ('D','D','D','D',2.5),
         ('D','C','D','C',4),
         ('D','D','C','C',2.5),
         ('D','D','D','C',1),
         ('D','D','C','D',2.5) ]
GameD = ['OPEC', # Game para OPEC
         ('C','C','C','C',3.5),
         ('C','C','C','D',1),
         ('C','C','D','D',2),
         ('C','D','D','D',3),
         ('C','C','D','C',4),
         ('C','D','C','C',4),
         ('C','D','D','C',3.5),
         ('C','D','C','D',3.5),        
         ('D','C','C','C',4),
         ('D','C','C','D',3),
         ('D','C','D','D',3.5),
         ('D','D','D','D',2),
         ('D','C','D','C',4),
         ('D','D','C','C',3),
         ('D','D','D','C',1),
         ('D','D','C','D',4) ]

#game(players,structure,plays,optimal)
Game = game(('USA','ArabiaSaudita','Russia','OPEC'),[GameA,GameB,GameC,GameD],None)

#player(self,name,order,strategySpace,payoffs,choice,suboptimal,strategies,state,gameplay):

PlayerA = player('USA',(1,2,3,0), [], [], None, [], None, [0,0,0,0], [])
PlayerB = player('ArabiaSaudita',(0,2,3,1), [], [], None, [], None, [0,0,0,0], [])
PlayerC = player('Russia',(0,1,3,2), [], [], None, [], None, [0,0,0,0], [])
PlayerD = player('OPEC',(0,1,2,3), [], [], None, [], None, [0,0,0,0], [])

Players = [PlayerA, PlayerB, PlayerC,PlayerD]

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