egttools.games.nonlinear_games.NPlayerStagHunt

class NPlayerStagHunt(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, nb_strategies: SupportsInt | SupportsIndex, group_size: SupportsInt | SupportsIndex)[source]

Bases: AbstractNPlayerGame

This game is based on the article Pacheco et al., ‘Evolutionary Dynamics of Collective Action in N -Person Stag Hunt Dilemmas’.

Abstract N-player game.

This abstract base class represents a symmetric N-player game in which each strategy’s fitness is computed as the expected payoff over all group compositions in a population.

Parameters:

  • nb_strategies (int) – Total number of strategies in the game.

  • group_size (int) – Size of the interacting group.

Methods

calculate_fitness

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

calculate_payoffs

Computes and returns the full payoff matrix.

group_size

nb_group_configurations

nb_strategies

payoff

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

payoffs

Returns the payoff matrix.

play

Calculate the payoff of each strategy inside the group.

save_payoffs

Saves the payoff matrix to a text file.

type

update_payoff

Updates an entry in the payoff matrix.
__init__(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, nb_strategies: SupportsInt | SupportsIndex, group_size: SupportsInt | SupportsIndex) → None[source]

Abstract N-player game.

This abstract base class represents a symmetric N-player game in which each strategy’s fitness is computed as the expected payoff over all group compositions in a population.

Parameters:

  • nb_strategies (int) – Total number of strategies in the game.

  • group_size (int) – Size of the interacting group.

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

str

calculate_fitness(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, strategy_index: SupportsInt | SupportsIndex, pop_size: SupportsInt | SupportsIndex, strategies: Annotated[numpy.typing.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.

  • strategies (numpy.ndarray) – Population state as a strategy count vector.

Returns:

Fitness of the focal strategy in the given state.

Return type:

float

calculate_payoffs()[source]

Computes and returns the full payoff matrix.

Returns:

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

Return type:

numpy.ndarray

group_size(self: egttools.numerical.numerical_.games.AbstractNPlayerGame) → int
nb_group_configurations(self: egttools.numerical.numerical_.games.AbstractNPlayerGame) → int
nb_strategies(self: egttools.numerical.numerical_.games.AbstractNPlayerGame) → int
payoff(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, strategy: SupportsInt | SupportsIndex, group_composition: collections.abc.Sequence[SupportsInt | SupportsIndex]) → float

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

Parameters:

  • strategy (int) – The strategy index.

  • group_composition (numpy.ndarray) – The group configuration.

Returns:

The corresponding payoff.

Return type:

float

payoffs(self: egttools.numerical.numerical_.games.AbstractNPlayerGame) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']

Returns the payoff matrix.

Returns:

Matrix of shape (nb_strategies, nb_group_configurations).

Return type:

numpy.ndarray

play(group_composition, game_payoffs)[source]

Calculate the payoff of each strategy inside the group.

$Pi_{D}(k) = (kFc) heta(k-M)$ $Pi_{C}(k) = Pi_{D}(k) - c$

Parameters:

  • group_composition (Union[List[int], numpy.ndarray]) – counts of each strategy inside the group.

  • game_payoffs (numpy.ndarray) – container for the payoffs of each strategy

Return type:

None

save_payoffs(file_name)[source]

Saves the payoff matrix to a text file.

Parameters:

file_name (str) – Destination file path.

Return type:

None

type()[source]
Return type:

str

update_payoff(self: egttools.numerical.numerical_.games.AbstractNPlayerGame, strategy_index: SupportsInt | SupportsIndex, group_configuration_index: SupportsInt | SupportsIndex, value: SupportsFloat | SupportsIndex) → None

Updates an entry in the payoff matrix.

Parameters:

  • strategy_index (int) – Index of the strategy.

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

  • value (float) – The new payoff value.

__annotations__ = {}