def __init__(self, roles=[], players={}, strategies={}, payoff_data=[]): """ Role-symmetric game representation. __init__ parameters: roles: collection of role-name strings players: mapping from roles to number of players per role strategies: mapping from roles to per-role strategy sets payoff_data: collection of data objects mapping roles to collections of (strategy, count, value) tuples """ self.roles = sorted(set(map(str, roles))) self.players = h_dict({r : int(players[r]) for r in self.roles}) self.strategies = h_dict({r : tuple(sorted(set(map(str, \ strategies[r])))) for r in self.roles}) self.numStrategies = [len(self.strategies[r]) for r in self.roles] self.maxStrategies = max(self.numStrategies) self.minPayoffs = self.zeros(dtype=float, masked=False) self.minPayoffs.fill(float('inf')) self.mask = np.array([[False]*s + [True]*(self.maxStrategies - s) for \ s in self.numStrategies]) self.size = prod([game_size(self.players[r], self.numStrategies[ \ i]) for i,r in enumerate(self.roles)]) self.role_index = {r:i for i,r in enumerate(self.roles)} self.strategy_index = {r : {s:i for i,s in enumerate( \ self.strategies[r]) } for r in self.roles} self.values = [] self.counts = [] self.dev_reps = [] for profile_data_set in payoff_data: self.addProfile(profile_data_set)
def __init__(self, role_payoffs): arbitrary_value = next(role_payoffs.itervalues()) if isinstance(arbitrary_value, list):#Game.addProfile calls like this d = {} for role, payoffs in role_payoffs.items(): d[role] = h_dict({p.strategy:p.count for p in payoffs}) h_dict.__init__(self, d) elif isinstance(arbitrary_value, dict):#others should look like this h_dict.__init__(self, {r:h_dict(p) for r,p in role_payoffs.items()}) else: raise TypeError("Profile.__init__ can't handle " + \ type(arbitrary_value).__name__)
def cliques(full_game, known_subgames=[]): """ Finds maximal subgames for which all profiles are known. input: subgames = known complete subgames to be expanded (any payoff data in the known subgames is ignored, so for faster loading, give only the header information). """ new_profiles = set(full_game.knownProfiles()) - set().union(*( \ subgame(full_game, s).allProfiles() for s in known_subgames)) new_strategies = {r:set() for r in full_game.roles} for prof in new_profiles: for role in full_game.roles: new_strategies[role] |= set(prof[role].keys()) subgames = {subgame(full_game).strategies} for sg in known_subgames: try: sg = subgame(full_game, sg.strategies) except AttributeError: sg = subgame(full_game, sg) if sg.isComplete(): subgames.add(sg.strategies) maximal_subgames = set() explored_subgames = set() while(subgames): sg_strat = subgames.pop() empty_role = not all(map(len, sg_strat.values())) empty_game = not any(map(len, sg_strat.values())) explored_subgames.add(sg_strat) maximal = True for role in full_game.roles: if empty_role and len(sg_strat[role]) > 0: continue available_strategies = (new_strategies[role] if empty_game \ else set(full_game.strategies[role])) - set(sg_strat[role]) for s in available_strategies: strategies = h_dict({r : tuple(sorted(list(sg_strat[r]) + \ ([s] if r == role else []))) for r in full_game.roles}) if strategies in explored_subgames: maximal=False continue try: new_sg = subgame(full_game, strategies, True) except KeyError: continue maximal=False subgames.add(new_sg.strategies) if maximal: sg = subgame(full_game, sg_strat) if len(sg) > 0: maximal_subgames.add(sg.strategies) return sorted(maximal_subgames, key=len)