PaperlayerView exact revision on arXiv

Source-linked AI summary

Emergent Models: Intelligence from Tiny Substrates

Giacomo Bocchese, Nicola Giacobbo, Etienne Guichard, James Wiles, Akshaj Devireddy

arXiv:2608.14019v1cs.NEcs.LG

TL;DR

Emergent Models address whether simple dynamical substrates can produce task-solving computation that generalizes beyond finite training ranges. The paper develops this framework and shows that tiny local-recursive systems can extrapolate simple arithmetic functions exactly while supporting control behaviour and online adaptation.

  • Problem

    Existing machine learning often treats modeling as learning a closed-form input-output map, motivating study of simple substrates whose dynamics can generate task-solving computation and global generalization.

  • Method

    The paper frames modeling as evolutionary search over initial configurations and interfaces for iterated local dynamical systems, including cellular automata with fixed local update rules.

  • Results

    Tiny Emergent Models can extrapolate several simple integer functions perfectly far beyond training ranges and produce control behaviours, while continuous variants support online policy switching.

  • Takeaways & Limitations

    The results support Emergent Models as a foundational framework for compact algorithmic computation beyond differentiable feed-forward maps.

  • Takeaways & Limitations

    The adaptation experiments test only in-distribution policy switching and never require adaptation to a novel task, making them a precursor to meta-learning rather than a test of it.

Abstract

from arXiv · show

Emergent Models (EMs) are a machine learning paradigm based on simple yet open-ended substrates, such as cellular automata, in which modeling is treated not as the learning of a closed-form input-output map but as the emergence, within simple dynamical systems, of computational behaviors that solve external tasks. Such substrates typically iterate a fixed local rule over a latent space for an adaptive number of steps, with an interface linking the latent state to external input/output signals. Training proceeds by evolutionary search. We hypothesize that some instances of this framework are biased toward global generalization: capturing the rule generating the data over its full domain, and therefore extrapolating beyond the training range. Theoretically, we prove that some EMs are latent-universal: with the update rule and interface held fixed, they can realize any partial computable function by varying only the initial condition of the latent state. Empirically, we study a zoo of minimal EM instantiations across discrete and continuous substrates, showing that local-recursive computation at a tiny scale (tens to hundreds of parameters) can extrapolate exactly on simple arithmetic functions, can support control behaviour and online adaptation, while still exposing several limitations. This work is foundational: it does not propose a competitive architecture, but a framework meant to widen the design space of machine learning beyond differentiable feed-forward maps.

1 Introduction

The introduction frames Emergent Models as dynamical-system-based machine learning motivated by general, compute-leveraging substrates and global expressivity. It presents latent universality as the theoretical ideal and minimal experiments as an initial study of tiny local-recursive models.

  • Motivation: Emergent Models couple simple dynamical systems to machine learning through interfaces that encode external inputs and decode outputs.They formalize the use of simple, general substrates whose behaviors emerge through dynamical processes.
  • Expressivity: Global expressivity captures functions exactly or arbitrarily precisely over their full, possibly open domain, rather than only fitting values on bounded regions.The introduction argues that expressivity is a precondition for search and inductive bias: unrepresentable target behaviors remain unreachable regardless of compute.
  • Iteration and substrates: Fixed-depth feed-forward mappings typically extrapolate poorly beyond training ranges, while iterative updates can increase expressivity by repeatedly transforming mutable state.The discussion connects this design principle to recurrent computation, compact recursive models, and classical computation theory.
  • Theoretical framework: In the latent-universal regime, holding the update rule fixed and varying only the initial latent state can express any computable function.This is identified as the framework’s strongest ideal regime and is stated as Theorem 1.
  • Experiments: Experiments examine a zoo of minimal Emergent Model instantiations rather than attempting to realize latent universality, with local-recursive models using 20-300 parameters.The experiments are presented as an opening-stage study showing extrapolation on simple arithmetic functions.

2 Emergent Models

