Experiments

Tractable Research Program

Phase 1: Accelerating Complexity

Experiment 1.1: Spatial Heterogeneity

Implementation:

• Divide soup into regions (e.g., 4 quadrants)
• Each region has different "nutrients"—tape values that aid replication
• Programs that migrate between regions face different selection pressures

// Modify soup.ts: add region-specific fitness bonus
getRegionBonus(x: number, y: number): number {
  const region = Math.floor(x * 2) + Math.floor(y * 2) * 2;
  const bonusChar = ['+', '-', '>', '<'][region];
  return this.code.includes(bonusChar) ? 1.2 : 1.0;
}

Metrics:

• Diversity index (Shannon entropy over program population)
• Niche specialization (programs concentrated in "home" regions)
• Migration rate (programs crossing region boundaries)

Expected outcome: Higher sustained diversity than uniform soup. Specialists emerge for each region.

Experiment 1.2: Host-Parasite Coevolution

Implementation:

• Mark some programs as "parasites" (can't replicate alone, must hijack host)
• Parasite success = uses host's output for own replication
• Host success = replicates while rejecting parasite interference

// Parasite detection: does program read from external tape?
isParasitic(prog: Program): boolean {
  const result = BFF.exec(prog.code);
  return result.inputReads > result.selfReads * 0.5;
}

Metrics:

• Arms race cycles (alternating dominance between host/parasite lineages)
• Complexity growth rate (bits of functional information)
• Time to first "immunity" (hosts that reject all current parasites)

Expected outcome: Based on Avida research, expect 2-3× complexity increase vs baseline.

Experiment 1.3: Island Model

Implementation:

• Run N independent soups in parallel
• Every M epochs, migrate top K programs between islands
• Use ring topology: island i sends to island (i+1) mod N

// Island migration
migrateIslands(islands: Soup[], topK: number): void {
  const migrants = islands.map(s =>
    s.programs.sort((a,b) => b.replicated - a.replicated).slice(0, topK)
  );
  islands.forEach((s, i) => {
    const source = (i - 1 + islands.length) % islands.length;
    s.programs.push(...migrants[source].map(p => ({...p})));
  });
}

Metrics:

• Inter-island diversity (how different are the populations?)
• Innovation spread time (how long until a successful mutation reaches all islands?)
• Global vs local optima (does migration help escape plateaus?)

Phase 2: Environmental Coupling

Experiment 2.1: External Resource Mapping

Implementation:

• Reserve tape region [200-255] as "environment"
• Environment contains "food" values that vary over time
• Programs that read food addresses and write to "claim" addresses get replication bonus

// Environmental food that changes every N epochs
updateEnvironment(tape: Uint8Array, epoch: number): void {
  const phase = Math.floor(epoch / 100) % 4;
  const foodAddr = 200 + phase * 10;
  tape.fill(0, 200, 256);
  tape[foodAddr] = 255; // current food location
}

Metrics:

• Food tracking rate (do programs "follow" moving resources?)
• Environment-dependent behavior (same program acts differently based on tape state)

Experiment 2.2: Predictable Patterns

Implementation:

• Environment follows simple pattern: A → B → C → D → A (cycle)
• Programs get bonus for being at the next food location before it activates
• This requires "prediction"—internal state that tracks pattern

Metrics:

• Anticipation rate (programs at next location before transition)
• Reaction time (epochs between environment change and program response)
• Pattern encoding (can we find internal state tracking the cycle?)

Experiment 2.3: Within-Lifetime Adaptation

Implementation:

• Track individual program execution over time
• Measure "efficiency" = successful outputs / total instructions executed
• Does efficiency improve as the program runs longer?

// Track execution efficiency over time
measureAdaptation(prog: Program): number[] {
  const efficiencies = [];
  for (let window = 100; window <= 1000; window += 100) {
    const result = BFF.exec(prog.code, [], window);
    efficiencies.push(result.output.length / window);
  }
  return efficiencies; // should increase if learning
}

Key metric: Efficiency slope. Positive slope = within-lifetime improvement. Zero/negative = no learning.

Phase 3: Abstraction Tasks

Experiment 3.1: Simple Transformations

Task examples (simplified ARC):

• Increment: Input [1,2,3] → Output [2,3,4]
• Reverse: Input [1,2,3] → Output [3,2,1]
• Double: Input [1,2,3] → Output [2,4,6]

// Score program on transformation task
scoreTransform(prog: Program, input: number[], expected: number[]): number {
  const result = BFF.exec(prog.code, input);
  let matches = 0;
  for (let i = 0; i < expected.length; i++) {
    if (result.output[i] === expected[i]) matches++;
  }
  return matches / expected.length;
}

Experiment 3.2: Transfer Learning Test

Example (increment family):

• Training: increment-by-1, increment-by-2, increment-by-3
• Test: increment-by-4 (never seen)

If programs solve unseen variants, they've abstracted the concept of incrementing, not just memorized specific cases.

Metrics:

• Training accuracy (expected to be high)
• Transfer accuracy (the key measure—should be above chance)
• Generalization gap (training - transfer accuracy)

Experiment 3.3: Novelty Search for Abstraction

Novelty metric:

Where \(\mu_i\) are k-nearest neighbors in behavior space. Higher sparseness = more novel behavior.

Behavior characterization:

• Not just output, but how program produces it
• Tape access patterns, loop structures, instruction frequencies
• Behavioral "fingerprint" that captures program's strategy

Hypothesis: Novelty search finds programs that solve tasks via abstraction rather than memorization, because memorization is "easy" (not novel) while abstraction is "rare" (novel).

Measurement Framework

Distinguishing Learning from Evolution

Operational definition:

Signal	Evolution	Learning
Timescale	Across generations	Within lifetime
Entity	Population improves	Individual improves
Mechanism	Selection + variation	Internal state update
Transfer	Offspring inherit	Same entity applies elsewhere

Key Metrics Summary

Getting Started

Next Steps