Simulation on Programmer.ie: Modern AI programming

Cellular Automata From First Principles 26: Cellular Automata as Computation

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

Cellular Automata From First Principles 26: Cellular Automata as Computation

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 already a form of computation.

The deeper question is whether local patterns can carry, transform and combine information in a way that supports general computation.

Information needs carriers

In ordinary software, information lives in variables and memory addresses.

Cellular Automata From First Principles 25: Evolve Rules for Desired Behaviour

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

Cellular Automata From First Principles 25: Evolve Rules for Desired Behaviour

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.

Represent a rule as bits

For an elementary CA, eight output bits completely define the rule:

Cellular Automata From First Principles 24: Search Larger Rule Spaces

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

Cellular Automata From First Principles 24: Search Larger Rule Spaces

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:

Cellular Automata From First Principles 23: Search All 256 Elementary Rules

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

Cellular Automata From First Principles 23: Search All 256 Elementary Rules

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

Assume we already have:

run_rule(rule_number, width, generations, initial_state)
fingerprint(history)

Then exhaustive search is simple:

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

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

        records.append({
            "rule": rule,
            **fingerprint(history),
        })

    return records

The hard part is no longer execution.

Cellular Automata From First Principles 22: Classify Rule Behaviour

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

Cellular Automata From First Principles 22: Classify Rule Behaviour

Cellular automata are often described using four broad behavioral classes:

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

These labels are useful vocabulary.

But if we want to use them experimentally, we should connect them to measurable evidence rather than treating them as magic categories.

Cellular Automata From First Principles 21: Sensitivity to Initial Conditions

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

Cellular Automata From First Principles 21: Sensitivity to Initial Conditions

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.

Create two nearby initial states

import numpy as np

width = 201
base = np.zeros(width, dtype=np.uint8)
base[width // 2] = 1

perturbed = base.copy()
perturbed[width // 2 + 1] ^= 1

The two states differ by exactly one bit.

Cellular Automata From First Principles 20: Periodicity and Attractors

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

Cellular Automata From First Principles 20: Periodicity and Attractors

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.

Hash each state

For binary arrays we can store the bytes:

def state_key(state):
    return state.tobytes()

Then track when each state first appeared:

Cellular Automata From First Principles 19: Entropy and Information

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

Cellular Automata From First Principles 19: Entropy and Information

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.

Binary entropy

If a binary state contains a fraction p of ones, then:

H = -p log2(p) - (1-p) log2(1-p)

In Python:

import math
import numpy as np


def binary_entropy(state):
    p = float(np.mean(state))

    if p in (0.0, 1.0):
        return 0.0

    return -(p * math.log2(p) + (1 - p) * math.log2(1 - p))

The maximum is 1 bit when zeros and ones occur equally often.

Cellular Automata From First Principles 18: Activity, Density and Change

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

Cellular Automata From First Principles 18: Activity, Density and Change

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

This chapter turns those ideas into explicit measurements.

Together they form our first useful behavioral fingerprint.

Cellular Automata From First Principles 17: Measure a Cellular Automaton

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

Cellular Automata From First Principles 17: Measure a Cellular Automaton

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

That is useful.

It is also limiting.

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.

If we want to compare rules, search for interesting behavior or eventually optimize a rule for some objective, we need to turn behavior into data.

Cellular Automata From First Principles 13: Build a Predator-Prey Ecosystem

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

Cellular Automata From First Principles 13: Build a Predator-Prey Ecosystem

A forest fire mostly transforms cells in place.

Rule 184 moves occupancy 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.

Cellular Automata From First Principles 12: Reaction-Diffusion and Pattern Formation

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

Cellular Automata From First Principles 12: Reaction-Diffusion and Pattern Formation

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.

Each lattice cell stores two values:

U = concentration of chemical U
V = concentration of chemical V

So our cell state is now a vector:

Cellular Automata From First Principles 11: Diffusion as Local Exchange

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

Cellular Automata From First Principles 11: Diffusion as Local Exchange

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.

Start with a pulse

import numpy as np

size = 121

grid = np.zeros(
    (size, size),
    dtype=np.float64,
)

grid[
    size // 2,
    size // 2,
] = 1.0

At the beginning one cell contains all the concentration.

Cellular Automata From First Principles 10: Simulate Traffic with Rule 184

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

Cellular Automata From First Principles 10: Simulate Traffic with Rule 184

Rule 184 is a beautiful example of moving 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.

Write the traffic mechanism directly

import numpy as np


def traffic_step(road):
    cars = road == 1

    empty_ahead = (
        np.roll(road, -1) == 0
    )

    moving = cars & empty_ahead

    next_road = road.copy()

    next_road[moving] = 0
    next_road[
        np.roll(moving, 1)
    ] = 1

    return next_road

The road is periodic, so the final road cell connects back to the first.

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

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

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

A forest fire is almost an ideal cellular-automaton exercise.

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:

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

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

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

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.

Cellular Automata From First Principles 07: Beyond Conway — Life-like and Multi-State Rules

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

Cellular Automata From First Principles 07: Beyond Conway — Life-like and Multi-State Rules

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.

You immediately get a family of Life-like cellular automata.

Cellular Automata From First Principles 06: Patterns as Data — Oscillators, Spaceships and Gliders

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

Cellular Automata From First Principles 06: Patterns as Data — Oscillators, Spaceships and Gliders

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 glider is not interesting because it has a familiar shape.

Cellular Automata From First Principles 05: Conway's Game of Life

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

Cellular Automata From First Principles 05: Conway’s Game of Life

Conway’s Game of Life is one of the cleanest examples of complex two-dimensional behavior emerging from a tiny local rule.

The world is a grid of dead and live cells.

Each cell sees its eight surrounding neighbors.

Then four ideas decide the next generation:

underpopulation
survival
overpopulation
birth

The standard rule is usually written B3/S23:

a dead cell is born with exactly 3 live neighbors,
a live cell survives with 2 or 3 live neighbors.

Everything else becomes or remains dead.

Cellular Automata From First Principles 04: Rule 110 and Computation in a Grid

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

Cellular Automata From First Principles 04: Rule 110 and Computation in a Grid

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. Matthew Cook published the universality proof in Complex Systems in 2004, showing that this elementary one-dimensional automaton can emulate universal computation.

Cellular Automata From First Principles 03: Rule 30 and the Surprise of Complexity

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

Cellular Automata From First Principles 03: Rule 30 and the Surprise of Complexity

Rule 30 is a perfect demonstration of why cellular automata are worth studying.

Its transition table contains eight bits:

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.

The result rapidly stops looking like something generated by a tiny deterministic program.

Cellular Automata From First Principles 02: Encode All 256 Elementary Rules

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

Cellular Automata From First Principles 02: Encode All 256 Elementary Rules

An elementary cellular automaton has only three inputs per cell:

left centre right

Each input is one bit.

That means there are only eight possible neighborhoods:

111 110 101 100 011 010 001 000

For each neighborhood the rule chooses either 0 or 1.

Eight binary choices means:

2^8 = 256

possible rules.

The elegant part is that we can store one complete rule table in one byte.

Cellular Automata From First Principles 01: Build Your First Automaton

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

Cellular Automata From First Principles 01: Build Your First Automaton

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 centre cell:

import numpy as np

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

print(state)

Conceptually:

Cellular Automata From First Principles 00: How Can Tiny Rules Build Complex Worlds?

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

Cellular Automata From First Principles 00: How Can Tiny Rules Build Complex Worlds?

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.