Cellular Automata From First Principles on AIBussin — AI applications, systems and books

How Can Tiny Rules Build Complex Worlds?

Mon, 10 Aug 2026 18:20:00 +0100

A cellular automaton begins with almost nothing.

You need:

a collection of cells,
a state for each cell,
a neighborhood,
and a rule that tells each cell what to become next.

That is enough.

There is no central controller.

There is no object that knows what the final pattern should look like.

There is only local state changing through time.

And yet some local rules produce stripes, fronts, oscillators, moving structures, traffic waves, cave systems, self-repairing patterns, and systems rich enough to perform computation.

Build Your First Automaton

Mon, 10 Aug 2026 18:21:00 +0100

In the previous chapter we reduced a cellular automaton to four things:

space
state
neighborhood
rule

Now we are going to build one.

Not a framework.

Not a library.

One update step.

That is enough to expose the whole mechanism.

Start with a one-dimensional world

Create a row of cells and turn on the center cell:

import numpy as np

width = 41
state = np.zeros(width, dtype=np.uint8)
state[width // 2] = 1

print(state)

Conceptually:

....................#....................

We will use 0 for an empty cell and 1 for an active cell.

Encode All 256 Elementary Rules

Mon, 10 Aug 2026 18:22:00 +0100

In the previous chapter we built one rule: a cell becomes active when exactly one of its three neighbors is active. That turned out to be Rule 22, but we treated it as a hand-written function.

Now we generalize. Instead of writing one function per rule, we encode every possible elementary rule as a single integer — and get all 256 automata for the price of one simulator.

An elementary cellular automaton has only three inputs per cell:

Rule 30 and the Surprise of Complexity

Mon, 10 Aug 2026 18:23:00 +0100

The previous chapter gave us a simulator that can run any of the 256 elementary rules. Now we pick one and look at it closely. Rule 30 is the standard demonstration of why cellular automata are worth studying.

Its transition table contains eight bits — the same encoding as in the previous chapter, repeated here so you can check the simulator line by line:

111 110 101 100 011 010 001 000
 0 0 0 1 1 1 1 0

Start from one active cell and repeatedly apply that rule.

Rule 110 and Computation in a Grid

Mon, 10 Aug 2026 18:24:00 +0100

Rule 110 looks like another one-byte transition table.

111 110 101 100 011 010 001 000
 0 1 1 0 1 1 1 0

But its behavior gives us a much deeper idea: a cellular automaton can become a computational medium.

The important shift is this:

pattern generator
 ->
signal system
 ->
computation

Rule 110 is computationally universal — under suitable encodings and initial conditions. Matthew Cook published the universality proof in Complex Systems in 2004, settling a conjecture Wolfram had made in the mid-1980s: this elementary one-dimensional automaton can emulate universal computation.

Conway's Game of Life

Mon, 10 Aug 2026 18:25:00 +0100

The previous chapter ended on a limit of one dimension: time supplies the second visual axis, but structures cannot move inside the world. In two dimensions they can. Conway’s Game of Life is one of the cleanest examples of intricate two-dimensional behavior emerging from a tiny local rule.

John Conway devised it in 1970; Martin Gardner’s October 1970 Scientific American column introduced it to a wide audience and triggered the volunteer zoology of patterns — still lifes, oscillators, spaceships — that made Life the most studied cellular automaton in history.

Patterns as Data — Oscillators, Spaceships and Gliders

Mon, 10 Aug 2026 18:26:00 +0100

Once we can run Conway’s Game of Life, the next step is not to add more graphics.

It is to make the patterns themselves inspectable.

A blinker is not interesting because somebody named it.

It is interesting because it returns to the same state after two generations — a testable dynamical property, not an aesthetic judgment. Throughout this chapter, “interesting” always cashes out into something executable: a period, a displacement, a fingerprint match.

Beyond Conway — Life-like and Multi-State Rules

Mon, 10 Aug 2026 18:27:00 +0100

The previous chapter ended on a causal direction: the rule produces the structures, and only then do we give the structures names. Change the rule and the names change with it.

That matters because Conway’s Game of Life is famous enough that it can accidentally become the definition of cellular automata.

It is not.

Life is one point in a much larger design space.

Keep the same two-dimensional grid and the same eight-cell Moore neighborhood, then change only the birth and survival counts.

Add Randomness Without Losing the Model

Mon, 10 Aug 2026 18:34:00 +0100

So far every transition in the book has been deterministic.

Given the same state, the next state is fixed.

That makes deterministic automata unusually easy to debug: if we preserve the initial condition and rule, we preserve the trajectory.

But many useful models need another ingredient.

A tree may ignite.

An organism may reproduce.

A driver may hesitate.

A material defect may appear.

The local rule can still be precise even when the outcome is probabilistic.

Build a Forest Fire Simulation

Mon, 10 Aug 2026 18:36:00 +0100

The previous chapter put probability into the rule. A forest fire is almost an ideal first exercise for using it.

The visible states are obvious:

0 = empty
1 = tree
2 = burning

The interactions are local.

And small changes in fuel density or ignition assumptions can produce very different global outcomes.

This is not intended as a high-fidelity wildfire model.

It is a deliberately simplified spread model designed to isolate one mechanism:

Simulate Traffic with Rule 184

Mon, 10 Aug 2026 18:38:00 +0100

The forest fire consumed its fuel. Rule 184 is the opposite case: a conserved quantity that moves. It is also a clean example of going from an abstract rule table to a model with a concrete interpretation.

Use a one-dimensional ring road:

1 = car
0 = empty road

A car moves one cell to the right when the destination is empty.

That is enough to produce free flow, queues and a macroscopic density-flow relationship.

Diffusion as Local Exchange

Mon, 10 Aug 2026 18:40:00 +0100

Until now most cells have stored discrete state:

0 / 1
empty / tree / fire
road / car

Now let each cell store a continuous quantity.

For diffusion:

state[y, x] = concentration

The local transition is no longer birth, death or movement.

It is local exchange.

This steps outside the strict finite-state definition — a deliberate extension, flagged as such, that the book will keep developing through reaction-diffusion, Lenia, and learned automata.

Reaction-Diffusion and Pattern Formation

Mon, 10 Aug 2026 18:42:00 +0100

Diffusion smooths differences.

Reaction can amplify them.

Put the two processes together and a nearly uniform field can develop persistent spots, stripes and fronts.

We will use a discrete Gray-Scott reaction-diffusion simulation because it gives us a compact bridge from local cellular updates to continuous pattern-forming dynamics. The model originates with Gray and Scott’s autocatalytic chemistry; John Pearson’s 1993 Science paper showed that finite-amplitude perturbations of it produce a surprising variety of spatiotemporal patterns — which is exactly the experiment this chapter runs.

Build a Predator-Prey Ecosystem

Mon, 10 Aug 2026 18:44:00 +0100

Gray-Scott, like the forest fire, transforms each cell in place.

Rule 184 moves occupancy, but in one constrained direction.

An ecosystem adds a harder problem:

organisms move
organisms reproduce
predators consume prey
several organisms may want one destination

Now local intentions can conflict.

That means update semantics become part of the model.

Separate visible kind from internal state

Start with:

0 = empty
1 = prey
2 = predator

import numpy as np

EMPTY = 0
PREY = 1
PREDATOR = 2

kind = np.zeros(
 (100, 100),
 dtype=np.uint8,
)

A richer model may need predator energy, age or reproduction state.

Generate Caves from Noise

Mon, 10 Aug 2026 18:46:00 +0100

A cave generator can be built from a mechanism we already understand:

random initial cells
 ↓
count nearby walls
 ↓
apply local smoothing rule
 ↓
repeat a few times
 ↓
stop and use the result

Unlike a forest-fire simulation, we are not trying to model an indefinitely evolving world.

Here the cellular automaton is a construction process.

The smoothing rule below belongs to a documented family: roguelike developers call the classic form the 4-5 rule — a tile becomes a wall if its 3×3 neighborhood (counting itself) holds at least 5 walls — usually run from ~45% initial fill for about five iterations. This chapter uses a stricter one-threshold variant; the Research section traces the lineage and the parameter consequences.

Grow Terrain from Local Height Rules

Mon, 10 Aug 2026 18:48:00 +0100

Binary caves ask:

wall or floor?

Terrain needs richer state.

Let each cell store a height:

0.0 = low
1.0 = high

Now local rules can smooth, raise, erode and classify terrain.

The challenge is not creating a pretty array.

It is creating a process whose output we can explain and control.

Start with a height field

import numpy as np


def random_heightmap(
 rows=120,
 cols=160,
 seed=42,
):
 rng = np.random.default_rng(seed)

 return rng.random(
 (rows, cols)
 )

Raw independent noise contains variation but little large-scale geography.

Generate Textures with Local Rules

Mon, 10 Aug 2026 18:50:00 +0100

Cellular automata do not need to represent a literal physical system.

They can also be used as visual machines.

The same ingredients we have used throughout the book:

local state
neighborhood perception
shared update
repetition

can generate masks, growth patterns, surface variation and animation.

The evaluation question changes.

Instead of asking:

Is this physically accurate?

we ask:

Does this local process produce useful, controllable visual structure?

That still demands more than “it looks interesting” — and this chapter’s metrics section holds it to that standard.

Measure a Cellular Automaton

Mon, 10 Aug 2026 18:50:00 +0100

Up to this point we have mostly looked at cellular automata.

That is useful.

It is also limiting. Part II closed by asking how we tell which worlds are dynamically interesting, and looking cannot answer that at scale.

A human can inspect a handful of spacetime diagrams.

We cannot reliably inspect:

256 elementary rules
× several initial conditions
× several widths
× hundreds of generations
× repeated stochastic runs

by eye.

Activity, Density and Change

Mon, 10 Aug 2026 18:51:00 +0100

A cellular automaton can look busy while doing very little that persists.

It can also look visually quiet while preserving a small moving structure for hundreds of generations.

So we need to separate several properties that are easy to confuse:

occupancy
temporal change
spatial variation
persistence

The first three are owned by the previous chapter — density, change_rate/change_curve (our activity observable), and spatial_variation — and are reused here without redefinition. This chapter adds what they cannot see: whether change persists, where it happens, and how runs end.

Entropy and Information

Mon, 10 Aug 2026 18:52:00 +0100

A row with almost all zeros is highly predictable.

A row containing a balanced mixture of zeros and ones is less predictable.

Shannon entropy gives us a precise way to measure that uncertainty — defined by Claude Shannon in 1948 as the expected surprise of a distribution, measured here in bits (base 2).

This chapter formally owns what Chapter 3 previewed: the preview binary_entropy becomes the definition below, with the base convention, edge cases, and limitations stated properly.

Periodicity and Attractors

Mon, 10 Aug 2026 18:53:00 +0100

Many cellular automata eventually repeat.

A fixed point repeats every generation.

An oscillator repeats after several generations.

On a finite grid, deterministic cellular automata must eventually revisit a previous state because only finitely many states exist.

That makes cycle detection a fundamental measurement: where entropy asked how uncertain a state is, recurrence asks whether the dynamics ever come back.

Hash each state

For binary arrays we can store the bytes:

Sensitivity to Initial Conditions

Mon, 10 Aug 2026 18:54:00 +0100

Change one cell.

Then run the same rule twice.

If the two futures remain almost identical, the rule is insensitive to that perturbation.

If the difference spreads, the rule amplifies local uncertainty.

That is one of the cleanest experiments we can perform on a cellular automaton.

One language note up front: this chapter says “sensitive” and “irregular,” never “chaotic” in the formal dynamical-systems sense. Whether any cellular automaton earns that stronger word is a classification question for the next chapter, which owns the class vocabulary.

Classify Rule Behavior

Mon, 10 Aug 2026 18:55:00 +0100

We now have six kinds of measurement. The literature already offers a coarser tool for organizing rules: four broad behavioral classes.

Class I -> settles to homogeneous behavior
Class II -> settles to simple stable or periodic structures
Class III -> irregular, apparently random behavior
Class IV -> persistent local structures and complex interactions

These labels are useful vocabulary — phenomenological shorthand from Wolfram’s 1980s survey, not formal dynamical-systems theorems. “Class III” here means Wolfram-class irregularity, not proven chaos in the mathematical sense; the book has called Rule 30 “irregular” until now for exactly this reason, and this chapter does not upgrade that word.

Search All 256 Elementary Rules

Mon, 10 Aug 2026 18:56:00 +0100

Elementary cellular automata give us a rare luxury.

The complete rule space is tiny.

There are only:

256 rules

So we do not need sampling, intuition or famous examples.

We can evaluate every rule.

Build an experiment runner

Reuse the owned helpers with their real signatures — Chapter 18’s runner (rule number, width, generations, seed, single-or-random start) and Chapter 19’s fingerprint:

def scan_rules(width=201, generations=200):
 records = []

 for rule in range(256):
 history = run_rule(
 rule,
 width=width,
 generations=generations,
 )

 record = fingerprint(history)
 record["rule"] = rule
 record["mean_entropy"] = float(
 entropy_curve(history).mean()
 )
 record["compression_ratio"] = compression_ratio(
 history
 )
 record.update(recurrence_metrics(history))

 records.append(record)

 return records

The hard part is no longer execution.

Search Larger Rule Spaces

Mon, 10 Aug 2026 18:57:00 +0100

The 256 elementary rules are small enough to enumerate.

Most interesting cellular-automata design spaces are not.

Add more states, a larger neighborhood, continuous parameters, or several channels and exhaustive search quickly becomes impossible.

So we need search strategies.

Why the rule space explodes

For k possible cell states and a neighborhood containing n cells, there are:

k^n possible neighborhood configurations

A deterministic rule chooses one of k outputs for every configuration, giving:

Evolve Rules for Desired Behavior

Mon, 10 Aug 2026 18:58:00 +0100

Once we can represent a rule, mutate it and measure its behavior, we can evolve cellular automata.

The key idea is simple:

population of rules
 ↓
simulate
 ↓
measure
 ↓
select
 ↓
mutate
 ↓
repeat

This chapter builds that loop without hiding it behind an optimization framework. “Evolution” here is algorithmic — genomes, mutation, selection over rule bits — not a biological claim. The genotype is eight bits; the phenotype is the measured trajectory.

Cellular Automata as Computation

Mon, 10 Aug 2026 18:59:00 +0100

A cellular automaton is a state machine distributed across space.

Each cell reads local information, applies the same transition rule, and writes a new state.

That is computation in the thin sense: deterministic state transformation. Every automaton in this book computes, in that sense, every step it runs.

The deeper question — and the one this chapter formally owns — is whether local patterns can carry, transform and combine information in a way that supports general computation. Chapter 5 gave the first exposure through Rule 110’s gliders; here universality becomes a precise comparative property rather than an impressive example.

From Discrete Cells to Continuous State

Mon, 10 Aug 2026 19:43:00 +0100

So far most of our cellular automata have used a small set of states:

0 or 1
empty / prey / predator
ready / firing / refractory

That makes rules easy to inspect.

But it also forces every update to make a hard categorical decision.

What happens if a cell can instead hold any value between 0 and 1?

0.0 -------------------------- 1.0

Now a cell can represent intensity, density, concentration, activation or some abstract amount of local material.

Neighborhoods as Convolution Kernels

Mon, 10 Aug 2026 19:45:00 +0100

A neighborhood does not have to be a list of nearby coordinates.

It can be a spatial weighting function.

That lets us say:

cells near this radius matter a lot
cells closer in matter less
cells farther away do not matter at all

The standard programming tool for applying that same weighted neighborhood everywhere is convolution.

Start with a small kernel

import numpy as np

kernel = np.array([
 [0.0, 0.1, 0.0],
 [0.1, 0.6, 0.1],
 [0.0, 0.1, 0.0],
])

Normalize it:

Growth Functions

Mon, 10 Aug 2026 19:48:00 +0100

We now have two pieces:

continuous state
 ↓
weighted neighborhood

But a neighborhood value does not tell us what should happen next.

We need a response curve.

In Lenia-style systems that curve is usually called a growth function.

It converts neighborhood potential into local growth or decay. This generalizes Chapter 28’s growth_function: same Gaussian-bump shape, now with explicit mu (preferred density) and sigma (tolerance) parameters instead of fixed constants.

Build Lenia From First Principles

Mon, 10 Aug 2026 19:51:00 +0100

We now have every conceptual component needed for a minimal Lenia implementation:

continuous state
radial kernel
convolution
smooth growth function
small time step
bounded update

This chapter assembles them into one runnable system — one historically important system, due to Bert Wang-Chak Chan (“Lenia: Biology of Artificial Life,” Complex Systems 28(3), 2019): not generic continuous CA, but Lenia specifically. The framing for this part so far:

Ch28–30
= components

Ch31
= one historically important system built from those components

Fidelity statement

The engine below implements the canonical Lenia update exactly — state plus timestep-scaled growth of the convolved field, clipped to [0, 1] — with the exponential growth mapping from Chan’s paper. It differs from full Lenia in scope, stated here so later comparisons use the same baseline:

Discover Your First Lenia Organisms

Mon, 10 Aug 2026 19:54:00 +0100

Running Lenia is easy.

Finding persistent, localized, non-trivial structures is the hard part.

This chapter turns that problem into a repeatable search pipeline. It follows Chan’s discovery playbook structurally — random soup generation, survival filtering, parameter tweaking, and, crucially, human judgment for what counts as interesting — while automating the parts that do not need eyes.

Define what counts as a candidate

We should not start with the vague objective:

Search Lenia Parameter Space

Mon, 10 Aug 2026 19:57:00 +0100

A Lenia pattern is not defined by its initial state alone.

It also lives inside a particular dynamical world.

Change the kernel or growth function slightly and the same seed may:

die
explode
freeze
oscillate
move
split
stabilize into a different morphology

So discovery has two coupled search spaces:

initial condition
 +
world parameters

Define parameter ranges

PARAM_RANGES = {
 "radius": (8, 24),
 "ring_center": (0.25, 0.75),
 "ring_width": (0.05, 0.25),
 "mu": (0.05, 0.30),
 "sigma": (0.01, 0.08),
 "dt": (0.03, 0.20),
}

These ranges are experimental choices.

Multi-Kernel and Multi-Channel Lenia

Mon, 10 Aug 2026 20:00:00 +0100

Our Lenia implementation has one scalar field:

A(x, y)

and one kernel:

That is enough for rich behavior.

But it also forces every local process to share the same spatial scale and the same state variable.

A richer model can use multiple channels:

A0(x, y)
A1(x, y)
A2(x, y)

and multiple kernels linking them.

This chapter builds a pedagogical multi-channel formulation in Lenia’s spirit — a connection graph with per-edge kernels and growth parameters. Canonical multi-kernel, multi-channel Lenia is Chan’s “Expanded Universe” (ALIFE 2020) direction; the book’s version is simpler and says so, keeping the graph inspectable rather than matching the canonical matrix formulation.

Damage, Robustness and Persistence

Mon, 10 Aug 2026 20:03:00 +0100

A pattern that survives in perfect conditions is only the beginning.

A stronger artificial-life question is:

What happens when the pattern is disturbed?

We can turn that into an experiment.

Define damage explicitly

Start with a rectangular ablation:

def damage_rectangle(state, y0, y1, x0, x1):
 damaged = state.copy()
 damaged[..., y0:y1, x0:x1] = 0.0
 return damaged

For a single-channel state:

damaged = damage_rectangle(state, 55, 70, 55, 70)

For multi-channel state, the ellipsis damages all channels in the same spatial region.

Flow-Lenia and Mass-Conserving Artificial Life

Mon, 10 Aug 2026 20:06:00 +0100

Ordinary Lenia updates local state by adding growth:

A(t + dt) = clip(A(t) + dt × G(U))

That means state can be created in one region and destroyed in another.

For many artificial-life experiments that is perfectly acceptable.

But it leaves a major question:

What changes if local structure must reorganize existing mass instead of creating or deleting it?

Flow-Lenia — Plantec et al. (2023), “Flow-Lenia: Towards open-ended evolution in cellular automata through mass conservation and parameter localization” — explores exactly that direction through two ideas: reformulating the update around transport so mass is conserved, and embedding rule parameters as local fields rather than global constants. This chapter presents both ideas with small pedagogical models, honestly labeled as stepping stones rather than reproductions.

Make the Automaton Differentiable

Mon, 10 Aug 2026 20:31:00 +0100

So far every rule in this book has been chosen by us.

Even Lenia still asks us to decide the neighborhood kernel, the growth function and the parameters that connect them.

What if we stop designing the local rule directly?

What if we define only the goal, then let gradient descent discover a local update rule that achieves it? (Designed here, learned starting now — Chapter 36’s bridge sentence becomes this chapter’s premise.)

Learn the Local Update Rule

Mon, 10 Aug 2026 20:32:00 +0100

A neural cellular automaton does not need a large neural network.

It needs a small local network applied everywhere.

That distinction matters.

The capability of the system comes less from the size of one cell’s computation and more from the repeated interaction of many cells over time. (Not “intelligence” — computational capacity through recurrence, in the book’s established vocabulary.)

Perception first

Each cell needs information about itself and nearby cells.

Hidden Cell Channels and Local Memory

Mon, 10 Aug 2026 20:34:00 +0100

A visible pixel is not enough state for a cell that must also coordinate growth.

So give every cell a vector.

[R, G, B, alpha, h1, h2, ... h12]

The first channels can be rendered. The rest are private internal state. (Chapter 37 deferred hidden-channel ownership here; this chapter takes it.)

CHANNELS = 16
VISIBLE = 4

state = torch.zeros(1, CHANNELS, 64, 64, device=DEVICE)

The hidden channels have no labels. We do not tell the model that channel 8 means “distance from the center” or channel 11 means “grow east”. If useful internal signals exist, training must discover them.

Grow a Target From One Seed

Mon, 10 Aug 2026 20:35:00 +0100

Now we can pose the central morphogenesis problem:

Start from one cell and learn local rules that construct a target pattern.

Note what this chapter is not: it is not asynchronous scheduling (that is the next chapter), nor persistence or regeneration training (later chapters own those objectives). One objective — growth to target — trained and honestly evaluated.

Prepare a target

Assume an RGBA image has been loaded into a tensor:

Randomize the Update Schedule

Mon, 10 Aug 2026 20:36:00 +0100

Most cellular automata in this book have used synchronous updates:

all cells observe state_t
all cells update
state_t+1 appears

Neural cellular automata are typically trained with randomized update schedules: there is no global clock, and cells cannot rely on exact phase relationships. The aim is robustness to timing, which we will measure rather than assume.

Stochastic firing

Instead of applying every predicted update, sample a binary mask:

def stochastic_update(x, dx, fire_rate=0.5):
 mask = (
 torch.rand(
 x.shape[0], 1, x.shape[2], x.shape[3],
 device=x.device,
 ) <= fire_rate
 )
 return x + dx * mask

Half the cells update on average.

Train for Persistence

Mon, 10 Aug 2026 20:37:00 +0100

Growing a target once is not enough.

A useful self-organizing system should continue to satisfy its objective after it arrives.

That means the target should behave more like an attractor than a timestamped frame. Operationally: low loss sustained over an extended interval past the growth horizon — not exact state invariance, not biological homeostasis.

The failure mode

Suppose training always evaluates at step 64.

The model can learn:

seed
 ↓
grow
 ↓
target at step 64
 ↓
overshoot
 ↓
disintegrate

The loss never sees the failure after step 64.

Regenerate After Damage

Mon, 10 Aug 2026 20:38:00 +0100

Persistence asks whether the organism can remain near its target.

Regeneration asks a different question:

after part of the state is destroyed, can local rules reconstruct the missing structure?

This is a much stronger test.

Damage the state, not just the image

If we erase only visible RGBA channels but leave hidden channels untouched, the model may retain a perfect invisible blueprint.

A harder test removes all channels inside the damaged region.

Test Generalization Beyond Training

Mon, 10 Aug 2026 20:39:00 +0100

A model can look robust while still depending on the exact conditions used during training.

So after growth, persistence and regeneration, we need a harder question:

what happens when the world changes?

Build a generalization matrix

Vary dimensions independently:

canvas size
seed position
update rate
rollout length
damage geometry
damage severity
noise level
boundary conditions

Then evaluate combinations that were not used during training. The table at the end of this chapter is executable scaffolding, not a report: every row specifies how to measure, and the verdicts get filled in by running, starting from one held-out axis at a time rather than all shifts at once.

Neural Cellular Automata for Pathfinding

Mon, 10 Aug 2026 20:37:00 +0100

Until now our neural cellular automata have learned to make and maintain shapes.

Now we will ask them to compute something.

Given:

walls
start
finish

can a shared local update rule discover a path?

This is an unusually good task for an NCA because classical pathfinding already has a local interpretation — and because recent work (Earle et al., 2023) has shown both hand-coded and learned BFS/DFS inside the NCA framework, with generalization tested on harder distributions. That paper is this chapter’s running reference: it shows the task is learnable in that setup and sets the evaluation standard.

Learn to Solve Mazes

Mon, 10 Aug 2026 20:38:00 +0100

A pathfinding NCA becomes interesting only when the training problem itself is disciplined.

If every maze has the same size, wall density and corridor style, the model may learn the dataset more than the algorithm.

So this chapter builds the training system around procedural variation.

Generate mazes as data

Start with binary occupancy:

0 = open
1 = wall

One simple generator begins with random walls. It does not reject disconnected examples; the BFS teacher below marks unreachable cells with a mask instead.

Generalize to Harder and Larger Mazes

Mon, 10 Aug 2026 20:39:00 +0100

Training accuracy answers the easiest question:

Can the model solve problems drawn from the training distribution?

The more interesting question is:

Did the local rule learn a reusable computation?

This chapter turns that into an explicit evaluation protocol.

Hold out dimensions of difficulty

Instead of one validation set, create several test families.

For example:

A: 32×32, familiar wall density
B: 48×48, familiar wall density
C: 64×64, familiar wall density
D: 32×32, denser obstacles
E: 32×32, longer required paths
F: different procedural maze generator
G: narrow bottlenecks and many dead ends

The point is not to maximize one aggregate score.

Inspect Hidden-State Propagation

Mon, 10 Aug 2026 20:40:00 +0100

A neural cellular automaton can solve a maze while most of its computation remains invisible.

The visible output might be one distance channel.

The internal state may contain eleven hidden channels (5–15 in the maze layout) evolving underneath it.

This chapter asks:

what is moving through those hidden channels while the answer is being computed?

Capture the entire state trajectory

Instead of saving only the final output — rollout_frozen plus per-step recording, same clamped execution, now with a trace:

What Did the Neural CA Actually Learn?

Mon, 10 Aug 2026 20:41:00 +0100

Visualization gives us hypotheses.

Intervention gives us evidence.

If we suspect a hidden channel carries useful information, the next question is simple:

what happens if we remove it?

This chapter turns NCA interpretability into controlled experimentation.

Establish the behavioral baseline

Before touching the model, record its normal performance — with a defined suite, not an anecdote:

def score_maze(final, walls, start, goal):
 dist = final[0, 3].detach().cpu().numpy()
 optimal_dist = bfs_distance(walls, goal)

 if not np.isfinite(optimal_dist[start]):
 return ("unreachable", int(np.all(dist <= 0.05)))

 path = descend_path(dist, start, goal, walls)

 if path[-1] != goal:
 return ("unsolved", None)

 excess = len(path) - 1 - int(optimal_dist[start])
 return ("solved", excess)


def evaluate_suite(model, mazes, steps=128, runner=None):
 run = runner or rollout_frozen
 solved = optimal = unreachable_ok = 0
 excess, unreachable = [], 0

 for walls, start, goal in mazes:
 state = make_state(walls, start, goal)
 frozen = state.clone()
 final = run(model, state, steps, frozen)
 kind, value = score_maze(final, walls, start, goal)

 if kind == "unreachable":
 unreachable += 1
 unreachable_ok += value
 elif kind == "solved":
 solved += 1
 optimal += int(value == 0)
 excess.append(value)

 n = len(mazes) - unreachable

 return {
 "valid_path_rate": solved / max(1, n),
 "optimal_path_rate": optimal / max(1, n),
 "mean_excess": float(np.mean(excess)) if excess else float("nan"),
 "unreachable_accuracy": unreachable_ok / max(1, unreachable),
 }

(Verified: executes end to end on test mazes; an untrained stub scores zero throughout — the harness measures rather than flatters.)

Profile Before You Optimize

Mon, 10 Aug 2026 20:52:00 +0100

By now we have built dozens of automata.

The natural temptation is to make them faster.

The wrong first question is:

Which optimization trick should I use?

The right first question is:

Where is the time actually going?

Performance work begins with measurement, and with the doctrine Part VI starts from:

Optimize the verified implementation, not the first implementation that happens to render something plausible.

Running this book’s own earlier code turned up undefined helpers, wrong signatures and a misaligned FFT, all inside chapters that produced plausible figures. Speed means nothing until equivalence is established.

Vectorize the Update Loop

Mon, 10 Aug 2026 20:53:00 +0100

A cellular automaton is local.

That does not mean we should update it cell by cell in Python.

For dense grids, the same local rule is applied everywhere. That regularity is exactly what array programming is good at.

Start with the obvious implementation

def life_step_slow(grid):
 height, width = grid.shape
 next_grid = np.zeros_like(grid)

 for y in range(height):
 for x in range(width):
 total = 0
 for dy in (-1, 0, 1):
 for dx in (-1, 0, 1):
 if dx == 0 and dy == 0:
 continue
 total += grid[(y + dy) % height, (x + dx) % width]

 alive = grid[y, x] == 1
 next_grid[y, x] = (
 total == 3 or (alive and total == 2)
 )

 return next_grid

This is useful because it states the mechanism clearly.

Run Cellular Automata on the GPU

Mon, 10 Aug 2026 20:54:00 +0100

Once the update is expressed as tensor operations, moving to a GPU becomes straightforward.

But a GPU is not automatically faster.

It wins when there is enough parallel work to amortize transfer and launch overhead.

A tensor implementation of Life

import torch
import torch.nn.functional as F

LIFE_KERNEL = torch.tensor(
 [[1.0, 1.0, 1.0],
 [1.0, 0.0, 1.0],
 [1.0, 1.0, 1.0]]
).view(1, 1, 3, 3)


def life_step(x):
 padded = F.pad(x, (1, 1, 1, 1), mode="circular")
 neighbors = F.conv2d(padded, LIFE_KERNEL.to(x.device))
 alive = x > 0.5
 born = neighbors == 3
 survive = alive & (neighbors == 2)
 return (born | survive).float()

Two things matter here beyond the convolution. First, this is the third life_step in the book (after Chapters 6 and 51) — same B3/S23 rule, new backend, bridged explicitly rather than silently redefined. Second, the padding mode is load-bearing: plain padding=1 zero-pads, which silently changes periodic boundaries into dead ones. Circular padding preserves the torus semantics every roll-based helper in this book assumes — verified bit-identical against the NumPy version on 20 random grids, where the zero-padded variant mismatched all 20 at the edges.

Use FFTs for Large Neighborhoods

Mon, 10 Aug 2026 20:55:00 +0100

Small local neighborhoods are cheap to evaluate directly.

Large smooth kernels are different.

Lenia taught us that a neighborhood may cover dozens of cells in every direction. At that scale, direct convolution can become expensive.

The Fourier transform gives us another route — provided the kernel is centered correctly, which is where the FFT bug this book had to fix lived.

Convolution becomes multiplication

For periodic domains:

convolution in space
 ↕
multiplication in frequency

So instead of sliding a large kernel over every location, we can transform both arrays, multiply them, and transform back.

Build a Reusable Cellular Automata Engine

Mon, 10 Aug 2026 20:56:00 +0100

Across this book we repeatedly rebuilt the same pieces:

state
neighborhood
rule
step loop
measurements
rendering

That repetition was useful while learning.

Now it is time to turn those concepts into interfaces.

Keep the engine small

A useful engine does not need to know what Conway’s Life, Lenia or an NCA is.

It only needs to orchestrate state transitions.

from dataclasses import dataclass
from typing import Callable, Any


@dataclass
class Automaton:
 state: Any
 step_fn: Callable[[Any], Any]

 def step(self):
 self.state = self.step_fn(self.state)
 return self.state

 def run(self, steps):
 for _ in range(steps):
 self.step()
 return self.state

That is intentionally boring.

Make Experiments Reproducible

Mon, 10 Aug 2026 20:57:00 +0100

By this stage the book contains many systems whose behavior depends on parameters, seeds and implementation choices.

If we cannot reconstruct a run, we cannot really compare it.

Treat configuration as data

from dataclasses import dataclass, asdict


@dataclass(frozen=True)
class ExperimentConfig:
 model: str
 width: int
 height: int
 steps: int
 seed: int
 backend: str
 dtype: str
 params: dict = None

Then extend with model-specific parameters rather than hiding them in notebook cells.

Run Parameter Sweeps and Benchmarks

Mon, 10 Aug 2026 20:58:00 +0100

Once experiments are reproducible, we can stop treating parameters as one-off choices and start mapping behavior systematically.

A parameter sweep is not merely a convenience.

It is a way to turn a model into a measurable landscape.

Build a grid of experiments

Sweep over rules and seeds with owned machinery — Chapter 18’s runner and Chapter 19’s fingerprint, reused exactly:

from itertools import product


def sweep_rules(rules, seeds, width=201, generations=200):
 records = []

 for rule, seed in product(rules, seeds):
 history = run_rule(
 rule,
 width=width,
 generations=generations,
 seed=seed,
 initial="random",
 )
 records.append({
 "rule": rule,
 "seed": seed,
 **fingerprint(history),
 })

 return records

Notice the seed axis.

Generate Figures and Animations

Mon, 10 Aug 2026 20:59:00 +0100

Cellular automata are visual systems.

That makes figures and animations unusually important.

But a useful image is not merely a screenshot. It should be a reproducible output of an experiment.

Save figures from data, not from memory

Suppose an experiment has produced a spacetime history:

history = np.stack(states)

A figure generator should accept that result explicitly:

import matplotlib.pyplot as plt


def save_spacetime(history, path):
 fig, ax = plt.subplots(figsize=(10, 6))
 ax.imshow(history, interpolation="nearest", aspect="auto")
 ax.set_xlabel("cell")
 ax.set_ylabel("time")
 fig.tight_layout()
 fig.savefig(path, dpi=180)
 plt.close(fig)

(Verified headless: PNG written with labeled axes from recorded arrays.)

Build a Cellular Automata Laboratory

Mon, 10 Aug 2026 21:00:00 +0100

We now have enough pieces to stop thinking in terms of isolated scripts.

A useful cellular-automata laboratory should let us define, run, measure, replay and visualize experiments across many kinds of automata without hiding the mechanisms we spent the whole book learning.

The laboratory is not the model

Keep these concerns separate:

model definition
execution backend
experiment configuration
metrics
artifacts
analysis

A rule should not know where its PNG is saved.

Capstone — Discover, Measure and Explain a New System

Mon, 10 Aug 2026 21:01:00 +0100

The previous chapter built the laboratory. This one uses it on a single problem.

The book began with one tiny rule applied to one tiny neighborhood.

We end with a different question:

Can we discover a cellular system, characterize its behavior, test its robustness and explain what we actually know about it?

That is the capstone. It uses the ideas rather than listing them: every stage below reuses owned machinery — Lenia configs and kernels (Ch31), discovery scoring (Ch32), outcome classes (Ch33), the measurement stack (Ch18–22), perturbation discipline (Ch35), search strategy (Ch24–25), and experiment records (Ch55).