Emergent Models turn simple dynamical substrates into computational models through an encoder–decoder interface and adaptive iteration. Their latent-universal regime can realize every partial computable function by varying only the initial program state, while raising unresolved questions about continuous computation and state retention.

  • Model framework: Emergent Models combine a fixed transition rule, adaptive halting, and an encoder–decoder interface that communicates with a latent state serving as computational space and memory.The interface may write and read at fixed ports or input-dependent locations, while the latent substrate can be discrete, continuous, bounded, or unbounded.
  • Modeling objective: Modeling means realizing a target function across its full domain, rather than fitting values only on a bounded compact region.For discrete functions this realization is exact; for continuous functions it is to arbitrary precision.
  • Latent universality: Latent universality fixes the state space, transition function, halting condition, and interface, while varying only a program state to select computations.Theorem 1 establishes an Emergent Model that computes every partial computable function from binary strings to binary strings using a finite-support program state.
  • Extensions and limitations: The framework extends to continuous-time local field dynamics, but analog-computing guarantees are absent and retained state may be incompatible with reliably resetting every computation.Persistent state can also influence future computations because subsequent programs are derived from retained latent states.
  • Latent universality: Finite-support programs make latent-universal models searchable in principle because enumerating or randomly sampling binary programs eventually reaches one computing any target partial computable function.This follows from the countability of finite binary strings and the existence of a suitable program for each target function.

3 Experiments … 3.5 CartPole

The experiments test whether minimal Emergent Models can perform exact arithmetic, extrapolate, control, and adapt using evolutionary search across discrete and continuous substrates. Results show exact extrapolation for several simple tasks, while GoL, multiplication, and control settings expose interface and search limitations.

  • 3 Experiments: Evolutionary search trains minimal substrate, program, rule, and interface components across arithmetic, control, and adaptation tasks.Generational population-based genetic algorithms use tournament selection, elitism, sparse crossover, and mutation to optimize discrete, non-differentiable, recurrent models.
  • 3.1 Arithmetic tasks: Arithmetic experiments target exact symbolic rule learning and extrapolation beyond finite integer training ranges.The tasks include affine, periodic, oscillatory, modular, and multiplication functions, with EM43 trained on [0, 30] and evaluated on [30, 1000].
  • 3.2 EM43: EM43 achieved perfect extrapolation in all runs for every one-input task, including the difficult periodic function x mod 4.The two-input multiplication task a·b performed poorly on both training and test sets and did not converge within the available compute budget.
  • 3.2 EM43: Geometric grokking describes stable, interpretable local patterns that propagate, collide with input markers, and trigger halting across input scales.The EM43 setup used 70 parameters carrying 2 bits each, or 140 bits, and trained on only 30 integer examples while extrapolating to larger ranges.
  • 3.3 GoL-EM: GoL training optimized initial glider positions under a fixed Conway’s Game of Life rule, using positional input encoding and equilibrium-based halting.Random search and a genetic algorithm reached almost identical results, suggesting a weakly structured search landscape without smooth fitness variation.
  • 3.3 GoL-EM: GoL-EM learned and generalized tasks x 7→x + k, including x −2, x −1, x + 1, x + 2, and x + 5.A conditional parity-dependent task was not successfully learned, and the chosen interface and halting protocol were not shown to preserve universality.
  • 3.4 Control tasks: Control experiments assess closed-loop behavior and robustness rather than unbounded extrapolation, with CartPole and Meta-Life providing bounded environments.State retention matters because controllers process observation streams; Meta-Life-Adapt requires inferring alternating food and poison phases from reward feedback.

3.6 GoL-EM · 3.7 CEM1D · 3.8 Meta-Life

Across three experiments, Emergent Models produced meaningful control and embodied behavior using local dynamical substrates, while exposing limitations in stability, expressivity, and adaptation scope. GoL-EM and CEM1D controlled CartPole, and Meta-Life extended the framework to foraging and reward-driven online policy switching.

  • 3.6 GoL-EM: GoL-EM trained only the initial state of a fixed Conway’s Game of Life substrate to control CartPole through a fixed encoding and decoding interface.The controller reset the board to the learned program at every macrostep, encoded four observations into six-bin lanes, evolved the board, and decoded collector activity into force.
  • 3.6.1 Results: 171.36 mean return and 417.20 best-controller return were reached in training, while evaluation on 20 new episodes produced 316.90±121.52 against a random baseline of ≈20.The evaluation also had a mean non-halting rate of 54.5%.
  • 3.6.1 Results: State retention destabilized GoL-EM and reduced performance close to random because residual debris interfered with subsequent observations.Without retention, the controller used a purely reactive reset at each CartPole macrostep.
  • 3.7 CEM1D: CEM1D used a continuous-valued one-dimensional local dynamical system with retained state across CartPole macrosteps, training only local interaction parameters while inheriting the latent state.The representative configuration used L = 19, reflective boundaries, ∆t = 0.1, and T = 30 microsteps per macrostep.
  • 3.7.1 Results: 737.32 ± 104.63 training return and 734.93±107.00 mean return over 1000 new rollouts showed high-performing, robust CEM1D CartPole control far above the random baseline of ≈20.The controller’s return was close to the maximum episode length of 800 and comfortably exceeded the standard solution threshold of 500.
  • 3.7.1 Results: CEM1D nevertheless often drifted beyond the allowed cart-position range, consistent with predominantly linear dynamics, weak cubic damping, fixed ports, and fixed computation time.The cubic coefficient was 0.03, contributing substantially mainly when cell values became large.
  • 3.8 Meta-Life: Meta-Life tested agents that sensed resources with three lidar rays and controlled rotational and forward speed in food-only foraging and visually ambiguous food/poison phases.In Meta-Life-Adapt, agents received transient reward feedback and had to infer phase changes online, but both regimes were present during training.

