Simulation 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.

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.