Project Retrospective: Golden Cascade / Cell Soup / Evolved ML

March 11, 2026 · View on GitHub

Date: 2026-03-10 Scope: 20 phases + Phase A + 6 ML Insight tests + cascade component tests + signal conditioner tests Duration: 2026-02-19 through 2026-03-09 (18 days) Review team: Fresh retrospective, no prior involvement

Section 1: Executive Summary

What the project was about

This project attempted to build hierarchical computation from first principles: golden cascade cells (single-pole low-pass filters with phi-based dynamics) placed in an open thermodynamic environment where cells earn food by being useful, reproduce when wealthy, and die when broke. The hypothesis was that economic pressure would drive the emergence of deep, layered computation -- a self-organizing neural network from biology-inspired predictive coding elements.

The project spanned 20 numbered phases, a consensus neural network phase (Phase A), 6 practical ML insight tests, cascade component tests across 4 ML roles (activation, normalization, RNN, signal conditioner), 2 viability analyses, and a final team retrospective. Total estimated compute: 10-15 hours across 18 calendar days. The project evolved from pure mathematical exploration (Phases 1-3) through self-organizing cell soup dynamics (Phases 4-14) to organism-level evolution (Phases 15-17) to open thermodynamic graph evolution (Phases 18-20) and finally practical ML extraction (Phase A, ML Insights).

What was actually discovered

The primary hypothesis failed comprehensively. Surprise-minimization does not produce useful representations. The golden ratio has no special properties as a hyperparameter. The golden cascade cell has no advantage over plain tanh. The cell soup architecture hits a fundamental "circuit half-life" ceiling where cell turnover destroys multi-layer circuits faster than they can form.

However, the project produced a strong negative-result portfolio and three genuine insights: (1) representation determines evolutionary success ( $10^{23}$ x improvement from switching register machines to computational graphs), (2) MI-based fitness eliminates degenerate solutions, and (3) viability analysis before experimentation is dramatically more cost-effective than experimentation alone.

Two modest practical findings survived testing: surprise-gated learning rate provides training stability (83.0% vs 80.2% cosine on MNIST, eliminates catastrophic seed failures), and settling is essential for stateful neurons (+49.4pp for EMA-based networks). Neither has been validated beyond small-scale MNIST.

Was it worth it

Partially. The negative results are rigorous and valuable -- they close off an entire line of inquiry with quantitative evidence. The representation insight is genuinely important for evolutionary computation. But roughly 50-60% of the compute was avoidable with better upfront mathematical analysis, and the two practical findings are too small and untested at scale to constitute a meaningful ML contribution yet.

One-paragraph honest assessment

This was a well-executed exploration of an ultimately unproductive hypothesis, redeemed by rigorous falsification and a few transferable insights about evolutionary search. The project demonstrated excellent scientific methodology -- pivoting when evidence demanded it, running proper controls and ablations, quantifying everything -- but it also demonstrated the cost of not doing mathematical feasibility analysis first. The golden cascade, the golden ratio, surprise-minimization, and the room mechanism are definitively dead as ML techniques. The surviving findings (surprise-gated LR, settling for stateful neurons) are interesting but modest, and their connection to the original golden cascade theory is tenuous at best. A PhD committee would say: thorough work, honest conclusions, but the core contribution is primarily negative results plus one good theoretical insight about representation design.

Section 2: What We Definitively Proved (with Evidence)

2.1 MI-based reward kills degenerate solutions

Claim: Using mutual information as an evolutionary fitness signal eliminates constant-output and trivial-relay attractors that plague correlation-based fitness.

Evidence: Phase 18b: 100% of surviving cells have MI > 0.1 within 1000 ticks. Constants die in ~47 ticks. Phase 20: no constant-output organisms in any final population across 9 runs. Correlation-based fitness (Phase 18) allowed constants to survive via slowly-varying signal correlation.

Why it matters: This is a genuine contribution to evolutionary computation. Any open-ended evolutionary system that uses correlation-based fitness risks convergence to trivial solutions. MI as fitness is a clean fix. However, this was already known in the information-theoretic fitness literature (Polani 2009, empowerment framework).

Confidence: HIGH. Replicated across 18 runs (9 in Phase 18b, 9 in Phase 20), multiple conditions, zero counterexamples.

2.2 Representation determines evolutionary success ( $10^{23}$ x)

Claim: Switching from register machine programs to computational graphs produced a $10^{23}$ x improvement in evolutionary search efficiency, resolving every barrier from 5 prior phases.

Evidence:

Register machines: 4.72 x $10^{33}$ search space, 9.8% non-constant, 10 million expected generations to find product (Viability Analysis V1)
Computational graphs: 8.7 x $10^{10}$ search space, 68.1% non-constant, 1-2 expected generations (Viability Analysis V2)
Phase 17: MULTIPLY found in <10 generations with graph-like ops (15/15 seeds)
Phase 20: ADD discovered in generation 1 across all 9 runs
Phases 18-19b: No nonlinear computation discovered in 10K+ ticks with register machines

Why it matters: This is the strongest finding in the project. It quantitatively demonstrates that no amount of evolutionary tuning, reward shaping, or mechanism refinement can compensate for a representation that lacks composable, independently mutable building blocks. This insight is well-known in GP (tree GP >> linear GP since Koza 1992), but the $10^{23}$ x quantification in a specific system is striking.

Confidence: HIGH. Supported by both mathematical analysis (viability tests V1, V2) and empirical results (Phases 17-20). The viability predictions matched actual outcomes.

2.3 Evolution consistently finds minimum-effort solutions

Claim: In every experiment, evolution discovered the simplest function that maximizes fitness and locked in, never exploring more complex alternatives.

Evidence:

Phase 15: Locks onto difference (linear, r=0.9997), ignores all nonlinear functions
Phase 16: Locks onto maximum (piecewise-linear) when linear functions removed
Phase 18b: Locks onto relay (LOAD+STORE), best evolved MI=0.787
Phase 20: Locks onto ADD(ch0, ch1), linear combiner at 1.49 bits vs optimal 2.60 bits
Phase 14: Integrator cells converge to minimum-surprise strategy, attending to most predictable input

Why it matters: This constrains fitness function design for any evolutionary system. If the fitness landscape has a simpler shortcut, evolution takes it. The desired behavior must BE the minimum-effort solution, or evolution will find something else. This is well-known in evolutionary computation but empirically demonstrated across 5+ independent experiments here.

Confidence: HIGH. Universal across all experiments; zero counterexamples.

2.4 Consensus improves classification but is just ensembling

Claim: Multiple cells per position (K>1) improve accuracy through averaging, but standard ensembling of independent networks dramatically outperforms shared-weight consensus.

Evidence:

Phase A: K=1 = 33.0%, K=3 = 42.1%, K=5 = 44.2% (under surprise learning)
ML Insights Test 1: Consensus K=5 = 71.4% vs Ensemble of 5 independent K=1 = 81.8%
Single K=1 network: 75.9%
Ensemble wins by +10.4pp because independent networks explore more of the loss landscape
K=7 (39.6%) performed worse than K=5 (44.2%), suggesting diminishing returns from consensus

