Package org.evoludo.simulator.modules

Class CSD

Object
Module
Continuous
CSD
All Implemented Interfaces:
Runnable, IBS.HasIBS, IBS.HasIBS.CPairs, MilestoneListener, Features, Features.Pairs, Features.Payoffs, HasDistribution, HasDistribution.Strategy, HasHistogram, HasHistogram.Degree, HasHistogram.Fitness, HasHistogram.Strategy, HasMean, HasMean.Fitness, HasMean.Traits, HasPop2D, HasPop2D.Fitness, HasPop2D.Traits, HasPop3D, HasPop3D.Fitness, HasPop3D.Traits, CLOProvider
Direct Known Subclasses:
scanCSD
public class CSD extends Continuous implements Features.Payoffs, IBS.HasIBS.CPairs, HasPop2D.Traits, HasPop3D.Traits, HasPop2D.Fitness, HasPop3D.Fitness, HasMean.Traits, HasMean.Fitness, HasHistogram.Strategy, HasDistribution.Strategy, HasHistogram.Fitness, HasHistogram.Degree
The module for investigating the evolutionary dynamics of the continuous snowdrift game, or more generally, interactions among pairs of individuals with continuous traits. A range of cost and benefit functions determine the payoffs to the interacting individuals. The characteristics of the interaction sensitively depend on the cost and benefit functions as well as the function parameters. For example, for the continuous games the cost and benefit functions \(C(x), B(x)\), are typically assumed to be smooth, strictly increasing functions that satisfy \(B(0)=C(0)=0\) and \(B(x)>C(x)\) at least for small \(x\), where \(x\) denotes the continuous trait, or the investment level. This means that no investements provide no benefits but also entail no costs but benefits, at least for small investments, exceed the costs.

In the continuous prisoner's dilemma the payoff to an \(x\)-strategist facing an individual with strategy \(y\) is thus given by \[P(x,y)=B(y)-C(x),\] which means the benefits only depend on the opponents trait while the costs only depend on the player's own trait. Clearly the only way for the \(x\) strategist to increase its payoff is to lower the investment level. The same applies to the \(y\) strategist and hence without any further mechanisms the investment levels will invariably decrease and cooperation vanish, just as in the traditional discrete prisoner's dilemma with the two fixed traits of cooperation and defection.

In contrast, in the continuous snowdrift game the payoff to an \(x\)-strategist facing an individual with strategy \(y\) is thus given by \[Q(x,y)=B(x+y)-C(x),\] which means that the benefit that the \(x\)-strategist obtains is based on the total cooperative investment made by both agents, while the costs depend only on its own trait, just as before. Because of \(B(x)>C(x)\) this implies that it is always advantageous for an individual to make a (small) cooperative investment if its partner is not doing so. As a consequence we might expect that cooperative investment levels evolve towards some non-zero level. As it turns out, the evolutionary dynamics is much richer and is analytically tractable using the framework of adaptive dynamics. In particular, it is possible that a population spontaneously split through evolutionary branching into two stably co-existing phenotypes of high and low investors. This dynamic provides an intriguing evolutionary pathway for the origin and emergence discrete traits as assumed in classical 2×2 interactions.

Author:
Christoph Hauert
See Also:

  • Constructor Details

    • CSD

      public CSD(EvoLudo engine)
      Create a new instance of the module for continuous games.
      Parameters:
      engine - the manager of modules and pacemaker for running the model

  • Method Details

    • load

      public void load()
      Description copied from class: Module
      Load new module and perform basic initializations.
      Overrides:
      load in class Continuous
      See Also:

    • getKey

      public String getKey()
      Description copied from class: Module
      Returns identifier of the active module. For example, 2x2 games in TBT return "2x2". This corresponds to the argument for the --module option to load a particular module. The default is to use the class name.
      Overrides:
      getKey in class Module
      Returns:
      the identifying key of this module

    • getAuthors

      public String getAuthors()
      Description copied from class: Module
      Returns a string with information about the authors of the module.
      Overrides:
      getAuthors in class Module
      Returns:
      the names of the authors

    • getTitle

      public String getTitle()
      Description copied from interface: Features
      Returns title of active module, e.g. 2x2 games in TBT returns "2x2 Games".
      Specified by:
      getTitle in interface Features
      Returns:
      the title of active module

    • pairScores

      public double pairScores(double me, double[] groupTraits, int len, double[] groupPayoffs)
      Description copied from interface: IBS.HasIBS.CPairs
      Calculate the payoff/score for modules with interactions in pairs and a single continuous trait. The focal individual has trait me and the traits of its len interaction partners are given in group. The payoffs/scores for each of the len opponent traits must be stored and returned in the array payoffs.

      Note:

      Only the first len entries in group are guaranteed to exist and have meaningful values. The population structure may restrict the size of the interaction group. len≤nGroup always holds.

      Important:

      must be overridden and implemented in subclasses that define game interactions between pairs of individuals (nGroup=2, pairwise=true), otherwise see IBS.HasIBS.CGroups.groupScores(double, double[], int, double[]).
      Specified by:
      pairScores in interface IBS.HasIBS.CPairs
      Parameters:
      me - the trait of the focal individual
      groupTraits - the traits of the group members
      len - the number of memebrs in the group
      groupPayoffs - the array for returning the payoffs/scores for each group member
      Returns:
      the total (accumulated) payoff/score for the focal individual