Experiment Overview

A neural network^{[6, 7]} is a computer model inspired by how brain cells work. It is made of many simple "cells" (called neurons) that receive numbers, do simple math, and send numbers to other cells. No one programs the network step-by-step to solve the problem. Instead, we give it a structure—layers and connections—and then we change the strength of those connections (the "weights") through learning^[8] or, in our case, evolution^[12].

Think of it like a recipe where we only adjust the amounts of ingredients, not the steps. In this experiment, each organism's "brain" is one small neural network. It is nothing like a human brain in size or complexity, but the same basic idea: numbers go in, math happens, and numbers come out that become actions.

The inputs are numbers that represent what the organism "knows"—for example, how far away the nearest food pellet is, or how close the nearest enemy organism is. Since the world wraps around (toroidal geometry), there are no walls—just open space in every direction. These numbers flow through layers. The first layer takes the inputs and multiplies them by learned "weights," adds "biases," and then applies a simple rule (like "if the result is negative, treat it as zero") so the network can learn patterns that are not straight lines. The result becomes the input to the next layer, and so on.

The output layer produces the final numbers. In our experiment, that is four numbers that control thrust, turn, shoot, and split (see Key terms below). The only thing that changes during evolution is the weights and biases; the layout of the network stays the same. If the first weight is big, that input has a big effect on the next layer; if it is small, it has a small effect.

The following terms are used throughout this overview. They are defined here so you can refer back anytime.

In this experiment, each organism is controlled by a specific neural network architecture often described as 24-64-4. This code describes the shape of its "brain" and how it processes information. You can think of it like a team of workers passing messages down a line.

1. The Inputs: 24 "Eyes" (Sensors)

The network starts with 24 inputs. Imagine the organism has 8 eyes looking in 8 different directions (forward, backward, left, right, and diagonals). Each eye measures exactly 3 things:

• How far is the nearest Food pellet in this direction?
• How far is the nearest Enemy organism in this direction?
• How far is the nearest boundary wrap point? (Since the world is toroidal—it wraps around like the surface of a donut—there are no walls. This value tells the organism how far it is from the wrap-around edge, which affects how distances to food and enemies are measured.)

With 8 directions × 3 measurements each, that gives us the 24 inputs. These numbers are the only thing the organism "sees." Because the world wraps around, organisms cannot hide in corners or against walls—the environment is completely open in every direction.

2. The Hidden Layer: 64 "Thinkers"

The information then travels to a large hidden layer containing64 neurons.

• Instead of splitting duties between small groups, this large group of 64 neurons works together to process the raw input data. They identify patterns (like "food is close") and calculate the best strategy simultaneously. Having more neurons in a single layer allows the network to capture complex relationships between the inputs directly.

3. The Outputs: 4 Actions

Finally, the network produces 4 outputs, which are the instructions sent to the organism's body:

• Thrust: How hard to push forward (0 to 100%).
• Turn: Which way to steer (-1 for left, +1 for right).
• Shoot: Whether to fire a projectile (if this number is high enough, it shoots).
• Split: Whether to reproduce/split (if high enough).

This entire process happens instantly, dozens of times per second, allowing the organism to react to its world in real-time.

We run 1,000 organisms at once. To do this quickly we use a graphics card (GPU) to run all 1,000 brains in parallel—like having 1,000 calculators working at the same time. The software runs on the GPU so we can simulate many generations in a reasonable time.

The petri dish is our controlled mini-world for the experiment. Think of a real petri dish in biology: a simple, closed environment where we can watch life (here, digital organisms) under fixed rules. That helps science because we can repeat the experiment exactly—same rules, same starting conditions—and change only one thing: how much we mutate the "genes" (weights) of the neural networks. So we can fairly compare two strategies.

The world is 2D (flat, like a tabletop) and continuous (organisms can be anywhere, not just on a grid), with wrap-around borders (toroidal geometry): going off one edge brings you back on the other side. This means there are no walls or corners to hide in—organisms must survive in the open. The physics are simple (movement and collisions) so the computer can simulate thousands of organisms without extra complexity. The petri dish is our lab bench—simple, repeatable, and designed so we can learn about evolution and mutation, not about the environment.

The organisms (also called agents) are digital creatures represented as circles moving in the 2D petri dish. Each has energy—like health or fuel. They lose a little energy every moment (metabolism, like burning calories just to stay alive) and gain energy in two ways: by eating food (static pellets that give a set amount of energy) or by predation (shooting a projectile at another organism to steal some of their energy).