3.9 Training setup · 3.10 Results

The controllers were evolved with a shared population-based genetic algorithm and evaluated in representative runs. CEM2D and mRNN both learned adaptive Meta-Life behaviors, but performance, interpretability, and long-horizon robustness varied substantially.

  • 3.9 Training setup: Both controllers used the same population-based genetic algorithm with rollout fitness, tournament selection, elitism, sparse crossover, and mutation.Offspring primarily inherited hard parameters from a base parent, while a donor parent contributed a sparse gene subset.
  • 3.9 Training setup: Food-only training used population A = 100 for 700 generations, whereas Meta-Life-Adapt used population A = 300 and longer CEM2D training than mRNN.CEM2D was evolved for 510 generations and the mRNN baseline for 260 generations; representative runs were reported instead of multi-seed averages.
  • 3.10 Results: In Meta-Life-Food, CEM2D reached a return of 133 per agent per rollout, while mRNN reached 146.The mRNN learned faster early, but CEM2D caught up later and achieved a comparable return.
  • 3.10 Results: In Meta-Life-Adapt, mRNN achieved a meta-score about 15% higher than CEM2D, while both obtained high scores relative to the optimum value of 1.CEM2D required substantially longer training and improved more slowly.
  • 3.10 Results: Lamarckian inheritance of the (c, m) state shaped the current run’s initial condition, while small c-to-m couplings and rarely active write gates kept m nearly static.Ablating memory appeared to reduce the meta-score only slightly short term but led to fully degenerate behavior.
  • 3.10 Results: The memory ablation is ambiguous because m may act as static computational hardware, or the hard parameters may have co-adapted to the inherited state.The proposed test compares inherited state across generations with resetting m at each rollout while retaining it within rollouts; this remains future work.
  • 3.10 Results: A CEM2D cell near reward input port I3 tracked the estimated resource regime, activating after food and remaining low after poison.Its activation also modulated behavior: high activation induced resource seeking, while low activation induced rotation until food returned.
  • 3.10 Results: Long evaluation rollouts exposed rotating-attractor failures in both models and freezing failures in mRNN, despite mitigation from the looping penalty.Diminishing-return fitness and resource removal at phase changes plausibly contributed to these robustness failures.

4 Conclusion

Emergent Models frame learning as the evolution of computational behavior in simple iterated substrates rather than the fitting of prescribed input-output maps. The conclusion highlights exact extrapolation in minimal systems while emphasizing training brittleness, task simplicity, and open questions about iteration, trainability, and universality.

  • Framework: Emergent Models search for latent-state configurations whose evolution produces desired behavior, using minimal ingredients such as memory, local interactions, and adaptive iteration.The framework treats modeling as emergence within a computational substrate rather than direct input-output mapping.
  • Theory: Some simple dynamical systems support latent universality when a fixed interface writes inputs and reads outputs over a general computable domain.This extends substrate-level universality toward computing arbitrary functions through initial-condition changes under a task-independent interface.
  • Empirical results: Tens to a few hundred parameters suffice for the experimental models, while Game of Life remains difficult to exploit because sensitive dynamics create brittle genotype-to-phenotype mappings.Continuous realizations are more trainable and less brittle, but remain harder to train than feed-forward or standard recurrent models.
  • Empirical results: EM43 extrapolates perfectly far beyond its training range on several simple integer functions, including periodic functions that feed-forward neural networks cannot represent globally.Successful generalization appears as a stable space-time interaction mechanism in the automaton rather than an opaque parameter vector.
  • Open questions: The conclusion conjectures that adaptive iteration enables extrapolation and that the ratio of parametrization to temporal depth may govern the balance between generalization and trainability.Evidence for both claims is partial, and whether substrates can be both algorithmically well-biased and efficiently searchable remains open.
  • Future directions: Future work proposes co-evolving a shared rule with task-specific programs, then freezing the rule and training programs for increasingly complex novel tasks.A second direction targets optimization methods for the trainability of low-q substrates.

