Polynomial Discovery

Multi-agent simulation where autonomous agents collaboratively learn a hidden cubic polynomial through noisy observations and peer-to-peer communication.

Problem

Multiple independent “scientist” agents attempt to discover a hidden cubic polynomial:

f(x) = ax³ + bx² + cx + d

What agents know:

• The functional form is cubic (4 parameters to learn)
• They can sample x values from [-1, 1]

What agents DON’T know:

• The true coefficients (a, b, c, d)
• They only observe noisy measurements: y = f(x) + noise

Evaluation:

• MSE is measured against the hidden ground-truth function on a dense evaluation grid
• This is an “oracle” metric - agents cannot compute it themselves

Agent Architecture

Each agent runs an asynchronous loop (not synchronized with other agents):

1. Sample: Draw random x, observe noisy y
2. Fit: Periodically refit model parameters using least squares
3. Receive: Process messages from peers (model parameters)
4. Integrate: Blend peer models with own (if peer seems better)
5. Send: With probability COMM_PROB, share model with a random peer

Installation

pip install -r requirements.txt

Usage

Basic Run

python independent_scientists_academy.py

Configuration via Environment Variables

export N_AGENTS=16
export COMM_PROB=0.12
export TOPOLOGY=ring    # ring | random | all
export STEPS=300
python independent_scientists_academy.py

Comparison Scripts

# Compare communication strategies (none vs ring vs random)
python compare_communication.py

# Compare across different hidden functions
python compare_problems.py

# Test scaling with agent count (1, 2, 4, 8, 16, 32, 64)
python compare_agent_counts.py

Sample Results

Single Run Dashboard (16 agents, 300 steps)

This shows:

• Top-left: MSE over time (best, median, worst agents)
• Top-right: Individual agent MSE trajectories
• Bottom-left: Model diversity decreasing as agents converge
• Bottom-right: Final agent models overlaid on true function

Communication Strategy Comparison

Comparing no communication vs ring topology vs random topology:

Key finding: Communication dramatically reduces worst-case performance. Random topology gives slightly better average performance due to shorter path lengths.

Performance Across Different Problems

Tested across 6 different hidden cubic functions:

Win rates (best median MSE per problem):

• Random (12%): 4/6 wins (67%)
• Ring (12%): 2/6 wins (33%)
• No Communication: 0/6 wins (0%)

Agent Count Scaling

Key findings:

• Sweet spot around 8-16 agents
• Linear message scaling (~88 msgs/agent)
• Best agent keeps improving with more agents
• Diminishing returns on median performance after ~16 agents

Key Insights

1. Communication helps most for worst-case: Isolated agents can get stuck in local minima; peer information helps escape

2. Random topology > Ring topology: Shorter average path length allows faster information spread across the network

3. Sparse communication is sufficient: 12% send probability (~80 messages per agent) provides most of the benefit

4. Asynchronous operation works: No need for synchronized steps; agents learn effectively at their own pace

5. Scaling efficiency: More agents help exploration, but communication overhead grows linearly

Files