Foraging is safer but can be slow; predation is riskier but can yield big gains. They have no hands or eyes; their only "senses" are the numbers from the raycasts and their own state, and their only "actions" are the four outputs (thrust, turn, shoot, split). No one programmed them to "go toward food" or "avoid enemies"—they only have a brain (neural network) that turns what they sense into actions. Over time, organisms that keep their energy high survive and reproduce; others die out.

Each moment (tick), every organism gets a list of 24 numbers: from 8 directions, how far to the nearest food and enemy (and sometimes enemy size), plus a few numbers about itself (energy level, speed, whether it is on cooldown for shooting or splitting). That list is the input to its neural network. The network outputs 4 numbers that control thrust, turn, shoot, and split.

No one programmed the organisms to "go toward food" or "avoid enemies." The network just has weights that get evolved; any "strategy" we see (foraging, fleeing, attacking) emerges from which organisms had more offspring. So their motivation is not written in code; it is implicit: organisms that by chance behave in ways that keep energy high get to reproduce, so over many generations the population tends to act in ways that help survival. We measure their success with a fitness score (see Key terms)—higher fitness means they tend to "win" more often in our pairwise comparisons. Think of it like nature selecting the best survivors.

We do not tell the organisms how to behave. We only select the best performers (top 20% by fitness score), copy their neural network weights to create offspring, and randomly change (mutate) those weights a little. So "why they act the way they do" is: their brains were shaped by many generations of trial and error.

Organisms that happened to have weights that led to good survival and reproduction left more copies; bad strategies died out. It is like breeding dogs for speed—we did not design the legs; we just kept the fastest and over time they got faster. At the start, behavior is almost random; after many generations we often see recognizable strategies (some organisms forage, some attack) because those strategies won in the petri dish. They act the way they do because evolution favored those behaviors in this environment.

We run two groups of experiments, identical in every way except how much we mutate the offspring.

• Control group — We use a fixed mutation amount (we always change the weights by the same small random amount), like flipping a coin the same way every time.
• Experimental group — We use adaptive mutation: we change the weights more when the parent did poorly and less when the parent did well. Struggling organisms get more random changes (more chance to try something new); successful ones get fewer changes (we keep what works).

For each group we start with 1,000 random neural networks, run the petri dish for many generations (each generation = one round of life, selection, breeding, and mutation), and we stop when the population's behavior stabilizes—meaning the mix of strategies stops changing much. We call that approaching a Nash equilibrium (see next section). We record when that happened (which generation) and how well the population did (peak rating). Then we compare the two groups: did the adaptive-mutation group reach stability faster? We use statistics to check if the difference is real or just luck.

Game theory^[3] is the study of situations where multiple decision-makers (players) choose actions, and each person's outcome depends not only on their own choice but on what others do. Think of two people dividing a pizza: if you ask for more, the other might take less; your best choice depends on what you think they will do. In our experiment, the "players" are the organisms. Each one chooses how to behave (forage, attack, flee) based on its neural network, and its success (energy, survival, reproduction) depends on what the other 999 are doing. So the petri dish is a "game" in the game-theory sense^[25].

Nash equilibrium^{[1, 2]} is a situation where no one can improve their outcome by changing their strategy alone, given what everyone else is doing. It is named after the mathematician John Nash. At a Nash equilibrium, if you are the only one who switches from "forage" to "attack," you don't do better—so no one has a reason to switch. It describes a stable outcome: everyone is doing the best they can given what others do.

In our experiment, each organism has a strategy (the way its brain turns inputs into actions). The population has a mix of strategies^{[4, 5]}. We say the population has reached a Nash-like equilibrium when the mix of strategies stops changing from generation to generation: the kinds of behavior have settled into a stable balance. At that point, no organism would do better by behaving differently, given how the rest of the population is behaving. We detect this by watching entropy variance^[28]—how much the organisms differ from each other in how "mixed" or "certain" their decisions are. When everyone is behaving similarly, that difference drops and stays low; when it stays low for many generations in a row, we treat that as having reached Nash equilibrium.

Why Nash equilibrium is the key metric: Our hypothesis is that adaptive mutation helps the population reach Nash equilibrium faster than fixed mutation. So the key metric is how many generations it takes to reach Nash equilibrium—that is our primary outcome. If the adaptive-mutation group reaches Nash equilibrium in fewer generations than the control group, that supports the hypothesis. Nash equilibrium is not just a fancy name for "they settled down"—it is the specific, stable outcome from game theory that we use to define "settled," and the generation at which we reach it is the main number we use to test our hypothesis.

