This repository provides an interactive, browser-based simulation of repeated coordination dynamics inspired by Arifovic-style evolutionary settings. The tool is designed for classroom use and exploratory research: users can step through each phase manually, run multiple periods automatically, and inspect how population behavior changes under different survival and reproduction rules.
The current interface supports two model variants:
- Simple version: fixed selection strength in survival probability.
- Complex version: user-controlled selection strength via parameter
c.
Both versions share the same simulation pipeline, visualization stages, and baby-generation rules.
The simulation tracks a population of agents, each with one effort type:
L(low effort)M(medium effort)H(high effort)
The game is a minimum-effort coordination environment:
- Group benefit is determined by the minimum effort in the group.
- Individual payoff is:
[ \text{payoff} = \text{group benefit} - \text{own effort cost} ]
Default values used in the app:
- Costs:
L=0,M=5,H=10 - Group benefit by group minimum:
L→0,M→10,H→100
So an individual can earn anywhere from -10 to 90 depending on group composition and own effort.
The UI is intentionally phase-based to make model mechanics understandable for first-time users.
A typical cycle is:
- Create population
- Make groups
- Survival draw
- Death display
- Birth
- Regroup and continue
The stage indicator and event log explain each transition in plain language, so users can follow not only outcomes but also the process that produced them.
- Survival draw computes who survives (stochastic selection based on probability), marking outcomes logically.
- Death display shows those outcomes visually, so users can inspect what changed before births refill the population.
This separation prevents the model from feeling like a single “instant jump” from grouped agents to next period.
Both versions use linear survival probabilities from payoff, with a baseline offset of +10.
[ P(\text{survival}) = \frac{0.85 \cdot \text{payoff} + 10}{100} ]
- Selection slope is fixed at
0.85. - Good for teaching and baseline experiments.
- Fewer free parameters, easier to compare runs.
[ P(\text{survival}) = \frac{c \cdot \text{payoff} + 10}{100} ]
cis user-editable (0to2).- Larger
cincreases sensitivity to payoff differences (stronger selection pressure). - Smaller
cweakens payoff-driven selection.
- Simple is a stable reference model.
- Complex supports sensitivity analysis and richer parameter studies.
After deaths are applied, the simulator creates newborns to keep total population size constant. How newborn effort is assigned is controlled by the baby rule.
Each baby copies a random effort type sampled from the current survivor pool.
- Mechanism: survivor-weighted replication.
- Interpretation: “successful strategies reproduce more often.”
- Typical effect: faster convergence, stronger lock-in/path dependence.
Each baby independently draws effort uniformly from L/M/H.
- Mechanism: pure exploration / mutation-like replacement.
- Interpretation: survivors do not directly bias newborn composition.
- Typical effect: more persistent diversity, slower convergence, higher noise.
For each baby:
- with probability
p: sample viafromAlive - with probability
1 - p: sample viaequalRandom
So p is an inheritance–exploration dial:
p = 1: equivalent to purefromAlivep = 0: equivalent to pureequalRandom- intermediate
p: balanced behavior
This rule is often the most useful for avoiding two extremes:
- overly rigid lock-in (
fromAliveonly) - overly noisy drift (
equalRandomonly)
This is a frequent and valid question.
- Within one grouped interaction, payoff computation is local to each group.
- Across periods, groups are not fully independent because:
- newborn generation references the global survivor composition,
- the next period reshuffles and regroups agents.
Result: local interactions + global replacement + reshuffling create cross-group coupling over time.
Main controls exposed in the UI:
Population sizeGroup sizePeriodsSeedSpeedBaby rulep(shown whenmixedPis selected)c(shown in Complex mode)Reset simulation(restores full initial state)
Navigation buttons:
Create populationMake groupsSurvival stepRun periodsPrevious frameNext frameStop
The simulation uses a seedable RNG. For reproducible comparisons:
- keep
seedfixed, - change one parameter at a time,
- compare trajectories across multiple periods.
This is especially important when evaluating sensitivity to c (Complex mode) and p (mixedP rule).
For new users:
- Start with Simple + mixedP (
p=0.5). - Observe several manual steps to understand each phase.
- Run longer periods automatically.
- Switch to Complex, vary
c(e.g.,0.4,0.85,1.4). - Compare outcomes under
fromAlive,equalRandom, andmixedP.
For reporting, track:
- final effort distribution,
- speed of convergence,
- volatility across periods,
- sensitivity to seed.
python3 -m http.server 8000Open:
http://localhost:8000/
If you use GitHub Pages, publish from main / (root).