EvoNash: A Distributed Computing Platform for the Convergence of Genetic Neural Networks to Nash Equilibrium

EvoNash is an open-source scientific experiment platform developed by jdefouw. It combines evolutionary algorithms, game theory, and distributed high-performance computing to test a core hypothesis: whether adaptive mutation rates (based on fitness) can accelerate the convergence of neural network groups to Nash equilibrium compared to fixed mutation rate strategies. The platform provides a complete experimental infrastructure, including a web dashboard for monitoring and analysis, GPU workers for distributed simulation, and statistical tools for result validation. Below are detailed breakdowns of its research problem, design, and implementation.

Background

EvoNash addresses a key question in evolutionary computation and multi-agent systems: how mutation rate strategies affect the convergence of neural network groups to Nash equilibrium.

Core Hypothesis

If a neural network's mutation rate (ε) is inversely proportional to its parent's fitness (low fitness parents produce high-mutation offspring; high fitness parents produce stable offspring), the group will converge to Nash equilibrium in fewer generations than a control group using fixed mutation rates.

Experimental Design

The platform uses a controlled comparison design with two groups:

• Control Group: Fixed mutation rate (ε = 0.05 for all offspring).
• Experimental Group: Adaptive mutation rate (ε = base value × (1 − current Elo/max Elo)).

Both groups use identical initial conditions (same random seeds, agent brains, and world layout) to ensure fair comparison.

System Architecture

EvoNash has three layers:

1. Web Dashboard: Built with Next.js14, TailwindCSS, and Recharts—supports real-time monitoring, statistical analysis (t-tests, effect size), and worker management.
2. GPU Workers: Python + PyTorch with CUDA for distributed simulation on NVIDIA GPUs.
3. Data Layer: PostgreSQL16 for storing experiment data, generation metrics, and worker telemetry.

Simulation Environment

The simulation is a deterministic 2D continuous ring space (no walls) with:

• 1000 neural network-controlled agents and food particles.
• Core mechanisms: Energy decay (metabolism), foraging (eating food), and predation (stealing energy via projectiles).
• Generation length: 750 ticks (~12 seconds of agent lifespan).

Neural Network Architecture

Each agent's network:

• Input layer (24): 8 rays × 3 values (food distance, enemy distance, boundary distance).
• Hidden layer (64): ReLU activation.
• Output layer (4): Thrust (0-1), steering (-1 to +1), shooting (0-1), splitting (0-1).

Fitness Function

Fitness = Survival ticks + Remaining energy (max score: 900 for full survival +150 energy). This drives selection (top 20% reproduce), mutation scaling, and analysis.

Evaluation Metrics

• Main Metric: Convergence speed (number of generations to reach Nash equilibrium).
• Secondary Metrics: Peak fitness (max score), strategy entropy (group decision randomness).

Nash Equilibrium Detection

Convergence is detected when the variance of group strategy entropy stays below 0.01 for 20 consecutive generations, followed by a 30-generation buffer to confirm stability.

Statistical Analysis

The dashboard auto-computes:

• Welch's t-test (compare convergence generations between groups).
• Cohen's d (effect size).
• Power analysis (sample size planning).
• Box plots (visualize convergence distribution).

Experiment Scale Suggestions

Power Level	Number of Experiments per Group	Generations	Reliability
Minimum	1+	500+	Basic analysis
Recommended	2+	1000+	Reproducible results
Robust	5+	2000+	Publication-ready

Technical Optimizations

• CUDA Acceleration: GPU workers use CUDA for 10-50x speedup while maintaining scientific equivalence.
• Determinism: Same random seed always produces identical results, ensuring reproducibility.
• Distributed Coordination: Web dashboard and workers communicate via HTTP API for dynamic registration and task allocation.

Tech Stack Summary

• Frontend: Next.js14, TailwindCSS, Recharts.
• Backend: Node.js20+, Express, PM2.
• AI Engine: Python3.8+, PyTorch, CUDA.
• Database: PostgreSQL16.
• Deployment: Debian, nginx.
• Hardware: NVIDIA GPU (recommended RTX3090).

Application Scenarios

EvoNash is useful for:

1. Evolutionary algorithm research (testing selection/mutation/cross strategies).
2. Game theory experiments (verifying multi-agent equilibrium convergence).
3. Neuroevolution (studying neural network evolution dynamics).
4. Distributed computing teaching (hands-on HPC projects).
5. Scientific methodology training (controlled experiments + statistical analysis).

Project Value

EvoNash is more than a tool—it's a complete research platform. It translates theoretical hypotheses into executable experiments and provides rigorous statistical validation. Its open-source nature allows researchers to modify parameters and adapt it to their needs, while the distributed architecture makes large-scale experiments affordable and accessible.

Conclusion

EvoNash integrates complex theoretical models, high-performance computing, and strict statistical analysis into an open-source framework. It serves as a solid foundation for academic research, teaching, and algorithm validation in evolutionary computation and multi-agent systems.