Detection criterion. Nash equilibrium^{[1, 2]} is detected using entropy variance^[28] across the population, not mean policy entropy. For each generation we compute a scalar policy entropy per agent (expected entropy of the action distribution over a fixed set of sample inputs). The entropy variance is the variance of those per-agent entropies across the population.

Why variance rather than mean entropy. Mean policy entropy indicates how mixed or deterministic the average policy is, but it does not measure population-level homogeneity. At equilibrium we require that the strategy mix has stabilized^[4]—i.e., that agents no longer differ substantially in behavior. That corresponds to low variance of policy entropy across agents: when all agents have similar entropies, the population has converged to a homogeneous strategy mix. We therefore define convergence as the generation at which entropy variance falls below a threshold and remains below it for a fixed stability window (after an initial phase of divergence), with a post-convergence buffer to confirm stability.

We have 1,000 organisms, each with a neural network that does many multiplications every moment, and we run hundreds of generations. Doing that on an ordinary computer (CPU) would take a very long time—hours or days. A GPU (graphics card) is built to do thousands of simple math operations at once (originally for drawing graphics). We use it to run all 1,000 brains in parallel—like having 1,000 people each do one multiplication at the same time instead of one person doing 1,000.

Workers are the computers that have the GPU and actually run the simulation. The website you see is the "controller"; it sends the experiment settings to a worker, the worker runs the petri dish and evolution on its GPU, and sends the results back. So we need GPU workers to finish the experiment in a reasonable time and to separate the heavy computation (worker) from the interface and storage (web app). Think of the worker as a lab technician who runs the experiment and mails back the data.

The primary metric for proving our hypothesis is how many generations it takes to reach Nash equilibrium (convergence velocity). The other metrics (peak fitness, policy entropy) support the analysis, but convergence to Nash is the key outcome we compare between the two groups.

Important detail: Fitness score tells us how well organisms did, whileentropy variance tells us how similar their decision-making styles are. Two groups could have similar fitness but still behave differently. That is why we track both performance and behavior.

• Convergence velocity ("when did they reach Nash equilibrium?") — We record the generation number at which the population's behavior becomes stable: the variety of strategies (who forages, who attacks) stops changing much from generation to generation. We check this using entropy variance—how much the organisms differ from each other in how mixed or certain their decisions are. When that difference is small and stays small for many generations, everyone is behaving similarly and we say we have reached a Nash-like equilibrium. So convergence velocity = how many generations it took to get there. Faster convergence = fewer generations.
• Peak fitness ("how good did they get?") — We record the highest fitness score that any organism (or the population) reached (see Key terms for how we calculate it). This tells us how well the evolved strategies performed in the petri dish.
• Policy entropy ("how predictable are one organism's decisions?") — This number tells us whether an organism is still experimenting (high entropy) or has settled on a stable style (low entropy). We look at the variance of that number across all organisms to detect equilibrium: when the variance is low, everyone is similar; when it stays low for many generations, we have reached Nash equilibrium.

We are measuring how fast the population stabilizes and how well it does, and we compare these between the control and experimental groups.

Two of the most important numbers in this experiment sound similar — policy entropy and entropy variance — but they measure very different things. Understanding the distinction is critical to understanding how we detect Nash equilibrium.

Policy entropy: "How random is ONE organism's behavior?"

Imagine an organism standing in the petri dish. It has four possible actions: move forward, turn left, turn right, or boost. If its neural network says "82% forward, 7% left, 5% right, 6% boost", that organism has a clear preference — it almost always goes forward. Its policy entropy is low.

On the other hand, if the neural network says "25% forward, 25% left, 25% right, 25% boost", the organism is essentially flipping a coin every time. It has no strategy. Its policy entropy is high.

Mathematically, for a single organism with action probabilities p₁, p₂, p₃, p₄:

The number we report on the dashboard as "policy entropy" is the average of this value across 200 sampled organisms. It tells us: on average, how decisive is the typical organism?

Entropy variance: "How DIFFERENT are the organisms FROM EACH OTHER?"

Policy entropy tells us about the average individual. Entropy variance tells us whether all the individuals agree. We take the entropy of each sampled organism and compute the variance (statistical spread) across the whole group:

Low variance means all organisms have similar entropy values. High variance means some are decisive while others are still confused.

Why variance matters more than entropy for detecting Nash equilibrium

Here is the key insight: you can have low average entropy but high variance, and it is NOT Nash equilibrium. Three scenarios illustrate this:

This is exactly why our convergence detection algorithm requires the population to diverge first (variance goes up as organisms develop different strategies) and then re-converge (variance drops back down as they settle on a shared equilibrium). Only when variance stays low for 20 consecutive generations after having been high do we declare Nash equilibrium.

The previous sections explain what we measure (convergence velocity, peak fitness, policy entropy). This section explains how the software actually captures those numbers from the organisms—step by step, in plain language.

Step 1: Give every organism the same "pop quiz"

We create a set of fake scenarios—like "there's food to your left and an enemy ahead." These are just made-up sensor readings (24 numbers). Every organism gets the exact same quiz so we can compare their answers fairly.

Step 2: See what each organism would do

We feed those fake scenarios into each organism's neural network brain. The brain spits out 4 numbers—one for each action (thrust, turn, shoot, split). For example:

Step 3: Convert to percentages

We turn those raw numbers into percentages that add up to 100% (using a math function called softmax). Now the answers are easy to read:

Step 4: Measure how indecisive each one is (policy entropy)

We plug those percentages into the entropy formula. You don't need to know the math—just know that it produces a single number:

• Organism A → low entropy (~0.3) — it knows exactly what it wants. Think of a student who circles "A" without hesitation.
• Organism B → high entropy (~1.4) — it's basically guessing. Think of a student who stares at the test and randomly picks an answer.

Step 5: Check if everyone agrees (entropy variance)

Now we have an "indecisiveness score" for each of the 200 sampled organisms. We ask: "Are these scores all similar, or are they all over the place?"

• If the scores are [0.3, 0.31, 0.29, 0.3, 0.28…] → low variance → everyone behaves the same way → the population has settled on a shared strategy.
• If the scores are [0.3, 1.2, 0.8, 0.1, 1.4…] → high variance → organisms are doing their own thing → still evolving, haven't reached agreement yet.

Think of it like a classroom: low variance means everyone got roughly the same grade on the test (they all "agree"). High variance means grades are scattered from 20% to 95%—everyone is different.

Step 6: Detect Nash equilibrium

We repeat Steps 1–5 every single generation and track the entropy variance over time. When it drops below a small threshold (0.01) and stays there for 20 generations in a row—after the population has already spread out and tried different strategies—we declare that the population has reached Nash equilibrium. We record which generation that happened at. That generation number is the key result we compare between the control and experimental groups.

Step 7: Compare the two groups with statistics