A Appendix · A.1 Turing machines as Emergent Models

The appendix represents Turing machines as generalized automata, encoding tape symbols, head position, and control state in a structured latent state. A global transition performs one Turing-machine step, while the halting predicate detects the designated halt state.

  • A Appendix: Turing machines can be represented as generalized automata.This appendix introduces the representation as a graphical generalized-automaton construction.
  • A.1 Turing machines as Emergent Models: The construction uses a one-sided tape for symbols, a parallel marker tape for head position, and a control vertex for the head state.The marker tape has one true marker and false markers elsewhere, while the control vertex stores a state in Q.
  • A.1 Turing machines as Emergent Models: Its global alphabet combines tape symbols, control states, and true/false head-position markers.The alphabet is defined as W := Γ ∪ Q ∪ {T, F}.
  • A.1 Turing machines as Emergent Models: The generalized automaton’s state space assigns symbols from the global alphabet across the tape, marker tape, and control vertex.The state space is defined over the vertices V1, V2, and V3.
  • A.1 Turing machines as Emergent Models: The halting predicate returns 1 exactly when the control vertex stores qhalt.It reads the control vertex rather than the tape or marker tape.
  • A.1 Turing machines as Emergent Models: The global transition f : S → S executes one Turing-machine step by locating the head, reading the relevant symbol and state, applying δ, and updating the configuration.The update writes the new tape symbol, moves the head marker, and changes the control cell.

A.2 Universal Turing machines

A universal Turing machine simulates any machine from a finite program and input encoded into its initial state. In EM notation, this encoding can use a computable pairing operation, including disjoint constructions that keep program and input separate.

  • Universal Turing machine: A universal Turing machine U simulates an arbitrary Turing machine M on input x when initialized with the paired state ⟨p_M, x⟩, where p_M is a finite program describing M.The pairing convention compiles program and input into U’s initial tape state.
  • Universal Turing machine: The fixed initialization scheme may computably rewrite raw input into U’s required representation, such as through block expansions, without depending on M or x.This scheme is fixed for the particular machine U.
  • EM formulation: With an arbitrary computable combining operator ⊕: S × S → S, the UTM initialization can be written in EM form as s_0 = p_M ⊕ E(x).E may transform the input, while ⊕ performs the computable pairing with the program.
  • Disjoint formulation: Disjoint formulations place the program and encoded input in separate regions or tapes, with ⊕ merely placing them side by side and the encoder independent of M.Examples include the standard textbook three-tape UTM, Watanabe’s 5,8 UTM, and Rendell’s SUTM.

A.3 Proof sketch of Theorem 1

The proof constructs an Emergent Model with fixed substrate and interface that realizes any partial computable binary function by varying only a finite-support initial latent state. It instantiates this latent universality both through a strongly universal Turing machine and through Conway’s Game of Life.

  • Universal-machine construction: For any partial computable function g, initializing the model with the compiled description p = ⟨M_g⟩ makes the induced map Φ_p compute g on every input.Defined inputs halt with g(x) returned; undefined inputs do not halt and therefore produce undefined output.
  • Universal-machine construction: A strongly universal Turing machine U is encoded as the fixed substrate and interface, with initialization, halting detection, and output decoding held fixed.The input is paired with a compiled machine program through p_M ⊕ E(x), while H detects halting and D reads the tape output.
  • Finite-support universality: Both the program p and initialized state p ⊕ E(x) have finite support, so every partial computable binary function is realizable from a finite non-blank latent pattern.The latent state consists of a finite input word followed by an infinite blank background.
  • Game of Life instantiation: Conway’s Game of Life on Z2 admits latent universality: a fixed Emergent Model has a finite-support pattern p whose induced map Φ_p computes any partial computable function.Rendell’s construction embeds a universal Turing machine in GoL and uses a fixed finite-support encoding for the machine description and input.
  • Game of Life instantiation: In the GoL construction, the simulated machine description and working tape occupy spatially distinct regions, enabling the initialization to factor into program and encoded-input components.The program occupies a disjoint finite-support region, while E(x) overwrites a modular input region corresponding to UTM tape cells and symbols.

