egttools.games.nonlinear_games.AbstractNPlayerGame

class AbstractNPlayerGame(self: egttools.numerical.numerical.games.AbstractNPlayerGame, nb_strategies: int, group_size: int)

Bases: AbstractGame

Abstract N-Player Game.

This abstract Game class can be used in most scenarios where the fitness of a strategy is calculated as its expected payoff given the population state.

It assumes that the game is N player, since the fitness of a strategy given a population state is calculated as the expected payoff of that strategy over all possible group combinations in the given state.

Notes

It might be a good idea to overwrite the methods __str__, type, and save_payoffs to adapt to your given game implementation

It assumes that you have at least the following attributes: 1. And an attribute self.nb_strategies_ which contains the number of strategies that you are going to analyse for the given game. 2. self.payoffs_ which must be a numpy.ndarray and contain the payoff matrix of the game. This array must be of shape (self.nb_strategies_, nb_group_configurations), where nb_group_configurations is the number of possible combinations of strategies in the group. Thus, each row should give the (expected) payoff of the row strategy when playing in a group with the column configuration. The payoff method provides an easy way to access the payoffs for any group composition, by taking as arguments the index of the row strategy and a List with the count of each possible strategy in the group.

You must still implement the methods play and calculate_payoffs which should define how the game assigns payoffs to each strategy for each possible game context. In particular, calculate_payoffs should fill the array self.payoffs_ with the correct values as explained above. We recommend that you run this method in the __init__ (initialization of the object) since, these values must be set before passing the game object to the numerical simulator (e.g., egttools.numerical.PairwiseComparisonNumerical).

Parameters
  • nb_strategies (int) – total number of possible strategies.

  • group_size (int) – size of the group in which the game will take place.

Methods

calculate_fitness

Estimates the fitness for a player_type in the population with state :param strategies.

calculate_payoffs

Estimates the payoffs for each strategy and returns the values in a matrix.

group_size

Size of the group.

nb_group_configurations

Number of different group configurations.

nb_strategies

Number of different strategies playing the game.

payoff

Returns the payoff of a strategy given a group composition.

payoffs

Returns the payoff matrix of the game.

play

Updates the vector of payoffs with the payoffs of each player after playing the game.

save_payoffs

Stores the payoff matrix in a txt file.

type

returns the type of game.

update_payoff

update an entry of the payoff matrix

__init__(self: egttools.numerical.numerical.games.AbstractNPlayerGame, nb_strategies: int, group_size: int) None

Abstract N-Player Game.

This abstract Game class can be used in most scenarios where the fitness of a strategy is calculated as its expected payoff given the population state.

It assumes that the game is N player, since the fitness of a strategy given a population state is calculated as the expected payoff of that strategy over all possible group combinations in the given state.

Notes

It might be a good idea to overwrite the methods __str__, type, and save_payoffs to adapt to your given game implementation

It assumes that you have at least the following attributes: 1. And an attribute self.nb_strategies_ which contains the number of strategies that you are going to analyse for the given game. 2. self.payoffs_ which must be a numpy.ndarray and contain the payoff matrix of the game. This array must be of shape (self.nb_strategies_, nb_group_configurations), where nb_group_configurations is the number of possible combinations of strategies in the group. Thus, each row should give the (expected) payoff of the row strategy when playing in a group with the column configuration. The payoff method provides an easy way to access the payoffs for any group composition, by taking as arguments the index of the row strategy and a List with the count of each possible strategy in the group.

You must still implement the methods play and calculate_payoffs which should define how the game assigns payoffs to each strategy for each possible game context. In particular, calculate_payoffs should fill the array self.payoffs_ with the correct values as explained above. We recommend that you run this method in the __init__ (initialization of the object) since, these values must be set before passing the game object to the numerical simulator (e.g., egttools.numerical.PairwiseComparisonNumerical).

Parameters
  • nb_strategies (int) – total number of possible strategies.

  • group_size (int) – size of the group in which the game will take place.

__new__(**kwargs)
__str__(self: egttools.numerical.numerical.games.AbstractNPlayerGame) str
calculate_fitness(self: egttools.numerical.numerical.games.AbstractNPlayerGame, strategy_index: int, pop_size: int, strategies: numpy.ndarray[numpy.uint64[m, 1]]) float

Estimates the fitness for a player_type in the population with state :param strategies.

This function assumes that the player with strategy player_type is not included in the vector of strategy counts strategies.

Parameters
  • strategy_index (int) – The index of the strategy used by the player.

  • pop_size (int) – The size of the population.

  • strategies (numpy.ndarray[numpy.uint64[m, 1]]) – A vector of counts of each strategy. The current state of the population.

Returns

The fitness of the strategy in the population state given by strategies.

Return type

float

calculate_payoffs(self: egttools.numerical.numerical.games.AbstractNPlayerGame) numpy.ndarray[numpy.float64[m, n]]

Estimates the payoffs for each strategy and returns the values in a matrix.

Each row of the matrix represents a strategy and each column a game state. E.g., in case of a 2 player game, each entry a_ij gives the payoff for strategy i against strategy j. In case of a group game, each entry a_ij gives the payoff of strategy i for game state j, which represents the group composition.

Returns

A matrix with the expected payoffs for each strategy given each possible game state.

Return type

numpy.ndarray[numpy.float64[m, n]]

group_size(self: egttools.numerical.numerical.games.AbstractNPlayerGame) int

Size of the group.

nb_group_configurations(self: egttools.numerical.numerical.games.AbstractNPlayerGame) int

Number of different group configurations.

nb_strategies(self: egttools.numerical.numerical.games.AbstractNPlayerGame) int

Number of different strategies playing the game.

payoff(self: egttools.numerical.numerical.games.AbstractNPlayerGame, strategy: int, group_composition: List[int]) float

Returns the payoff of a strategy given a group composition.

If the group composition does not include the strategy, the payoff should be zero.

Parameters
  • strategy (int) – The index of the strategy used by the player.

  • group_composition (List[int]) – List with the group composition. The structure of this list depends on the particular implementation of this abstract method.

Returns

The payoff value.

Return type

float

payoffs(self: egttools.numerical.numerical.games.AbstractNPlayerGame) numpy.ndarray[numpy.float64[m, n]]

Returns the payoff matrix of the game.

Returns

The payoff matrix.

Return type

numpy.ndarray

play(self: egttools.numerical.numerical.games.AbstractNPlayerGame, group_composition: List[int], game_payoffs: List[float]) None

Updates the vector of payoffs with the payoffs of each player after playing the game.

This method will run the game using the players and player types defined in :param group_composition, and will update the vector :param game_payoffs with the resulting payoff of each player.

Parameters
  • group_composition (List[int]) – A list with counts of the number of players of each strategy in the group.

  • game_payoffs (List[float]) – A list used as container for the payoffs of each player

save_payoffs(self: egttools.numerical.numerical.games.AbstractNPlayerGame, file_name: str) None

Stores the payoff matrix in a txt file.

Parameters

file_name (str) – Name of the file in which the data will be stored.

type(self: egttools.numerical.numerical.games.AbstractNPlayerGame) str

returns the type of game.

update_payoff(self: egttools.numerical.numerical.games.AbstractNPlayerGame, strategy_index: int, group_configuration_index: int, value: float) None

update an entry of the payoff matrix