A complex result needs no complex cause
2026-07-22 · What Counts as "Complex"
You see a pattern so intricate it seems impossible, and your instinct says: whatever made this must be intricate too. That instinct is the first thing this field takes apart.
A snowflake. A three-metre termite "cathedral." A production outage the whole team stays up all night failing to explain. When we meet something intricate, we assume an equally intricate cause behind it: a complex design, a clever adversary, a hidden conspiracy.
But there is a whole class of things whose rules are simple enough to fit on a napkin, and whose output is intricate enough that you could stare at it forever and never finish counting. And the sharper part comes next: between those few lines of rule and the final pattern there is no shortcut — the only way to know what it looks like is to run it, one step at a time.
This is the fourth issue of Phase A. The first three asked what "complex" even means; this one lands the sharpest cut: complexity isn't in the cause, it's in the cause iterated. The protagonist is a device dumb almost past belief — the cellular automaton. It also opens a second kind of unpredictability: not sensitivity to initial conditions (chaos, Topic 8), but the absence in principle of any shortcut (Topic 11 takes this head-on).
Picture a row of cells, each in one of two states: black or white (call them 1 and 0). Time ticks one step at a time, and a cell's next state depends only on itself and its two immediate neighbours right now — nothing further, nothing elsewhere.
Three cells, two colours each: eight possible "neighbourhoods." A rule is just an assignment of an output colour to each of those eight. So the total number of rules you can write is 28 = 256, no more and no fewer. This kind of device — cells updating together by a local rule — is a cellular automaton (CA); the simplest one-dimensional version is an elementary CA, and there are exactly 256 of them in the whole world.
Start from a single black cell at the top and stack each moment's row downward, and you get a "spacetime diagram": space across, time down. Two rules:
Rule 90: new cell = left neighbour XOR right neighbour (differ → black, same → white, and the centre cell is ignored). The output is a Sierpiński triangle — a fractal, every small piece a shrunken copy of the whole. Rule 30: also looking only at three cells, but growing a pattern with no discernible order at all. How disorderly? Wolfram's Mathematica once literally used one column of its output as a random-number generator.
Here is the first thing that matters: the intricacy of the pattern carries no information about the intricacy of the rule. The Sierpiński triangle looks carefully designed, yet it is just "left XOR right" iterated; Rule 30's mess looks like it must have a complex random source behind it, yet that is an equally short sentence. The complexity your eye perceives and the complexity of the rule that generates it are two quantities that can be entirely unrelated.
Seeing an intricate or chaotic result, don't rush to infer an equally intricate or chaotic cause (a clever adversary, an elaborate plot). Ask the dumb question first: is there a simple, purely local rule that, iterated a few steps, would grow into this? That rule is usually far shorter than the story you'd invent for an "intricate result" — and far likelier to be true.
Run the 256 rules one by one and you find they aren't 256 different kinds of mess — they sort into four large classes. This classification is Stephen Wolfram's; it's called the Wolfram classes.
Class I: from any starting row, everything quickly collapses into a dead uniform state — all white, or all black. Class II: it settles onto fixed, or locally periodic, structures — a row of vertical bars, a little block blinking in place. Ordered, but that's all; nothing new ever appears again. Class III: a perpetually churning noise, no stable structure surviving, like TV static — Rule 30 lives here. Class IV: the rarest, and the most interesting. Neither frozen nor pure noise, it grows localized structures that hold their shape, move, and collide, drifting across a background. Rule 110 is one. Chris Langton named this thin seam the edge of chaos — wedged between rigid order (I, II) and pure disorder (III).
This picture rewards a second look. Frozen (Class II) and chaotic (Class III) are the two extremes, both common and both barren — one where nothing happens anymore, one where nothing can be held onto. What can actually carry "complex behaviour" (storing information, moving it elsewhere, letting two pieces collide and combine) is only that thin seam in the middle that takes careful balance to hold. This is why "complex" is so rare: it is not the opposite of order, nor a synonym for chaos, but a narrow strip pinned between them.
Take the cellular automaton up to two dimensions and you get Conway's Game of Life (John Conway, 1970) → ref · Cellular Automata & the Game of Life. The rules are even fewer — just four.
A living cell with exactly 2 or 3 living neighbours (of its eight) stays alive; otherwise it dies (too crowded or too alone). A dead cell with exactly 3 living neighbours comes to life. From those four rules grows an entire zoo: still blocks, a "traffic light" blinking in place, and the famous glider — a five-cell shape that returns to its original form every four steps, shifted one cell diagonally. It looks like it's "moving," yet nothing at all moves; only cells switching on and off by the same rule.
The astonishing part follows: the Game of Life has been proven Turing complete. Using gliders as signals and "glider guns" as sources, people have actually built AND, OR and NOT gates inside it, and from there a full universal computer. Anything a computer can compute can, in principle, be computed by these four rules. The same holds in one dimension: that messy neighbour from before, Rule 110, was proven Turing complete by Matthew Cook in 2004. A rule that looks at just three cells has computing power equal to your phone (only far slower).
This has a name: universality is cheap. Building a machine that can compute anything needs no complex hardware — one minimal local rule suffices. So "it's too simple to be doing anything complex" is an invalid inference — simple and "incapable" are entirely different things.
When you're about to use "this thing is too simple / too small / too trivial to cause something that complex" to rule out a suspect (a few-line script, a harmless-looking config change, a small incentive clause), stop. Simple local rules are exactly the kind of thing that grows arbitrarily complex behaviour. Delete "it's simple" from your list of reasons to exclude it, and replace it with: actually run it and watch what it unfolds into.
mov instruction, even PowerPoint's animation system. The regularity: any system that can express "conditional branching + a growable store" hides a universal computer. The conclusion: whether a system "can compute" is almost independent of how complex it looks — that threshold is low enough to trip over. What's scarce was never computing power, but the trouble of organizing it into the particular computation you want.
Now back to that opening claim — "no shortcut" — stated precisely. It doesn't hold for every rule; whether it holds is exactly what divides the predictable from the unpredictable.
For a rule like 90 there is a shortcut: whether cell k in row N is black or white equals the parity of the binomial coefficient C(N,k) — a formula, plug in and you know, no need to run row by row. But for rules like 110 or 30 (Class III, IV)? Wolfram gave it a name: computational irreducibility. It means: to know what the system looks like at step N, there is no method faster than honestly computing all N steps. No skip-ahead formula exists. This isn't "we haven't found it yet"; for a Turing-complete system it is impossible in principle — otherwise you could foresee a program's output without running it, and that class of problem (the halting problem) is already proven unsolvable.
This is a different unpredictability from chaos (Topic 8). Chaos is "a hair's difference in the start, a large difference in the result" — fundamentally a precision problem, solvable in theory with a precise-enough start. Irreducibility is starker: even with a perfect, entirely deterministic, noiseless start, you can only run it at full speed, saving not a single second. Determinism has never meant predictability — here the reason isn't sensitivity, it's the plain absence of a shortcut.
Facing a system with perfectly clear, fully deterministic rules but baffling overall behaviour (a swarm of interacting automated strategies, a multi-party pricing environment), stop spending effort on the formula or intuition that "computes the outcome in one jump" — for this kind of system it may simply not exist. Move the budget from "deriving the outcome" to "running it cheaply": simulate, sandbox, release in small staged rollouts, and let the system show you its next frame rather than guessing it on paper.
Now the other side, the boundary. "Simple rules grow unbounded complexity, compute universally, and admit no shortcut" — this story is seductive, and precisely because it's seductive it's easy to overreach with. Before using it, know its edges.
First, cellular automata are discrete, deterministic toys. Cells are black or white, time jumps a step at a time, the rule is fixed iron, no noise anywhere. The real world is continuous, noisy, and its rules themselves change (Topic 26's adaptive systems are exactly about this). "All of reality is one big CA" is a suggestive conjecture (Wolfram bets heavily on it), not an established fact — treat it as fact and you've slid from science into metaphysics.
Second, "the edge of chaos is the best place for complexity / life / computation" is much softer than it sounds. It comes from Langton's λ-parameter experiments, but in 1993 Melanie Mitchell, James Crutchfield and Peter Hraber re-examined it with genetic algorithms and found that the claimed result — "evolution pushes systems to the edge to compute" — was substantially an artifact of the experimental setup, not a robust regularity. "The edge" is a fine metaphor; as a measurable, predictive law it doesn't yet stand. Don't wield it as a shield to say "we should stay at the edge of chaos."
Third, Turing complete ≠ doing useful computation. Saying the Game of Life "can" compute anything, and saying some particular Life configuration "is" computing something useful, are two different things. The vast majority of Class IV configurations compute nothing meaningful — just gliders colliding. "It's Turing complete" is often used to gild a system, as if that made it profound — but universality is a potential, not an achievement.
Fourth, pulling the decision back: "a complex result needs no complex cause" says needs not — not that there is no cause, and certainly not "so the rule can't be blamed." That local rule really exists, can be identified, can be changed. The cone snail's shell has a definite developmental mechanism; Rule 30 has a definite definition. Reading "the cause need not be intricate" as "there is no cause to trace" is, once again, swapping a claim about structure for a claim about responsibility — exactly the trap from the last issue on self-organized criticality.
Before concluding "a single simple rule explains it," state honestly how your system differs from a CA: is there noise? does the rule itself change? did you actually find the rule, or only a metaphor that "looks like" it? If even one of those three questions has no answer, don't port the CA's conclusions straight over — and above all don't use them to let anyone off the hook.
Advocates say yes, and that it's the sweet spot for innovation. But be careful: as §5 notes, this is more metaphor than measurable claim right now — you'd first have to say what the organization's "slope" even is and how you'd measure it. An "edge" with no units is just a nice-sounding word. To make it real, find an observable proxy first (the reversible fraction of decisions, the speed information flows between layers), then talk about "tuning toward the edge."
Because universality is a potential; speed and density are another matter. Rule 110 can compute anything, but so slowly it's useless — encoding one addition into glider collisions takes astronomically many steps. Real chips are valuable for "how much useful computation they organize per watt, per square millimetre, per second," not for "whether they can compute." Which is exactly §5's third point: Turing completeness is a ticket, not a ranking.
Yes. Irreducibility denies point prediction (computing the next exact state), not learning distributions, mechanisms, or boundaries. You can't predict the next crisis's exact timing and size, but you can still recognize structures like "slow accumulation + threshold release" and still change a system's coupling. The reducible part remains learnable — just stop expecting a skip-ahead "formula of history."
Generally — we can't. "Can it be generated by some shorter rule" is itself tied to Kolmogorov complexity, which is uncomputable (Topic 41). All you can do is "try to search for a short rule": find one, and a simple cause suffices; fail, and you've proven neither that it's complex nor that it's simple. Humility is the only honest posture here.