Why it matters: It doesn't, particularly. This confirms a well-known result: ensemble diversity matters more than ensemble size. The shared weight matrix in consensus limits the diversity of the K cells, making them less effective than independently trained networks despite seeing the same input. The inverse-surprise weighting scheme for combining cell outputs adds computational overhead without measurable benefit.

Confidence: HIGH. Clean A/B comparison, 3 seeds, matched architectures.

2.5 Settling is essential for stateful neurons

Claim: Networks with internal state (EMA-based neurons) need multiple forward passes at inference to converge. Standard stateless neurons (ReLU) gain nothing from settling.

Evidence:

ML Insights Test 2: Consensus network T=1 = 9.9%, T=5 = 59.2% (+49.4pp). Standard ReLU: T=1 = 40.7%, T=5 = 40.5% (-0.2pp)
Phase A: T=1 = 20.1%, T=5 = 38.6% (+18.5pp)

Why it matters: This is a correct but niche design principle. It applies only to networks with internal state (Boltzmann machines, Hopfield networks, energy-based models, some recurrent architectures). It does not apply to the vast majority of deployed neural networks (feedforward with ReLU/GELU). The finding is a design guideline, not a performance improvement.

Confidence: MEDIUM. The T=1 baseline is artificially low because the network was trained with T=5, so T=1 accuracy reflects a train-test mismatch, not a genuine "no settling" baseline. A fair comparison would train separate models at each T.

2.6 Surprise-gated LR provides training stability

Claim: Scaling learning rate by per-sample prediction error (lr_effective = base_lr * clip(surprise/threshold, 0.1, 2.0)) prevents catastrophic training failures.

Evidence:

ML Insights Test 6: Surprise-gated = 83.0% (seeds: 82.3%, 81.4%, 85.4%) vs Cosine = 80.2% vs Fixed LR = 59.2% (seeds: 81.5%, 78.9%, 17.3%)
The main value is stability: no catastrophic seed (17.3%) under surprise-gating

Why it matters: Modest. The improvement over cosine is +2.8pp on MNIST with a custom architecture. This has not been tested on standard benchmarks, standard architectures, or with standard optimizers (Adam). The mechanism is similar to existing adaptive methods (focal loss, importance-weighted SGD, curriculum learning). The novelty claim is thin.

Confidence: LOW-MEDIUM. Only 3 seeds on a small MNIST subset with a custom consensus architecture. The catastrophic seed failure in fixed LR that surprise-gating prevents may be an artifact of the specific architecture. Unknown whether this generalizes.

2.7 Golden ratio 0.618 is NOT special

Claim: The golden ratio has no special properties as a decay rate, observation weight, cycling period, or any other hyperparameter in neural network dynamics.

Evidence:

ML Insights Test 5: Decay 0.618 = 57.8% +/- 30.1%, Decay 0.9 = 86.1% +/- 0.6%
Phase 12: Evolvable decay +65% over fixed golden ratio
Phase 17: Phi-cycling diversity 25x higher but fitness equal or slightly worse
Phase A: Room mechanism (phi-weighted observation) = -22pp

Why it matters: Closes off a line of speculation that consumed significant project time. The golden ratio appears in the mathematical structure of the cascade (phi-power eigenvalues) but this structure confers no practical advantage.

Confidence: HIGH. Tested across 4+ independent experiments with consistent negative results.

2.8 Golden cascade cell approximately equals plain tanh

Claim: The golden cascade cell (EMA + tanh(surprise) + room) provides no advantage over a simple tanh nonlinearity for classification or function approximation.

Evidence:

Phase 17: Plain tanh + evolved ops = +0.983 gap vs cascade + evolved ops = +0.962 gap
Phase A: Plain tanh = 61.2% vs cascade without room = 60.5%, cascade with room = 38.6%
CASCADE_COMPONENT_FINDINGS: SurpriseGate = 10.0% (random chance), CascadeNorm = 59.7% (worse than NoNorm at 72.6%), CascadeRNN = 95.2% (matches SimpleRNN at 95.1%, far below GRU at 98.6%)
SIGNAL_CONDITIONER_FINDINGS: Raw input beats cascade conditioner at every noise level

Why it matters: This is the central negative result of the project. The golden cascade cell, which motivated the entire 20-phase research arc, has no viable ML application. It was tested as an activation function (KILL, -67pp), normalization layer (KILL, -17pp), RNN cell (KILL, matches SimpleRNN), learning rule (KILL, = random features), confidence signal (KILL, AUROC 0.495), OOD detector (KILL, AUROC 0.471), and signal conditioner (KILL, worse than raw input).

Confidence: HIGH. Seven independent roles tested, all failed. The cascade cell is mathematically elegant but practically useless.

2.9 Surprise-minimization does NOT produce useful hidden representations

Claim: Using surprise (prediction error) to drive hidden layer learning produces representations no better than random features.

Evidence:

Phase A: All-supervised = 80.2%, Surprise-hidden = 43.9%, Random-hidden = 41.5%, Output-only = 43.9%
Surprise for classification: AUROC 0.495 (random). Mean surprise on correct examples: 0.0372, incorrect: 0.0370

Why it matters: This falsifies a core tenet of the predictive coding hypothesis as applied to ML. Self-prediction (zero surprise) can encode any function, including useless ones. There is no gradient from surprise-minimization toward task performance. The surprise gradient is self-canceling: it pushes cells toward outputting constants.

Confidence: HIGH. Replicated with multiple conditions and matched controls.

2.10 The cascade cell is a signal repeater, not a computer

Claim: In open thermodynamic soup, cascade cells converge to relaying environmental signals rather than computing novel functions.

Evidence:

Phases 1-14: Max meta-function correlation |r| = 0.370 (sensors only), with L2 never exceeding L1
Phase 18b: All best programs are simple relays. MUL not enriched (-3%). Best MI = 0.787 from neighbor relay
Phase 19b: Best programs contain MUL opcodes but MUL results are immediately overwritten -- vestigial computation

Why it matters: Combined with the minimum-effort principle and the circuit half-life constraint, this shows the fundamental limitation of cascade cells in evolutionary systems. They optimize for metabolic efficiency (low surprise = low cost), not computational complexity.

Confidence: HIGH. Consistent across 14 phases. The best programs in Phase 18b were analyzed instruction-by-instruction: the best in Condition A (MI=0.787) effectively relays a neighbor's output; the best in Condition B (MI=0.928) is a pure relay of CH[0] with 3 redundant OUTPUT instructions. In Phase 19b, the best program (MI=0.78) contains a MUL instruction but the result is immediately overwritten by a NEIGHBOR load on the next line -- vestigial computation that does nothing.

2.11 Additive reward shaping dilutes selection pressure

Claim: Adding bonuses (multi-channel, nonlinearity, complexity) to the MI fitness signal weakens selection rather than improving it.

Evidence:

Phase 19b: MI-only (B) = 0.301 bits vs Full shaped (A) = 0.208 bits. Bonuses contribute ~0.03/tick alongside MI of ~0.05/tick, effectively doubling energy without improving computation.

