egttools.games.PGG

class PGG(group_size, cost, multiplying_factor, strategies)[source]

Bases: AbstractNPlayerGame

Classical Public Goods game with only 2 possible contributions (o or cost).

Parameters
  • group_size (int) – Size of the group playing the game.

  • cost (float) – Cost of cooperation.

  • multiplying_factor (float) – The sum of contributions to the public good is multiplied by this factor before being divided equally among all players.

  • strategies (List[egttools.behaviors.pgg_behaviors.PGGOneShotStrategy]) – A list of strategies that will play the game.

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__(group_size, cost, multiplying_factor, strategies)[source]

Classical Public Goods game with only 2 possible contributions (o or cost).

Parameters
  • group_size (int) – Size of the group playing the game.

  • cost (float) – Cost of cooperation.

  • multiplying_factor (float) – The sum of contributions to the public good is multiplied by this factor before being divided equally among all players.

  • strategies (List[egttools.behaviors.pgg_behaviors.PGGOneShotStrategy]) – A list of strategies that will play the game.

__new__(**kwargs)
__str__()[source]
Return type

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()[source]

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(group_composition, game_payoffs)[source]

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

Return type

None

save_payoffs(file_name)[source]

Stores the payoff matrix in a txt file.

Parameters

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

Return type

None

type()[source]

returns the type of game.

Return type

str

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