After running many experiments in both the control and experimental groups, we have a list of convergence generation numbers for each group—for example, the control group might converge at generations [230, 241, 225, 238, …] and the experimental group at [210, 195, 208, 193, …]. We use a standard statistical test (Welch's t-test) to answer one question: "Is the difference between these two lists real, or could it be just luck?"

• The p-value tells us the probability that the difference happened by random chance. A very small p-value (like 0.001) means there's only a 0.1% chance the result is a fluke—so we're confident the difference is real.
• The effect size (Cohen's d) tells us how big the difference is. A small p-value says "the difference is real"; the effect size says "and the difference is large" (or small, or medium).

The dashboard displays all of these results automatically as experiments finish—the convergence generation for each experiment, the statistical comparison between groups, and the conclusion of whether the hypothesis is supported.

After running hundreds of experiments in both the control and experimental groups, we need to answer two questions: "Is the difference real?" and"How big is the difference?" We use two standard scientific tools to answer them.

Welch's t-test: "Is the difference real, or just luck?"

Imagine you have two coins. You flip each one 100 times. Coin A lands on heads 53 times and Coin B lands on heads 58 times. Is Coin B actually weighted differently, or did it just get lucky? That's exactly what a t-test answers.

In our experiment, the "coins" are the two groups (control vs. experimental), and the "number of heads" is the generation number where each experiment converged. We collect all the convergence generations from each group and ask: is the average different enough that it probably isn't a coincidence?

The t-test gives us a p-value. Think of the p-value as a "suspicion meter":

• p = 0.50 — 50% chance the difference is just random noise. Not suspicious at all. We'd say "there's no real difference."
• p = 0.05 — Only a 5% chance it's luck. That's the standard cutoff in science. Below this, we call it statistically significant.
• p = 0.001 — Only a 0.1% chance. Very strong evidence the difference is real.
• p = — the p-value from our actual experiment (computed live from the database). In plain language: .

We use Welch's version of the t-test (rather than the basic Student's t-test) because it doesn't assume the two groups have the same amount of spread in their data. Since our control and experimental groups might vary differently, Welch's is the safer, more accurate choice.

Cohen's d: "Okay, the difference is real—but how big is it?"

A p-value tells you whether a difference exists, but not how much it matters. With enough data, even a tiny, meaningless difference can be "statistically significant." That's where Cohen's d (the effect size) comes in.

Think of it this way: imagine measuring the height of students in two classrooms. Cohen's d answers: "If I pulled a random student from each classroom, how obvious would the height difference be?"

• d < 0.2 (Negligible) — You wouldn't notice the difference. Like comparing heights of two random groups of the same age.
• d = 0.2–0.5 (Small) — You'd notice if you looked carefully. Like comparing the heights of 13-year-olds to 14-year-olds.
• d = 0.5–0.8 (Medium) — Clearly noticeable. Like comparing the heights of 12-year-olds to 15-year-olds.
• d > 0.8 (Large) — Obvious to anyone. Like comparing the heights of 10-year-olds to adults.

Our experiment's Cohen's d is (computed live from the database), which puts the effect .

Putting it together

Earlier (in the "Why We Use the Same Seed" box near the top of this page) we mentioned that we start the control and experimental groups from the same random seed so that the comparison is fair. That idea is so central to this project that it deserves its own section. The dashboard's Seed Pair Progress card and Paired Seed Comparison scatter plot are not just nice visualizations — they are how this experiment turns a difference of opinion ("I think adaptive mutation is faster") into a result that the scientific method can actually test.

What is a seed pair?

A seed is just a number that locks in every random choice the simulation makes — the starting positions of the 1,000 organisms, the initial weights inside their neural-network brains, where food pellets spawn, and so on. Two experiments started with the same seed face mathematically identical worlds.

A seed pair is a matched set of runs at the same seed: one Control run (fixed mutation) and one Experimental run (adaptive mutation). Because both runs faced the same starting brains, the same food layout, and the same random events, the only thing that can differ between their outcomes is the one variable we deliberately changed: the mutation strategy.

Why seed pairs prove data integrity

Imagine running two experiments on different days, with different starting brains and different food layouts. The Experimental run converges at generation 200 and the Control at 230. Was the difference caused by adaptive mutation — or did the Experimental run just get lucky with where the food spawned? You cannot tell. That is called a confounded result, and it is what bad science looks like.

Seed pairs eliminate that confound completely. Both runs in a pair start in the same world. If the Experimental run still finishes first, the only thing that could have caused the difference is the mutation strategy. This is what makes our data trustworthy: every comparison is apples-to-apples by construction, not by luck.

This is the textbook definition of a controlled experiment: hold everything constant except the one variable you are testing. The seed is what lets us do that with computational precision — far more cleanly than is usually possible in biology, psychology, or medicine.

Why pairs make the hypothesis testable by the scientific method

The scientific method demands a falsifiable hypothesis — one that could be shown wrong if the data went the other way. Our hypothesis is specific: at the same seed, adaptive mutation will reach Nash equilibrium in fewer generations than fixed mutation. Because each seed pair is a head-to-head comparison under identical conditions, every single pair is a tiny, complete test of that hypothesis. If adaptive mutation had no real advantage, we would expect the Experimental run to win on roughly half the pairs and lose on the other half (random tie). The fact that it wins on the vast majority is direct evidence against the null hypothesis.

We don't trust just one pair — the strength tiers

Even within a single seed, the same code can produce slightly different convergence generations from one run to another. That is because the GPU runs thousands of calculations in parallel, and tiny floating-point ordering differences can nudge the trajectory of evolution. So instead of comparing one CTRL run to one EXP run at each seed, we run several of each and average them.

The dashboard sorts seeds into four tiers based on how many converged runs each side has:

• Strong (≥30 each side) — rock-solid. The averaged convergence generation has very little room left for noise.
• Acceptable (10–29 each side) — enough data to compare with confidence. We treat ≥10 each as the minimum threshold for a viable pair.
• Weak (1–9 each side) — usable, but the seed's mean still wobbles. These pairs contribute less weight.
• Unpaired — only one side has converged data. We can't compare yet, so this seed is excluded from the paired analysis.

That is what the "X/Y paired seeds" counter on the dashboard is tracking: how many seeds have crossed the bar to count toward the headline result.

How seed pairs make the statistical analysis stronger

Section 16 explained Welch's t-test, which compares the two big lists of convergence generations — all controls vs. all experimentals. That test is valid, but it has to fight through a lot of noise: some seeds are just naturally harder than others, and that seed-to-seed variation gets thrown into the mix.

Because every seed in our experiment is matched, we can also run a paired t-test. Instead of comparing two big lists, the paired t-test looks at the difference within each pair and asks: are these per-pair differences consistently away from zero? Two seeds with very different absolute convergence generations — say (220 vs 195) and (240 vs 215) — both have the same difference of −25, and the paired test sees that consistency clearly.

Cohen's d for the paired test (sometimes written d_z) is computed from the per-pair differences: the mean difference divided by the standard deviation of those differences. A small standard deviation of differences means the per-seed gaps cluster tightly around a single value, which is even stronger evidence than a large average alone could provide.

What about outliers? Sometimes the control wins

On the Paired Seed Comparison scatter plot, every dot is one matched seed. The diagonal line is "tied." Dots below the diagonal are seeds where adaptive was faster; dots above are seeds where the control was faster. The dashboard reports both counts honestly — in the current data, roughly of pairs go the adaptive way, but a small fraction (about ) come back the other direction.

That is not a flaw — that is what real data looks like.Adaptive mutation is a probabilistic advantage, not a guarantee. On any particular seed, several things can flip the comparison:

• The random starting brains for that seed might already sit close to a stable equilibrium, in which case the small fixed mutation rate happens to nudge them in gently while adaptive mutation's larger early-generation steps temporarily push them away before settling.
• The food and predation dynamics for that particular world might happen to reward less exploration, so adaptive mutation's extra exploration becomes a slight cost rather than a benefit.
• At very low pair counts (a Weak-tier seed with only 1–2 runs each side), the seed mean still has noise of its own and a single unlucky run can flip the direction of that pair.

The paired t-test does not ask "does adaptive win every time?" It asks "across all paired seeds, is the average difference different from zero?" With of pairs leaning the adaptive way and a mean difference of generations, the paired test's current verdict on the live data is: , with the effect size . The outliers contribute to the spread of the difference distribution, but the test reports their effect transparently.

One of the most common (and most healthy) reactions to the headline result on the dashboard is some version of: "Wait. Adaptive doesn't win every seed. And the dashboard is showing more control runs converging than experimental runs. How can you still claim adaptive is better?" That is exactly the right question to ask, and answering it properly is what separates a result you should trust from a result you should question. This section addresses the disparity head-on and shows the actual math, with every number computed live from the running database.

Acknowledging the disparity honestly

There are two real disparities in the data right now:

• Pair-level losses. . The losses are not a glitch — they are part of the natural variance of evolution.
• Convergence-rate gap. . Some of this is sampling lag (the queue prioritizes filling the slowest seed first), but even taking it at face value, it does not change the conclusion below.

The argument we are about to make is: even if you take both of those observations at their worst, the paired analysis still overwhelmingly supports adaptive mutation. We will show this four different ways: a model-free sign test, a paired t-test with confidence interval, a sensitivity analysis that throws away the most favorable wins, and a raw magnitude argument.

Step 1 — The sign test (no math required)

Forget about how much faster adaptive is for a moment. Just count, across all matched seeds, how often it finishes first. If the two strategies were equally good, that count should look like flipping a fair coin once per seed: about half wins, half losses, give or take random luck.

What we actually see is . The sign test makes noassumptions about distributions, normality, or magnitudes — it just counts directions, and the direction it counts is currently . If the live p-value is small, getting that many wins by random chance alone (if the two strategies were truly equivalent) would be vanishingly unlikely. If it ever rises, this paragraph will reflect that.

Step 2 — The paired t-test (now using the magnitudes)

The sign test ignores how large each gap is. The paired t-test fixes that: it asks whether the average size of the per-pair difference is far enough from zero to be unlikely under the null hypothesis "the two groups are equivalent."

Live result: . By Cohen's convention, d_z values above 0.8 are considered "large"; the current paired effect size sits . And we are not just relying on a single point estimate — we get . The lower bound of that interval is currently .

On the proportion side, a Wilson 95% confidence interval for the true win-rate (the probability that adaptive will beat control on a fresh seed) lands at . That lower bound is currently .

Step 3 — Sensitivity: what if the biggest wins are flukes?

A reasonable skeptic might worry that the average is being carried by a few seeds where adaptive happened to win huge, and that the "real" population difference is much smaller. So let's deliberately throw away those wins and run the paired t-test again, on the remaining (less favorable) data:

The pattern in that table is the point. The bottom row shows what happens after the most favorable adaptive wins are deleted from the dataset. If the remaining differences still produce small p-values and a non-trivial mean gap, the result is not propped up by a handful of lucky seeds — it is a population-wide phenomenon. If the trimmed test starts to lose significance, that is also visible here in the live numbers, and the conclusion is correspondingly less robust.

Step 4 — The raw magnitude argument

Forget statistics for a moment and just look at the raw arithmetic. If you sum up every generation that adaptive shaved off relative to control across every winning pair, and separately sum up every generation that control shaved off relative to adaptive across every losing pair, you get one of the most striking numbers on the dashboard:

For colour, the extreme pairs are: .

What about the convergence-rate gap?

The other disparity is that, as of the moment you load this page, the two sides may have different numbers of converged runs (see the live counters above). There are two things to say about this. First, the headline paired analysis specifically only uses seeds where both sides have converged data — so the count gap cannot bias that comparison. Second, looking just at the matched seeds where the comparison is fair: .

In other words: convergence-count differences are mostly a function of which experiments the queue has scheduled to completion at this moment in time, not a statement about whether adaptive runs are failing to converge. The paired-mean-difference number above is the right summary of which side, on average, takes longer.

Putting it together

All of the numbers in this section are computed from the live database every time you load this page. As the experiment continues to run, the specific values above will shift slightly — what won't shift is the conclusion they support.

Two statistical concepts appear frequently on the results dashboard: the Interquartile Range (IQR) and the 95% Confidence Interval (CI). Both describe "spread," but they answer very different questions.

IQR: "Where did the middle 50% of experiments land?"

Imagine lining up every converged experiment from fastest to slowest. The first quartile (Q1) is the point where 25% of experiments finished faster, and the third quartile (Q3) is where 75% finished faster. The gap between them is the IQR:

A small IQR means most experiments converged around the same generation—the process is consistent. A large IQR means there was more variability in how long experiments took.

95% Confidence Interval: "How sure are we about the true difference?"

Our experiments are a sample—we ran , but we could theoretically run millions. The confidence interval gives us a range where the true average difference between control and experimental almost certainly lives.

On the live data, the 95% CI for the mean per-pair difference is currently generations. That reads as: "We are 95% confident the true average difference in convergence speed is between and generations."

One question people often ask is: "Why do you need computers to do the statistics? Can't you just look at the numbers?" The short answer is that the dataset is far too large for any human to process by hand.

How much data does one experiment produce?

Each experiment runs 1,000 organisms for up to generations, with each generation comprising 750 simulation ticks (steps). That means a single experiment involves:

At every tick, each organism's 1,860-weight neural network processes 24 sensor inputs and produces 4 action outputs. All of these weights, inputs, and outputs are numbers that contribute to the statistics.

How much data does the full study produce?

We don't run just one experiment—we run of them to achieve statistical significance. That multiplies the numbers above dramatically:

Each generation also logs a row of statistics (average fitness, peak fitness, policy entropy, entropy variance, mutation rate, population diversity). With .

Why computers are essential

With this volume of data, doing the analysis by hand would be impractical:

• Running the simulation itself requires a GPU (graphics processing unit) because 1,000 neural networks need to make decisions simultaneously, 750 times per generation. A GPU can process all 1,000 agents in parallel; a human calculator would take years per experiment.
• Computing entropy variance requires evaluating each organism's neural network on sample inputs, applying softmax, calculating Shannon entropy, and then computing the variance across all 200 sampled organisms—every single generation. That's tens of thousands of entropy calculations.
• Statistical testing across experiments means computing Welch's t-test, Cohen's d, bootstrap confidence intervals (10,000 resamples), normality checks (Shapiro-Wilk), and power analysis. Each of these involves hundreds or thousands of mathematical operations.
• Real-time monitoring on the dashboard requires the database to query, aggregate, and return data for charts and tables in under a second—something only possible with a proper PostgreSQL database and a web application.

In short, this experiment produces an enormous volume of data, and every layer—from running the simulation to detecting convergence to testing the hypothesis—relies on computational power that would be impossible to replicate by hand.

This experiment sits at the intersection of three powerful fields: evolutionary computing^{[10, 11, 12]} (improving AI through trial and error over generations), game theory^{[3, 4, 5]} (understanding strategic decision-making when multiple agents interact), and neural networks^{[6, 8, 9]} (giving agents brains that can process information and make decisions). That combination isn't just academic—it has direct applications to some of the most important challenges facing humanity.

Real-World Applications

• Autonomous vehicles and robotics: Self-driving cars must constantly make decisions in a world full of other drivers, pedestrians, and cyclists—all making their own decisions simultaneously. This is exactly the kind of multi-agent game theory problem our experiment studies. If adaptive mutation helps populations of AI agents find stable strategies faster, that same principle could help robot fleets (warehouse robots, delivery drones, self-driving trucks) learn to coordinate efficiently without crashing into each other.
• Economics and market design: Stock markets, auctions, and supply chains are all systems where many agents (traders, companies, consumers) interact strategically. Economists use Nash Equilibrium to predict market outcomes. Our experiment tests whether there are faster ways to find these equilibria—which could help design fairer auction systems, more efficient markets, or better pricing algorithms.
• Drug discovery and protein design: Pharmaceutical companies use evolutionary algorithms to search through billions of possible molecular structures to find effective drugs. The question of "how much should we mutate?" is directly relevant—adaptive mutation could help these searches converge on promising drug candidates faster, potentially saving years of research time.
• Climate and resource management: Managing shared resources (fisheries, forests, water supplies) involves many stakeholders making independent decisions. Game theory helps model these "tragedy of the commons" situations. Understanding how populations converge to stable strategies could inform policies that help communities reach sustainable equilibria faster.
• Multi-agent AI systems: As AI becomes more common, we increasingly have situations where multiple AI systems interact—chatbots negotiating, trading algorithms competing, or recommendation systems influencing each other. Understanding how populations of AI agents reach equilibrium is crucial for ensuring these systems behave predictably and safely.
• Cybersecurity: Attackers and defenders in cybersecurity are engaged in a constant strategic game. Evolutionary approaches to security (where defense strategies evolve in response to attacks) could benefit from adaptive mutation to find robust defense strategies more quickly.

Why Adaptive Mutation Matters Beyond This Experiment

The core question—"should we change things more when they're not working and less when they are?"—is fundamental to optimization everywhere. Currently, most evolutionary algorithms use fixed mutation rates, which is like always turning every knob by the same amount regardless of whether you're close to a good solution or far away. If our experiment demonstrates that adaptive mutation accelerates convergence, that finding could be applied to:

• Training neural networks more efficiently (reducing the enormous energy cost of training large AI models)^{[13, 14]}
• Optimizing engineering designs (aircraft wings, circuit layouts, antenna shapes) faster^[11]
• Evolving game-playing AI (like AlphaGo's successors) with less computational cost^[26]
• Accelerating scientific simulations that use evolutionary search methods^{[17, 18]}

How This Experiment Could Be Expanded

This kind of experiment could grow in many directions. We could use bigger or more complex worlds (3D environments, multiple food types, predator-prey ecosystems), larger populations or bigger neural networks, or entirely different mutation strategies (for example, letting the organisms learn their own mutation rate over time). We could also introduce cooperation (organisms that work together to hunt) or communication (organisms that signal to each other), creating richer game-theoretic scenarios. The goal is to show that evolutionary game-theoretic experiments can scale from a science fair project to tools that benefit both scientific research and real-world industry.

EvoNash is fully open-source. If you would like to reproduce this experiment—or run your own variation of it—everything you need is on GitHub:

github.com/jdefouw/EvoNash

What You Need

• An NVIDIA GPU with CUDA support — any modern NVIDIA card will work (e.g. RTX 2060 or newer). The simulation runs entirely on the GPU, so a dedicated graphics card is required. An RTX 3090 is recommended for fastest results.
• Python 3.8+ with PyTorch (CUDA version) — this powers the simulation worker.
• Node.js 20+ and PostgreSQL 16 — these run the web dashboard and store experiment data.

Quick Start (3 Steps)

git clone https://github.com/jdefouw/EvoNash.git
cd EvoNash

# Install PostgreSQL, create a database, and apply the schema
psql -U evonash -d evonash -f web/lib/sql/schema_standalone.sql

cd web
npm install
cp .env.example .env   # then edit .env with your database connection string
npm run build
npm start

# Install PyTorch with CUDA (see https://pytorch.org for your CUDA version)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128

cd worker
pip install -r requirements.txt
# Edit config/worker_config.json — set controller_url to your dashboard URL
python run_worker.py

Running Your Own Experiments

Once the dashboard is running and the worker is connected, open the dashboard in your browser, navigate to Experiments → New Experiment, and create experiments in both the Control and Experimental groups. Use the same random seed for each pair (e.g. 42) so the only difference is the mutation strategy. For statistically meaningful results, run at least 5 experiments per group with different seeds.

The dashboard will automatically compute convergence generation, peak fitness, and statistical comparisons (t-tests, effect sizes) as data comes in. You can watch the experiments progress in real time.

Contribute or Extend

Contributions are welcome! Some ideas for extensions: try different neural network architectures, experiment with new mutation strategies (e.g. self-adaptive rates), add cooperation mechanics, or scale to larger populations. See the project PROJECT_SPEC.md for the full technical specification.