Why it matters: A practical lesson for evolutionary algorithm design. Additive bonuses act as universal subsidies that all organisms receive, reducing the relative advantage of genuinely fit individuals.

Confidence: MEDIUM-HIGH. Single experiment with 3 seeds, but the mechanism is clear.

2.12 Per-unit costs penalize complexity

Claim: When each instruction or parameter costs energy, evolution minimizes model size rather than maximizing performance.

Evidence:

Phase 19: Per-instruction cost -> mean slots = 1.03, programs collapse to 1 slot
Phase 19b: Flat cost -> mean slots = 2.16, 16% reach 3+ slots
Phase 12: Cells universally evolve toward minimum connections (3)

Why it matters: Design principle for evolutionary systems: use flat existence costs, not per-component costs, if the goal is to evolve complex solutions.

Confidence: HIGH. Replicated across multiple experiments.

2.13 Connection inheritance is critical for evolutionary systems

Claim: Offspring inheriting parent wiring patterns dramatically improves evolutionary outcomes.

Evidence:

Phase 10: 860% improvement in max meta-function correlation (0.030 to 0.270) from connection inheritance alone.

Why it matters: This is the evolutionary analog of transfer learning. It is the single largest quantitative improvement in the project. However, it is not novel -- NEAT, HyperNEAT, and other neuroevolution methods all use topology inheritance.

Confidence: HIGH. Clear before/after comparison in a single phase.

Section 3: What Was Wasted (Honest Accounting)

3.1 Phases 4-9: Incremental cell soup tuning

What we did: Five phases testing local learning rules (7 conditions), drifting environments (6 conditions), scale-up (500+ cells), and free market economics. Total runtime estimated at 3-5 hours of compute plus several days of analysis.

Why it was wasted: Phases 6-7 tested within-lifetime learning rules that could not work because the cell's entire lifetime is one convergence episode -- there is no learning phase distinct from settling. This could have been identified mathematically from the EMA convergence time vs. cell lifetime. Phase 8 (scale-up) and Phase 9 (economics) produced marginal improvements (|r| from 0.059 to 0.098) that were superseded by connection inheritance in Phase 10.

The lesson: Before testing learning rules, compute whether the substrate has enough computational time to learn. If the cell lifetime approximately equals the convergence time, there is no room for learning.

3.2 Phases 11-13: Nurturing complexity

What we did: Three phases testing frontier bonuses, quality consumer bonuses, longevity bonuses, disabled pruning, increased food supply, and periodic K=2 re-seeding. Total runtime estimated at 2-3 hours of compute.

Why it was wasted: The circuit half-life constraint (50-76 steps vs. 200+ step optimization time) was a structural limitation that no parametric tuning could overcome. The 4x deficit between circuit stability and optimization time needed a qualitative architectural change, not mechanism tweaks. Phase 11 measured the circuit half-life; Phases 12-13 confirmed that no mechanism changed it by more than 2x. The Phase 13 longevity bonus set its threshold at 500 steps when cells died at ~49 steps -- a basic parameter mismatch that should have been caught before running.

The lesson: When you identify a structural constraint (circuit half-life < optimization time), don't spend multiple phases trying parametric fixes. Either change the architecture or move on.

3.3 Phase 14: Cell type diversity

What we did: Introduced integrator cells (content-dependent attention + multiplicative gating) and inhibitor cells. Runtime ~1-2 hours.

Why it was wasted: The result -- integrators become competitive parasites winning at survival while losing at computation -- could have been partially predicted from the minimum-effort principle. Attention without gradient tuning converges to the most predictable (least informative) input. This is known from the attention mechanism literature. Additionally, the best result (|r| = 0.370) came from plain sensors (Condition A), not from the new cell types.

The lesson: Attention mechanisms require gradient-based tuning to attend to task-relevant inputs. Without backprop, attention degenerates.

3.4 Phases 18-19b: Register machine program cells

What we did: Three phases (18b, 19, 19b) testing register machine programs as evolvable cells, with MI reward, developmental encoding, and shaped rewards. Total runtime: ~145 minutes of compute.

Why it was wasted: Phase 17 had already demonstrated that graph-like representations with evolvable operations solve the problem trivially in <10 generations. The register machine representation was a known-inferior alternative (tree GP >> linear GP since Koza 1992). The viability analysis V1, which took 22 seconds, proved register machines needed 10 million generations to find multiplication. This analysis was done AFTER Phase 19b, not before.

The lesson: This is the single largest waste in the project. An estimated 130 minutes of compute and days of analysis could have been saved by 22 seconds of mathematical analysis. Do viability analysis BEFORE experiments.

3.5 The golden ratio cargo cult

What we did: The entire project was framed around the golden ratio. Phases 1-3 established phi-based eigenvalues and phase transitions. The observation equation used phi-weighted combinations. The cycling mechanism used phi-based periods. Everywhere phi appeared, it was treated as potentially meaningful.

Why it was wasted: The golden ratio appears in the mathematical structure of the cascade because the cascade equation x_{n+1} = alpha * x_n + (1-alpha) * obs has algebraic structure when alpha = 1/phi. But algebraic structure does not imply optimality. Decay 0.9 outperforms 0.618 and is 50x more stable. Phi-cycling adds diversity but not fitness. The room mechanism (61.8% weight) drowns the input signal.

The lesson: Mathematical elegance does not imply practical utility. A parameter that produces beautiful algebraic identities is not necessarily optimal for any task. Test the "beautiful" value against boring alternatives (0.5, 0.9, etc.) early.

3.6 Running cascade component tests after sufficient evidence

What we did: CASCADE_COMPONENT_FINDINGS tested SurpriseGate, CascadeNorm, and CascadeRNN on CIFAR-10 and sequential MNIST. SIGNAL_CONDITIONER_FINDINGS tested the cascade as a signal conditioner for noisy regression, distribution shift, and anomaly detection. Total runtime ~125 minutes.

Why it was partially wasted: By the time these tests ran, the project had already accumulated strong evidence that cascade cells don't outperform standard alternatives (Phase 17 ablation, Phase A ablation, ML Insights Tests 3-5). The component tests were thorough but confirmed what earlier tests had shown. However, they provided the cleanest falsification evidence -- particularly SurpriseGate at 10% (random chance) and CascadeNorm at 59.7% (worse than no normalization at 72.6%).

What was valuable: The root cause analyses in these tests are the most detailed in the project. The CASCADE_COMPONENT_FINDINGS explains WHY SurpriseGate diverges (no scale normalization, EMA lag, no centering), WHY CascadeNorm fails (EMA statistics converge too slowly, same statistics in train/eval is a bug not a feature), and WHY CascadeRNN is mediocre (fixed decay = fixed forgetting, surprise gating adds noise not signal). These diagnoses are more valuable than the raw numbers because they explain the failure mode, not just the failure.

The lesson: There's a tension between "we already know this doesn't work" and "we should test it rigorously in every plausible role." The component tests were arguably the right call for completeness, but could have been limited to 2-3 conditions instead of the full matrix. The root cause analyses, however, were worth the time.

3.7 Summary of waste

