egttools.games.nonlinear_games.CommonPoolResourceDilemmaCommitment

class CommonPoolResourceDilemmaCommitment(group_size, a, b, cost, fine, strategies)

Bases: AbstractNPlayerGame

Common Pool resource game with commitment, but the threshold is set as another strategy :type group_size: int :param group_size: Size of the group playing the game. :type group_size: int :param a and b: Both a and b are the parameters of the game, if a>>b, then it’s attractive to invest in the CPR :type a and b: flaot :type cost: float :param cost: cost of making the commitment for commitment proposing strategy :type fine: float :param fine: fine for defection when accepting the commitment :type fine: float :type strategies: List[AbstractCPRStrategy] :param strategies: List of strategies which will play the game :type strategies: Lit[int]

Methods

add_group_extraction
calculate_expected_consumption
calculate_fitness	Computes the fitness of a given strategy in a population state.
calculate_payoffs	Computes and returns the full payoff matrix.
calculate_total_extraction
check_if_commitment_validated
get_nb_committed
group_size	Returns the size of the group.
nb_group_configurations	Returns the number of distinct group configurations.
nb_strategies	Returns the number of strategies in the game.
payoff	Returns the payoff of a strategy in a given group context.
payoffs	Returns the payoff matrix.
play	Executes the game for a given group composition and fills the payoff vector.
save_payoffs	Saves the payoff matrix to a text file.
type	Returns the string identifier for the game.
update_payoff	Updates an entry in the payoff matrix.

__init__(group_size, a, b, cost, fine, strategies)

Common Pool resource game with commitment, but the threshold is set as another strategy :type group_size: int :param group_size: Size of the group playing the game. :type group_size: int :param a and b: Both a and b are the parameters of the game, if a>>b, then it’s attractive to invest in the CPR :type a and b: flaot :type cost: float :param cost: cost of making the commitment for commitment proposing strategy :type fine: float :param fine: fine for defection when accepting the commitment :type fine: float :type strategies: List[AbstractCPRStrategy] :param strategies: List of strategies which will play the game :type strategies: Lit[int]

__new__(**kwargs)

__str__(self: egttools.numerical.numerical_.games.AbstractNPlayerGame) → str

Returns a string representation of the game.

Return type:

str

add_group_extraction(group_extraction, group_composition)

calculate_expected_consumption(population_state)

Return type:

float

calculate_fitness(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, strategy_index: int, pop_size: int, strategies: numpy.ndarray[numpy.uint64[m, 1]]) → float

Computes the fitness of a given strategy in a population state.

Parameters:

• strategy_index (int) – The strategy of the focal player.

• pop_size (int) – Total population size (excluding the focal player).

• strategies (numpy.ndarray[uint64]) – The population state as a strategy count vector.

Returns:

Fitness of the focal strategy in the given state.

Return type:

float

calculate_payoffs()

Computes and returns the full payoff matrix.

Returns:

A matrix with expected payoffs. Each row represents a strategy, each column a group configuration.

Return type:

numpy.ndarray

calculate_total_extraction(commitment_accepted, group_composition)

Return type:

float

check_if_commitment_validated(nb_committed, group_composition, commitment_accepted)

Return type:

None

get_nb_committed(group_composition)

Return type:

int

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

Returns the size of the group.

Return type:

int

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

Returns the number of distinct group configurations.

Return type:

int

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

Returns the number of strategies in the game.

Return type:

int

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

Returns the payoff of a strategy in a given group context.

Parameters:

• strategy (int) – The strategy index.

• group_composition (list[int] or numpy.ndarray[int]) – The group configuration.

Returns:

The corresponding payoff.

Return type:

float

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

Returns the payoff matrix.

Returns:

The matrix of shape (nb_strategies, nb_group_configurations).

Return type:

numpy.ndarray

play(group_composition, game_payoffs)

Executes the game for a given group composition and fills the payoff vector.

Parameters:

• group_composition (List[int] | numpy.ndarray[int]) – The number of players of each strategy in the group.

• game_payoffs (List[float] | numpy.ndarray[float]) – Output container where the payoff of each player will be written.

Return type:

None

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

Saves the payoff matrix to a text file.

Parameters:

file_name (str) – Destination file path.

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

Returns the string identifier for the game.

Return type:

str

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

Updates an entry in the payoff matrix.

Parameters:

• strategy_index (int) – Index of the strategy (row).

• group_configuration_index (int) – Index of the group composition (column).

• value (float | numpy.float64) – The new payoff value.

__annotations__ = {}