A.4 Computation and Modeling on the Continuous

This section clarifies continuous computation by making arbitrary-precision approximation explicit. It uses finite-string encodings of inputs discretized to arbitrary precision, rather than infinite representations of real numbers.

  • Continuous computation: The framework defines arbitrary-precision approximation for continuous-valued functions and elaborates this notion here.Exact computation is used for discrete functions, while continuous-valued functions are handled through arbitrary-precision approximation.
  • Continuous computation: Standard computable analysis represents real inputs through infinite names, reading as much representation as needed for the requested output accuracy.This approach treats computation over real numbers through potentially unbounded input representations.
  • Continuous computation: This framework instead discretizes inputs to arbitrary precision and encodes them as finite strings, keeping the formulation close to ordinary computation theory.The finite-string formulation is presented as a simpler alternative to standard computable analysis.

A.4.1 Finite dyadic representations

Finite dyadic representations encode numbers as finite binary strings. Because dyadic rationals are dense in R, increasing string length allows arbitrarily precise finite approximations of any real input.

  • Definition: Dyadic rationals have finite binary representations and can therefore be encoded as finite strings.The section defines the set D as numbers with finite binary representations.
  • Approximation: The set D is dense in R, so every real input x can be approximated by a finite dyadic x_fin within any positive tolerance δ.For every x ∈ R and δ > 0, a finite dyadic approximation exists.
  • Precision: Increasing the number of binary digits makes the dyadic grid finer and permits arbitrarily close approximation of any real number.The model receives a finite dyadic approximation whose precision increases with the length of the finite string.

A.4.2 Exact computation on dyadic inputs

On dyadic inputs, Emergent Model computation reduces to ordinary discrete computation through a finite program that induces a partial map. A universal Turing machine can compute exactly any partial computable dyadic function, halting on inputs in its domain and diverging otherwise.

  • On dyadic inputs, computation is ordinary discrete computation, and a finite program θ induces a partial map.
  • A model computes a dyadic-valued partial computable function when it is total on the subset eD.
  • For inputs outside eD, the model’s computation is undefined because it never halts.
  • A universal Turing machine computes exactly any partial computable dyadic function, halting on domain inputs and diverging otherwise.

A.4.3 Continuous computation as arbitrary-precision approximation

The section defines continuous computation as arbitrary-precision approximation using finite-precision dyadic input and output representations. A fixed output tolerance may be achieved with input precision that varies by real input, rather than requiring uniform global precision.

  • Definition: Continuous computation is understood in the arbitrary-precision approximation sense, with inputs and outputs represented by finite-precision dyadics.The passage explicitly defines “computes” this way for continuous-valued partial functions.
  • Approximation guarantee: For every output tolerance ε > 0, a finite program θε exists that approximates every real input using some suitable input tolerance δ.The required δ may depend on the particular input x.
  • Precision requirements: The output tolerance ε is global, but the necessary input tolerance δ may vary across the domain because some regions are more sensitive to perturbations.The framework requires each real input to admit some sufficient finite precision, not one uniform precision level for all inputs.

A.4.4 Asymptotic form

The asymptotic formulation lets finite dyadic inputs become exact as input tolerance tends to zero, and defines computation through limiting programs that uniformly approximate the target. It leaves open whether these programs converge to one exact asymptotic program as output tolerance vanishes.

  • A.4.4 Asymptotic form: As input tolerance tends to zero, δ →0 and the finite dyadic approximation xfin tends to the real input x.This asymptotic perspective is formulated for every real input x.
  • A.4.4 Asymptotic form: For each output tolerance ε > 0, a finite program θε induces a limiting function when that limit exists for every x ∈e X.The limiting function is defined from increasingly precise finite inputs.
  • A.4.4 Asymptotic form: The model computes g when every ε > 0 admits a finite program whose limiting function uniformly approximates g over the whole domain.The approximation requirement applies everywhere on the domain, not only to selected inputs.
  • A.4.4 Asymptotic form: Whether the programs θε converge as ε →0 to a single program θ realizing exact asymptotic computation is left unaddressed.This is identified as a stronger theoretical question.
Loading 2608.14019v1…