Phase(s)	Estimated compute	Could have been avoided?	How
4-9 (incremental soup tuning)	3-5 hours	Partially (6-7 yes, 8-9 less clear)	Math on convergence time vs lifetime
11-13 (nurturing complexity)	2-3 hours	Yes, after Phase 11 measured the constraint	Accept the structural limitation
14 (cell type diversity)	1-2 hours	Partially	Literature review on attention without gradients
18-19b (register machines)	~145 minutes	Yes	Viability analysis V1 (22 seconds)
Golden ratio investigation	Embedded in all phases	Partially	Test phi vs alternatives in Phase 3
Cascade component tests	~125 minutes	Partially	Run fewer conditions

Conservative estimate: ~40-50% of total compute was avoidable. This translates to roughly 8-9 of the 18 days, consistent with the team's retrospective estimate.

3.8 What the waste pattern reveals

The waste follows a clear pattern: incremental refinement of a failing approach instead of architectural pivots.

Phases 6-9: Four phases of incremental tuning when the fundamental issue (cells can't learn because their lifetime equals their convergence time) was a structural constraint
Phases 11-14: Four phases of mechanism tuning when the fundamental issue (circuit half-life < optimization time) was a structural constraint
Phases 18-19b: Three phases of reward/encoding tuning when the fundamental issue (register machines are the wrong representation) was a structural constraint

In each case, the project identified the correct diagnosis eventually, but only after exhausting parametric fixes. The pattern suggests a systematic bias toward parameter tuning over architecture change -- possibly because parameter tuning feels like progress (numbers go up slightly) while architecture change feels like starting over.

The antidote: After 2 failed phases against the same barrier, ask explicitly: "Is this a parametric problem or a structural problem?" If structural, no parameter change will fix it. Change the architecture or move on.

3.9 The opportunity cost

Beyond compute waste, there is an opportunity cost. The 130+ minutes spent on register machine experiments (Phases 18-19b) could have been spent on:

Scaling Phase 20's graph framework to larger problems
Validating surprise-gated LR on CIFAR-10 (the most promising practical finding)
Testing settling on existing stateful architectures (LSTMs, state-space models)
Running the cascade component tests earlier to kill the cascade sooner

The project ended with two unvalidated findings (surprise-gated LR, settling) that could have been validated at scale within the saved time. This is the real cost of not killing ideas early: not just the wasted compute, but the foregone opportunity to validate what actually works.

Section 4: What Has Potential (If Anything)

4.1 Surprise-gated learning rate

The idea: Scale learning rate per sample based on the network's prediction error: lr_effective = base_lr * clip(loss / running_ema(loss), 0.1, 2.0).

Why it might work: The stability benefit (no catastrophic seed failures) is genuine and potentially valuable for production training pipelines where seed-dependent failures are costly. The automatic curriculum property (hard examples get more attention early, easy examples less late) is theoretically sound.

What would need to happen:

Implement as a PyTorch LR scheduler wrapper (1 day)
Test on CIFAR-10 with ResNet-18 and MobileNetV3, 5+ seeds (2-3 hours compute)
Test interaction with Adam (which has its own per-parameter adaptation)
If positive: test on ImageNet subset, measure training cost savings
Literature review: confirm this hasn't been published under a different name

Honest probability of success: 20-30%. The mechanism is similar to focal loss, importance-weighted SGD, and curriculum learning. Adam may already capture the adaptation. The current evidence is from 3 seeds on small MNIST with a non-standard architecture. The 2.8pp improvement over cosine is within noise for many benchmarks.

Where it should be tested: CIFAR-10 with standard architectures (ResNet-18, MobileNetV3). If it works there, ImageNet. If it doesn't, close the thread.

4.2 Graph evolution framework for architecture search

The idea: Use Phase 20's computational graph representation with MI-based fitness for neural architecture search, targeting edge deployment (fewer parameters, lower FLOPs).

Why it might work: Phase 20 demonstrated that graph evolution with MI fitness discovers useful computation in 1-2 generations when the representation is right. The operation palette can be swapped for edge-efficient operations (depthwise conv, pointwise conv, skip connection, SE block). MI-based fitness prevents degenerate architectures (where entire layers are bypassed).

What would need to happen:

Scale from 4-node graphs on toy functions to 8-16 node graphs on MNIST (1-2 days)
Replace arithmetic operations with CNN operations (conv3x3, conv1x1, depthwise, etc.)
Define multi-objective fitness: accuracy * (1/params) or accuracy * (1/FLOPs)
Compare evolved architectures against MobileNetV3-Small on CIFAR-10
If competitive: scale to larger graphs and harder tasks

Honest probability of success: 10-15%. This is a well-explored space. DARTS, ENAS, ProxylessNAS, and others have been optimizing edge architectures for years with much larger budgets and teams. The Phase 20 framework is conceptually clean but untested at real scale. The value proposition is unclear: what would MI-based evolutionary search find that differentiable NAS hasn't?

Where it should be tested: CIFAR-10 with 8-16 node graphs. Success criterion: achieve >90% accuracy with <100K parameters.

4.3 The composition thesis as a design principle

The idea: Representations with composable, independently mutable building blocks enable efficient evolutionary search. The $10^{23}$ x improvement from register machines to graphs is a specific instance of a general principle.

Why it might work: This is a well-established principle in evolutionary computation (schema theory, building block hypothesis), but the quantitative demonstration here is unusually clear. It could guide the design of evolvable representations for new domains.

What would need to happen: This is a theoretical insight, not a testable hypothesis per se. It should inform representation design in any evolutionary search application. The specific recommendation: ensure single mutations can change one component without breaking others.

Honest probability of being useful: 60%. As a design principle, it's already proven. The question is whether it leads to new representations that outperform existing ones in specific domains.

Where it should be applied: Any domain using evolutionary search -- NAS, program synthesis, materials design, drug discovery.

4.4 Surprise-based pruning (speculative)

The idea: Neurons whose activation patterns are highly predictable (low surprise variance) may be redundant and prunable.

Why it might work: Conceptual connection to the cascade surprise mechanism. Neurons that never "surprise" the network may not be contributing unique information.

What would need to happen:

Train a standard ResNet-18 on CIFAR-10
Compute per-neuron activation variance over validation set
Prune bottom 20%, fine-tune, measure accuracy recovery
Compare against magnitude pruning and gradient-based pruning

Honest probability of success: 10%. This is entirely speculative -- it was never tested in the research arc. The connection to golden cascade surprise is conceptual, not empirical. Activation variance is a crude proxy for importance. Existing pruning methods (magnitude, gradient) have years of refinement.

Where it should be tested: ResNet-18 on CIFAR-10 as a quick pilot.

4.5 The two-phase learning model (supervised structure then surprise inference)

The idea: Train hidden layer structure with supervised learning (backprop), then use surprise-based mechanisms only at inference time for confidence estimation or adaptive computation.

Why it might work: Phase A showed that the architecture works with supervised training (80.2%) but not with surprise-based learning (43.9%). The surprise mechanism is useless for training but might provide useful signals in a pre-trained network -- for example, high surprise in a trained network might indicate distribution shift or adversarial inputs.

What would need to happen:

Train a standard network on CIFAR-10
Add EMA tracking to each neuron post-training (no retraining)
At inference, compute surprise per neuron
Test whether neuron-level surprise correlates with confidence, OOD status, or adversarial detection
Compare against existing methods (softmax entropy, ODIN, Mahalanobis distance)

Honest probability of success: 5%. ML Insights Tests 3-4 already showed surprise is useless for confidence and OOD detection in the consensus network, and CASCADE_COMPONENT_FINDINGS showed CascadeNorm's OOD probe at 91.7% (decent) but via feature representations, not surprise scores. The signal conditioner tests showed the EMA adapts to anomalies, destroying the detection signal. These results strongly suggest surprise-after-training would also fail. But the specific test (add EMA to a standard trained network) was not done, and the failure modes might differ.

Where it should be tested: ResNet-18 on CIFAR-10 with OOD test on SVHN.

4.6 Open thermodynamic evolution as a framework (theoretical)

The idea: The open thermodynamic framework (energy, metabolism, birth, death) as a general-purpose evolutionary algorithm, independent of the golden cascade cell.

Why it might work: Phase 20 demonstrated the framework works when paired with the right representation. The MI-based fitness, flat existence costs, connection inheritance, and computational graph representation produced stable, productive evolution with no extinctions across 9 runs. This is a clean, general-purpose framework that could be applied to other evolutionary search problems.

What would need to happen:

Abstract the framework from the cell soup specifics
Define it as a library: environment interface, organism interface, energy economics, MI fitness
Apply to a standard benchmark (NAS search space, symbolic regression)
Compare against standard evolutionary algorithms (CMA-ES, NEAT, genetic programming)

Honest probability of success: 15-20%. The framework is clean but not obviously superior to existing evolutionary algorithms. The main selling point is MI-based fitness (which prevents degenerates) and continuous selection (which may be more efficient than generational selection for some problems). But these advantages may be marginal compared to well-tuned standard algorithms.

Where it should be tested: Symbolic regression benchmarks (SRBench) as a direct comparison with GP.

4.7 Summary: potential by expected value

Lead	Probability of Success	Potential Impact if Successful	Expected Value	Recommended Investment
Surprise-gated LR	20-30%	Low-medium (training stability)	Low-medium	1 day (CIFAR-10 test)
Graph evolution for NAS	10-15%	Medium (edge architectures)	Low-medium	2-3 days if LR test passes
Composition thesis	60% (as principle)	Low (design guidance)	Medium	No experiment needed
Surprise-based pruning	10%	Low-medium (pruning criterion)	Low	4-6 hours (quick pilot)
Two-phase learning	5%	Low	Very low	Only if other tests succeed
Open thermo framework	15-20%	Medium (new evo algorithm)	Low-medium	2-3 days (benchmark comparison)

The highest expected-value action is testing surprise-gated LR on CIFAR-10 with ResNet-18. It costs 1 day and has a 20-30% chance of producing a publishable result. Everything else should be conditioned on that outcome.

4.5 What does NOT have potential

For completeness, the following ideas should be explicitly abandoned:

Golden cascade cells as ML components: Tested in 7 roles, failed all. No viable application.
Surprise-minimization as unsupervised learning: 43.9% = random features. Definitively dead.
Golden ratio as hyperparameter: Underperforms simpler alternatives. No magic.
Open thermodynamic cell soup for hierarchical computation: Circuit half-life kills it. Would need neurons with 10x longer lifetimes.
Room/shared medium mechanism: Drowns the input signal (-22pp).
Register machine program evolution: $10^{23}$ x worse than graph evolution. Use graphs.
Additive reward shaping: Dilutes selection. Use MI-only.
Consensus (K>1 with shared weights): Strictly worse than ensembling.

Section 5: Methodology Lessons

5.1 Math first, compute second

The viability analyses (V1 and V2) are the most cost-effective work in the entire project. V1 took 22 seconds of compute and proved register machines need 10 million generations -- saving the project from further register machine experiments. V2 took 22 seconds and correctly predicted Phase 20's success. The ratio: 22 seconds of math vs. ~145 minutes of wasted experiments = 400x cost ratio.

The principle: Before running any evolution experiment, compute: (1) search space size, (2) mutation distance between solutions, (3) expected generations to target, (4) energy economics (can the starting population survive?), (5) fraction of random solutions that are non-degenerate. If the math says it won't work, the experiment will confirm the math -- expensively.

5.2 Check against literature before building

The register machine representation was known to be inferior to tree-based GP since Koza (1992). The attention-without-gradients failure was predictable from transformer literature. The evolution-stability tension is documented in artificial life (Tierra, Avida). A half-day literature review before Phases 14 and 18-19b would have saved significant time.

5.3 Small tests before large experiments

Phase 20 succeeded partly because the viability analysis V2 was a small test that predicted the outcome. The optimal process: hypothesis -> minimal pilot (1-2 conditions, short duration) -> extract quantitative measurements -> viability analysis -> decide -> full experiment or pivot.

The project mostly did this but not consistently. Phases 18-19b were full experiments without viability checks. Phase 20 was preceded by V2 and succeeded immediately.

5.4 The cost of not killing ideas early

The golden cascade hypothesis should have been challenged earlier. By Phase 3, the mathematical elegance was established. By Phase 12, evolvable decay rates beat fixed phi (+65%). By Phase 17, plain tanh matched cascade. But the cascade continued being treated as central through Phase A and the ML Insights tests.

Sunk cost fallacy in research: the more time invested in an idea, the harder it is to declare it dead. The project eventually did kill the cascade, but it took 17+ phases when 5 would have sufficed.

5.5 When to pivot vs. persevere

Pivot signals (in retrospect):

Phase 6-7: Learning rules don't help -> the cell isn't learning, it's settling. Should have pivoted to longer lifetimes or different dynamics.
Phase 13: Circuit half-life measured at 50-76 steps vs 200+ step optimization -> structural barrier. Should have pivoted immediately to organism-level selection.
Phase 18b: Relay ceiling demonstrated -> register machines are stuck. Should have pivoted immediately to graphs.

Persevere signals:

Phase 10: Connection inheritance +860% -> this mechanism is powerful, continue building on it.
Phase 17: Evolvable ops solve the problem -> the graph-like representation works, scale it up.
Phase 20: Viability analysis predicts success -> run the experiment.

The pattern: Pivot when you've identified a structural barrier with clear mathematical bounds. Persevere when you've found a mechanism with large quantitative impact.

A quantitative pivot heuristic (from this project): If you've tested 3+ mechanisms against a barrier and none changed the key ratio by more than 2x (Phases 11-14 against the circuit half-life), the barrier is structural, not parametric. Stop tuning and change the architecture.

5.6 The value of negative results

The project's negative results are arguably its most valuable output:

They close off an entire line of inquiry (golden cascade as ML technique) with quantitative evidence
They provide a falsification template: specific experiments, specific numbers, specific architectures
They save future researchers from re-exploring the same dead ends
They demonstrate that mathematical elegance (phi-power eigenvalues, conserved quantities) does not predict practical utility

The falsification table (Section 2 of RESEARCH_ARC_COMPLETE.md) is a concrete artifact that any researcher considering golden-ratio-based ML can reference.

5.7 How the team process helped (or didn't)

Helped:

Multiple perspectives (Alpha/Beta/Gamma) provided genuine diversity of interpretation
The retrospective conversation (TEAM_CONVERSATION_V21) was honest and self-critical
Phased structure with clear success criteria enabled clean pivot decisions
Rigorous ablation controls in most experiments
Explicit kill criteria before experiments (used effectively in cascade component tests)
Documentation of every phase with specific numbers, not vague assessments

Didn't help:

The three-team structure sometimes produced redundant analysis (Alpha, Beta, Gamma all analyzing the same 3-cell system in Phases 1-3 with overlapping conclusions)
The team conversations were sometimes performative rather than productive (the "discussion" format encouraged narrative over analysis)
The phased structure encouraged incrementalism (tweaking the last phase) rather than radical pivots. Phases 11, 12, 13, and 14 are all incremental adjustments to the same failing system
No formal "pre-mortem" or devil's advocate role. The golden cascade hypothesis was the project's identity, and nobody was tasked with trying to kill it early

5.8 The viability analysis as a general method

The viability analysis framework deserves explicit documentation as a transferable method. For any evolutionary experiment, compute these five quantities BEFORE running:

Search space size -- How many possible solutions? If > $10^{15}$ , random search cannot cover it in any reasonable time. Structured search (building blocks, mutation gradients) is required.
Non-degenerate fraction -- What fraction of random solutions produce non-trivial behavior? If < 10% (as with register machines at 9.8%), most of the population is dead weight. If > 50% (as with graphs at 68.1%), the population is healthy from initialization.
Mutation distance -- How many exact mutations to get from the starting solution (typically a relay or identity) to the desired solution? If > 3 exact mutations each at low probability, the search is effectively random. If 1-2 mutations (as with graphs), the search is tractable.
Energy economics -- Can the starting solution (relay) survive? Compute net energy per tick. If negative, the population dies before evolution can operate. If positive, evolution has a substrate to work with.
Selection gradient -- What is the reproductive rate ratio between the current best and the desired solution? If < 1.5x, selection is too weak. If > 2x, evolution can find the better solution within a few generations.

This five-number summary takes minutes to compute (or seconds with a simple script) and accurately predicted the outcomes of both Phase 20 (all metrics favorable -> success) and the register machine experiments (all metrics unfavorable -> failure).

5.9 Negative results require the same rigor as positive results

The project's falsification evidence is its most durable contribution, but only because it was done rigorously. Each negative result included:

Matched architectures (same layer sizes, same datasets)
Multiple seeds (3-5 per condition)
Explicit controls (random baseline, standard alternative)
Specific numerical thresholds (not "it didn't work" but "0.495 AUROC, which is within 0.005 of random")
Root cause analysis (WHY it failed, not just THAT it failed)

This level of rigor is necessary for negative results to be useful. A vague "we tried X and it didn't work" helps nobody. A specific "X achieved 43.9% on MNIST [50->32->16->10] with PCA-50 features, 10K train, 2K test, 3 seeds, matched architecture, vs 41.5% for random features and 80.2% for supervised training" is referenceable and saves other researchers real time.

Section 6: Quantitative Summary

Complete Experiment Table

Phase	What Tested	Runtime	Key Result	Verdict	Avoidable?
1-3	3-cell golden cascade math	~30 min	r=0.72 timescale matching, phi-power eigenvalues	PROVED (math)	No -- foundational
4-5	Cell soup evolution	~30 min	103 births, 63 deaths, decay evolves 0.44->0.33	PROVED (evo works)	No -- core validation
6	Local gradient learning (7 cond.)	~1 hr	0/7 conditions help	DISPROVED (learning rules)	Yes -- math on convergence time
7	Drifting environment learning	~1 hr	0/6 channels help	DISPROVED (learning rules)	Yes -- follows from Phase 6
8	Scale-up 500+ cells	~1 hr	max \|r\|=0.059, trophic structure	INCONCLUSIVE	Partially -- baseline needed
9	Free market economics	~1 hr	max \|r\|=0.098 (+4x)	PARTIAL	Partially -- some mechanisms tested
10	Connection inheritance	~1 hr	max \|r\|=0.270 (+860%)	PROVED (inheritance)	No -- key discovery
11	Frontier + quality consumer	~1 hr	max \|r\|=0.198, half-life ~269 steps	PARTIAL	No -- measured constraint
12	Evolvable architecture	~1 hr	max \|r\|=0.345, K>1 dies, decay +65%	PARTIAL	No -- valuable ablations
13	Nurturing complexity	~1 hr	Longevity never activates, half-life 50-76	DISPROVED (parametric fixes)	Yes -- after Phase 11
14	Cell type diversity	~1-2 hr	Integrators are parasites, sensors best	DISPROVED (complex cells)	Partially -- lit review
15	Organism-level selection	8.5 min	`difference` r=0.9997, no nonlinear	PARTIAL (linear attractor)	No -- identified key problem
16	Breaking linear attractor	50 min	`maximum` gap +0.25, 5/5 seeds	PROVED (max computable)	No -- key architecture test
17	Evolvable wiring ops	26 min	Product gap +0.96, 15/15 seeds. Cascade = tanh	PROVED (ops matter)	No -- pivotal result
18b	MI-based reward	15.5 min	MI 0.510 vs random 0.389, constants die	PROVED (MI reward)	No -- validated MI fitness
19	Developmental encoding	~64 min	Programs collapse to 1 slot	DISPROVED (per-unit cost)	Yes -- math on search space
19b	Shaped rewards + hard env	64.5 min	MI-only 0.301 > shaped 0.208	DISPROVED (shaping hurts)	Yes -- after 18b + viability
20	Graph soup + MI survival	20.3 min	Max MI 1.71, 9/9 stable, ADD dominates	PROVED (framework works)	No -- project culmination
A	Consensus neural network	12 min	80.2% supervised, 43.9% surprise	DISPROVED (surprise learning)	No -- needed for falsification
ML-1	Consensus vs ensembling	~5 min	71.4% vs 81.8%	DISPROVED (consensus)	No -- clean comparison
ML-2	Settling for stateful neurons	~5 min	+49.4pp stateful, -0.2pp stateless	PROVED (settling)	No -- novel finding
ML-3	Surprise as confidence	~5 min	AUROC 0.495	DISPROVED	No -- needed testing
ML-4	Surprise as OOD detector	~5 min	AUROC 0.471	DISPROVED	No -- needed testing
ML-5	Golden ratio as decay	~5 min	0.618: 57.8%, 0.9: 86.1%	DISPROVED	Could have been Phase 3
ML-6	Surprise-gated LR	~5 min	83.0% vs 80.2% cosine	PROVED (weak)	No -- key finding
Components	Cascade as ML primitives	~65 min	SG=10%, CN=59.7%, CascadeRNN=95.2%	DISPROVED (all three)	Partially -- redundant with prior
Signal Cond	Cascade as conditioner	~1 min	Raw input beats cascade everywhere	DISPROVED	Partially -- redundant with prior

Runtime Summary

Category	Estimated Runtime	Fraction
Productive experiments	~4-5 hours	~45%
Necessary falsification	~2-3 hours	~25%
Avoidable experiments	~3-4 hours	~30%
Viability analyses (V1+V2)	<1 minute	<0.1%

Phase Dependency Graph (What Required What)

Phases 1-3 (math foundation)
  |
  +-- Phases 4-5 (evolution validation)
  |     |
  |     +-- Phase 10 (connection inheritance -- KEY DISCOVERY)
  |     |     |
  |     |     +-- Phases 11-14 (incremental tuning -- largely avoidable)
  |     |     +-- Phases 15-16 (organism-level selection)
  |     |           |
  |     |           +-- Phase 17 (evolvable ops -- PIVOTAL)
  |     |                 |
  |     |                 +-- Phase 20 (graph soup -- SUCCESS)
  |     |
  |     +-- Phases 6-9 (learning rules, economics -- mostly avoidable)
  |
  +-- Phase 18b (MI reward -- VALUABLE)
  |     |
  |     +-- Phases 19-19b (register machines -- AVOIDABLE)
  |
  +-- Phase A (consensus network -- NEEDED for falsification)
  |     |
  |     +-- ML Insights 1-6 (practical extraction -- NEEDED)
  |
  +-- Cascade components + Signal conditioner (final falsification -- PARTIALLY NEEDED)

Critical Path (minimum phases to reach the same conclusions)

If the project were repeated with perfect hindsight:

Phases 1-3: Mathematical foundation (2 days) -- Establish the golden cascade structure
Phase 5: Evolution validation (0.5 day) -- Confirm evolution works
Phase 10: Connection inheritance (0.5 day) -- Discover the key mechanism
Phase 12: Evolvable decay (0.5 day) -- Prove phi is not optimal
Phase 15: Organism-level selection (0.5 day) -- Identify the linear attractor
Phase 17: Evolvable ops (0.5 day) -- Solve the problem with graph representation
Viability V1 + V2: Mathematical analysis (1 hour) -- Prove register machines fail, graphs work
Phase 20: Graph soup (0.5 day) -- Validate the framework
Phase A + ML Insights: Practical extraction (1.5 days) -- Falsify cascade, extract findings

Total: ~7 days vs 18 days actual. Savings: ~60%.

The saved 11 days correspond to: Phases 4, 6-9, 11, 13-14, 18-19b, and the cascade component/signal conditioner tests. These were either redundant with earlier findings, predictable from math, or testing mechanisms already demonstrated to fail.

Accuracy of Viability Predictions

The viability analyses made specific, testable predictions. Here is how they performed:

Viability Analysis V1 (Register Machines):

Prediction	V1 Said	Actual	Correct?
Relay MI in product env	~0.034 bits	Confirmed (cells with MI 0.2-0.5 were NOT relaying channels)	YES
Relay net energy	Negative (-0.015/tick)	Relays died, population survived on lucky programs	YES
Generations to find product	10 million	Never found in 10K+ ticks	YES
Multiplicative bonuses help?	No (can't multiply zero)	Phase 19b confirmed: shaping hurt	YES

Viability Analysis V2 (Computational Graphs):

Prediction	V2 Said	Actual (Phase 20)	Correct?
Linear combiner in every seed	95% confidence	9/9 seeds	YES
Mean MI > 1.0 within 500 ticks	80% confidence	No (mean ~0.65)	NO (diversity lowers mean)
MUL appears but doesn't dominate	70% confidence	Confirmed	YES
No optimal 3-node solution	60% confidence	Correct (max MI ~1.7, not 2.6)	YES
No extinction	99% confidence	0/9 extinct	YES

Score: 8/9 predictions correct. The one miss was about population mean MI, which V2 predicted would rise faster than it did. The reason: V2 didn't account for population diversity keeping the mean below the best individuals. This is a minor miss -- the qualitative prediction (evolution works) was correct.

Section 7: The Honest Bottom Line

What would we tell another researcher considering this line of work?

Do not pursue golden cascade cells, surprise-minimization as an unsupervised learning rule, or the golden ratio as a magic hyperparameter. These are definitively dead. The evidence is comprehensive: 20 phases, 6 ML insight tests, 3 cascade component tests, 3 signal conditioner tests, 27+ conditions, 50+ seeds. Not one experiment found an advantage for any of these mechanisms over standard alternatives.

If you are interested in evolutionary computation or self-organizing systems, the useful insights are: (1) representation design matters more than algorithm tuning by orders of magnitude, (2) MI-based fitness eliminates degenerate solutions, (3) evolution always finds the minimum-effort solution so your fitness landscape must make the desired behavior the easiest path, and (4) do mathematical viability analysis before running experiments.

If you are interested in practical ML improvements, test surprise-gated LR on standard benchmarks with standard architectures. If it works on CIFAR-10 with ResNet-18, there may be a small contribution. If it doesn't, close the thread. Do not build custom architectures around golden cascade principles.

Is there a paper here?

There are two possible papers, neither strong:

Paper 1: Negative results. "Golden Cascade Cells Are Not Useful for Machine Learning: A Comprehensive Falsification." This would document the 7 roles tested, the consistent failure, and the lesson that mathematical elegance does not predict practical utility. Publishable in a workshop or negative-results venue. Low impact but honest.

Paper 2: Representation design for evolutionary computation. "Representation Determines Evolutionary Search Efficiency: A $10^{23}$ x Improvement from Computational Graphs over Register Machines." This quantifies a known principle (tree GP >> linear GP) in a new setting with striking numbers. The viability analysis framework (compute search space, mutation distance, energy economics before experimenting) is a practical contribution. Publishable in an evolutionary computation venue. Medium impact.

Neither paper would be accepted at a top ML venue (NeurIPS, ICML, ICLR) because the positive findings are too small and the negative findings, while rigorous, don't introduce new methods.

Paper 3 (long shot): Open thermodynamic evolution with MI fitness. "Energy-Based Evolutionary Computation with Information-Theoretic Fitness." This would present the Phase 20 framework (computational graphs + MI survival + open thermodynamics) as a general-purpose evolutionary algorithm. The viability analysis methodology (5-number summary predicting experiment outcomes) could be the methodological contribution. Publishable if the framework demonstrates competitive performance on standard symbolic regression benchmarks. Medium-low probability without further experiments.

What is NOT a paper: The golden cascade cell, the room mechanism, surprise-minimization, or any phi-based mechanism. These have been thoroughly falsified and have no positive results to report. A negative-results paper would need to argue that these ideas were sufficiently well-known or promising that falsifying them is a service to the community -- and honestly, these ideas were never widely pursued by the ML community, so falsifying them has limited audience value.

What's the one thing we'd do differently if starting over?

Run the viability analysis math FIRST. Before every phase, compute: search space size, mutation distance, energy economics, fraction of random solutions that work. This single practice would have cut the project timeline roughly in half (from 18 days to ~9 days) while reaching the same conclusions. The cheapest experiment is the one you don't need to run.

Final assessment

Partially productive. The project was well-executed and honest. It produced rigorous negative results that close off a line of inquiry, a strong theoretical insight about representation design, and two modest practical findings that need scale validation. But roughly half the compute was avoidable, the core hypothesis (golden cascade cells for ML) was wrong from the start, and the surviving findings are too small to constitute a significant ML contribution on their own.

The research arc demonstrates both the value and the cost of empirical exploration. The value: genuine insights emerged that mathematical analysis alone wouldn't have predicted (connection inheritance, competitive parasitism, circuit half-life constraint). The cost: without mathematical feasibility checks, much of the exploration was in provably unproductive territory.

What claims can we make with confidence?

Strong claims (would survive peer review):

Register machine evolution is $10^{23}$ x less efficient than computational graph evolution for arithmetic function discovery, and this gap is explained by composability of building blocks
MI-based fitness eliminates degenerate (constant-output) solutions in evolutionary systems while correlation-based fitness does not
Evolution reliably finds the minimum-effort solution in fitness landscapes with shortcuts
The golden cascade cell (EMA + tanh(surprise)) provides no measurable advantage over plain tanh as a neural network component, tested across 7 distinct ML roles

Moderate claims (suggestive but not conclusive):

Surprise-gated learning rate improves training stability on small-scale MNIST (3 seeds, custom architecture)
Stateful neurons (EMA-based) benefit from iterative settling at inference time
Mathematical viability analysis (search space, mutation distance, energy economics) accurately predicts evolutionary experiment outcomes

Weak claims (interesting but unvalidated):

The composition thesis -- that representations with independently mutable building blocks enable efficient evolutionary search -- is a useful design principle
Surprise-gated LR may provide stability benefits on standard benchmarks
The evolution-stability tension is a fundamental constraint on self-organizing computational systems

Related Work	What They Found	What We Added
Koza (1992) tree GP	Trees >> linear programs for GP	Quantified as $10^{23}$ x in a specific system
NEAT (Stanley 2002)	Topology evolution works	MI-based fitness eliminates degenerates (NEAT uses task-specific fitness)
AutoML-Zero (Real 2020)	Can evolve complete ML algorithms from scratch	Register machines are $10^{23}$ x worse than graphs (AutoML-Zero uses register-like programs)
Predictive coding (Friston)	Free energy principle explains neural computation	Surprise-minimization does NOT produce useful ML representations (43.9% = random features)
Focal loss (Lin 2017)	Downweight easy examples	Surprise-gated LR: upweight hard examples via LR scaling (similar mechanism, different interface)
Boltzmann machines (Hinton)	Settling improves energy-based models	Settling improves EMA-based neurons too (known in principle, specific quantification new)

The meta-lesson

The deepest lesson from this project is about the relationship between theoretical motivation and empirical validation. The golden cascade had genuine mathematical beauty -- phi-power eigenvalues, conserved quantities, exact phase transitions, connections to free energy minimization. This beauty motivated 20 phases of experiments. But mathematical beauty is not evidence of practical utility. Every phi-based mechanism was tested and found to be either equal to or worse than simpler alternatives.

The temptation to conflate elegance with effectiveness is powerful in research. This project is a 18-day case study in that temptation. The lesson is not "don't be inspired by mathematics" -- it's "test your inspired hypotheses against boring baselines as early as possible, and accept the results honestly."

A fair grade from a rigorous PhD committee: B-. Thorough methodology, honest conclusions, valuable negative results, but the core contribution is limited and the efficiency could have been much better. The student understands the problem space deeply by the end -- the question is whether they should have understood it sooner.

Appendix: Key Files

Essential Reading (ranked by importance)

analysis/RESEARCH_ARC_COMPLETE.md -- The complete 20-phase writeup
analysis/VIABILITY_ANALYSIS.md -- Why register machines fail (V1)
analysis/VIABILITY_ANALYSIS_V2.md -- Why graphs succeed (V2)
analysis/CELL_SOUP_CONCLUSION.md -- Phases 1-14 summary
analysis/ML_INSIGHTS_FINDINGS.md -- The 6 practical ML tests

Key Experiment Scripts

python/experiments/graph_soup.py -- Phase 20 (the framework that works)
python/experiments/organism_soup_v3.py -- Phase 17 (evolvable ops breakthrough)
python/experiments/organism_soup_v2.py -- Phase 16 (breaking the linear attractor)
python/experiments/organism_soup.py -- Phase 15 (organism-level selection)
python/experiments/program_cells_v2.py -- Phase 18b (MI reward for programs)
python/experiments/program_cells_v4.py -- Phase 19b (shaped rewards)
python/experiments/cell_soup_consensus.py -- Phase A (consensus network)
python/experiments/ml_insights_test.py -- Practical ML extraction
python/experiments/cascade_components.py -- Component-level falsification
python/experiments/signal_conditioner_test.py -- Final cascade test
python/experiments/viability_test.py -- Viability Analysis V1
python/experiments/viability_test_v2.py -- Viability Analysis V2

Falsification Evidence (for future reference)

Hypothesis	Primary Evidence	Supporting Evidence	Strength
Golden ratio is optimal	ML Insights Test 5 (0.618: 57.8%, 0.9: 86.1%)	Phase 12 (+65% for evolvable decay), Phase 17	Definitive
Surprise-minimization produces representations	Phase A (43.9% = random 41.5%)	ML Tests 3-4 (AUROC 0.495, 0.471)	Definitive
Cascade beats tanh	Phase 17 A vs C (0.962 vs 0.983)	Phase A (-0.7pp), Component tests (all KILL)	Definitive
Register machines are evolvable	V1 (10M generations needed)	Phases 18-19b (no nonlinear comp found)	Definitive
Reward shaping helps evolution	Phase 19b A vs B (0.208 vs 0.301)	Energy breakdown shows dilution	Strong
Room mechanism helps classification	Phase A (-22pp with room)	Observation eq gives 23.6% to input	Definitive
Consensus beats ensembling	ML Test 1 (71.4% vs 81.8%)	Phase A analysis (shared weights limit diversity)	Definitive
Surprise detects OOD	ML Test 4 (AUROC 0.471)	Signal conditioner (adapts to anomalies)	Definitive
Per-unit costs help evolution	Phase 19 vs 19b (1.03 vs 2.16 slots)	Phase 12 (cells minimize connections)	Strong
Complex cell types improve soup	Phase 14 (integrators are parasites)	Phase 12 (K>1 evolves to K=1)	Strong

Final Note on Replicability

All experiments in this project used explicit random seeds (42, 123, 456, 789, 2024 for evolutionary experiments; 42, 123, 789 for ML experiments). The datasets are standard (MNIST, CIFAR-10) with documented preprocessing (PCA to 50, 10K train/2K test splits). The architectures are fully specified in each findings document. Any result in this retrospective can be independently verified by running the corresponding script with the documented parameters and seeds.

The project produced ~40+ plot files, ~15+ JSON result files, and ~30+ analysis documents. The complete file inventory is in the git repository under python/experiments/plots/ and analysis/.