Neither pure order nor pure randomness is complex
2026-08-28 · Method & Limits
Nearly every measure of "complexity" you can think of on the spot awards its top score to a page of gibberish. A page of gibberish is not complex — it is boring. The field spent thirty years patching that hole, and the patch turns out to be more useful than the problem.
"This is way too complex" is one of the most common verdicts in any office, and it gets applied to two opposite things: a forty-page approval process with every step nailed down and nested three deep; and a project with no process at all, where anyone can reach in at any moment. The first has too many rules. The second has too few. Describing both with the same word, and then treating both with the same "let's simplify", is where a lot of failures start.
This issue asks whether complexity can actually be reduced to a number. That sounds academic, but it settles something practical: when somebody says "reduce complexity", do you have any way to ask them which complexity they mean?
Here is the counterintuitive part. Almost every measure you would reach for first — information content, unpredictability, description length — puts randomness at the top. Random is a perfect score on these rulers. And randomness is plainly not what we mean by complex. This issue covers four rulers: the first two crash on exactly this point, and the last two were built to fix it.
Earlier issues have leaned on the word "complex" many times: Topic 1 separated complex from complicated, Topic 2 covered emergence, Topic 26 covered complex adaptive systems. This issue adds no new mechanism. It does one thing: split the word into several distinct, separately computable quantities, and point out where they contradict each other.
Start with the requirement. Any ruler worth having must score low at both ends.
One end is perfect order: a page of nothing but the letter A, a salt crystal where sodium and chloride alternate forever, a tune made of one repeated note. Look at a small piece and you know the whole thing. Nothing is left to explain.
The other end is perfect randomness: a thousand recorded coin flips, the static on a dead television channel. Here a small piece tells you nothing about any other piece — but again nothing is left to explain, because the four words "it is all random" have already said everything there is.
What we actually want the word for sits in between: a cell, a language, a city, a novel. Not copying themselves, not lawless. You can infer some of the rest from a part, and never all of it.
The first ruler comes from telecoms. In 1948 Claude Shannon at Bell Labs was after something very concrete: how much can a telegraph line carry per second.
His answer is called Shannon entropy, measured in bits. The definition fits in one plain sentence: on average, how many yes/no questions must you ask to pin down the next symbol.
If the next letter is always A, you ask nothing; entropy is 0. If it is one of 26 letters, each equally likely, you need about 4.7 questions (2 to the 4.7 is roughly 26); entropy is 4.70 bits. Real English sits in between: by single-letter frequency it comes to about 4.1 bits, because e is far more common than z and you can ask a little less.
The problem is right there in the picture. Entropy ranks them gibberish > prose > repetition. For a telegraph line that is exactly right: gibberish really does eat the most bandwidth. For the complexity we are after it is badly wrong — it hands the top score to the most boring thing there is, and puts a novel almost on top of noise.
There is a second point that gets missed more often: entropy is not a property an object carries. It is computed relative to an assumed distribution. Strictly, "the entropy of this string" is not a well-formed question; "the entropy per symbol, given that it came from such-and-such a source" is. Change the assumed source and the number changes. English came out at 4.1 bits above because only single-letter frequencies were counted; when Shannon's 1951 paper had people guess the next letter with the preceding context available, English fell to roughly 1 bit per letter. Same text, a fourfold difference, because it is not the same question.
Next time you see "the entropy of this system is X", or any diversity index at all, ask two things: what is the alphabet (what counts as one symbol) and how is it coarse-grained (how fine a difference counts as a different state). Two numbers computed with different answers to those are not comparable — this is the number-one reason cross-team complexity metrics never converge. The action: report those two on the same line as the number. If you cannot state them, the number does not enter the decision.
The second ruler tries to dodge the "you must assume a source first" problem by asking about the object directly.
In the 1960s Ray Solomonoff, Andrey Kolmogorov and Gregory Chaitin independently landed on the same idea: the complexity of a thing is the length of the shortest program that outputs it. This is Kolmogorov complexity.
The advantage is that probability drops out entirely. You need not assume anyone is generating this string. You only ask: to rebuild it exactly, what is the least you have to write?
This ruler genuinely fixes something: it separates looks random from is random. Stare at the decimals of pi and you will find no pattern, but the shortest program is a few lines. Anything computable has low Kolmogorov complexity.
Then it crashes in the same place: a truly random string has no description shorter than copying it out, so it scores highest. Coin flips are once again the most complex thing in the world.
It also brings a new problem. Kolmogorov complexity is uncomputable. Not merely hard — it is proven that no general program can return the shortest description length for arbitrary input. You only ever get an upper bound ("I have already squeezed it down to this"), never confirmation that it is the shortest. Chaitin pushed this further: there is a constant such that no formal system can prove of any specific object that its Kolmogorov complexity exceeds it. In plain terms — "this thing really is complex" is, in almost all cases, unprovable.
When somebody says "this thing is too complex", separate there genuinely is no shorter description from they have not found the pattern yet. There is a test so cheap it feels like cheating: compress it. Logs, config files, reports, code — anything gzip takes down to 5% is repetitive, not complex, and the fix is deduplication, not more headcount. The test only runs in one direction: if it compresses, it is simple; if it does not, you have merely failed to prove it simple.
Two rulers crashing at the same point suggests the fault is in the question, not the rulers. Murray Gell-Mann and Seth Lloyd changed the question in 1996.
A full description of an object, they said, splits into two parts: the regularities — the structure it shares with the class of things it belongs to — and the random part, the particular accidental values filled in within that structure. Effective complexity counts only the first.
Take the coin-flip record. Describing it fully takes a thousand bits, but the regular part is one sentence: "a thousand independent fair flips." That sentence is short, so a random string has effective complexity near zero. The salt crystal's regular part is short too — "sodium and chloride alternating, forever." Both ends collapse at once. Only objects whose structure itself takes a long statement to specify can score high.
This is real progress. But it introduces something new, and that something is the most important sentence in this issue: the line between "regular" and "random" is not in the object. It is in the hand holding the knife.
The same genome: to someone classifying species, individual variation is noise; to someone studying population genetics, that variation is the entire signal. The same sales data: seasonality is a regularity to one department and a nuisance to be stripped out by another. Gell-Mann and Lloyd said so themselves — effective complexity only has a value once you specify who is looking and at what coarse-graining. The philosopher of science James McAllister pushed the criticism to its conclusion in 2003: since any dataset can be carved into different sets of regularities by different observers, effective complexity is not an objective property of the object.
How much that matters depends on what you want from it. If you want a constant to carve in stone, it is fatal. If you want a working ruler, it has merely turned an implicit choice into a parameter you are forced to declare — which is usually an improvement.
There is another route entirely. In 1988 Charles Bennett asked not how long the description is, but how many steps it takes to run that shortest description out into the object.
The quantity is logical depth. It separates describing from generating, and that separation immediately explains something none of the earlier rulers could.
The coin-flip record has a long program (copy it out) but runs in one step: print. It is shallow. The salt crystal has a short program and almost no computation. Shallow too. But the thousand decimals of pi beginning at the billionth place have a short program and require you to actually grind through a billion digits — that is deep. A genome is the same: the rules describing it are not enormous, but the thing itself was run out over billions of years of trial and error, with no shortcut past it.
The useful part of this ruler is that it gives a reason why something is worth anything. A deep object — a process that has run for ten years, a species, a customer list built up over time — can have a short description while the thing itself cannot be cheaply recreated, because a run of computation is frozen inside it. This has nothing to do with how big it is or how many clauses it has.
To value something that already exists — inherited code, a ten-year-old process, a customer list — do not ask how big it is. Ask how many rounds of real feedback it would take to rebuild from zero. The workable proxy: how many of these rules were beaten into place by a specific incident? Can't name many → it is shallow, and rewriting costs what the code costs. Can name dozens, each matched to an incident → it is deep, and rewriting costs the time to walk into all those holes again, typically an order of magnitude more.
Now the other side, and this section matters more than the five before it.
First, the four rulers contradict each other on the same object. They are not four ways of measuring one thing. They are four different quantities that happen to share the word "complexity".
Second, essentially none of these can be computed. Kolmogorov complexity is uncomputable, as covered. Effective complexity depends on a coarse-graining you have to supply yourself. Logical depth cannot get past the same uncomputable "shortest program" as its starting point. What actually gets used in practice is always a proxy — compression ratio, parameter count, residual error — and the relationship between the proxy and the original quantity has usually never been checked by anyone.
Third, the inverted-U is assumed, not demonstrated. Seth Lloyd once compiled a list of some forty different definitions of complexity, each built for a different question in a different field. Expecting all of them to lie on a single order-to-randomness axis and peak at the same place has no basis.
Cellular automata provide a clear cautionary case → ref · Game of Life & cellular automata: around 1990 Chris Langton proposed a parameter λ to locate a rule on an order-to-chaos axis, and Norman Packard's experiments appeared to show that evolution drives rules toward the "edge of chaos". In 1993 Melanie Mitchell, Peter Hraber and James Crutchfield redid the experiment and found the original result came mostly from the experimental setup and the mechanics of the genetic algorithm, not from any property of the edge itself. This does not say the edge is not there; it says that particular evidence does not hold — and "edge of chaos" remains one of the most loosely cited phrases in the field.
Fourth, and most important: none of these four rulers predicts anything. They are descriptive quantities, not dynamics. Knowing a system has high effective complexity tells you nothing about whether it will collapse, when, or in which direction. Every mechanism in the previous forty issues — feedback, criticality, power laws, resilience — yields testable predictions. Not one of these four does. Their value lies elsewhere: they break a vague word into several quantities that each mean something definite, which turns "this is complex" into a claim you can interrogate. That is a gain in vocabulary, not in theory — and mistaking it for the latter is the exact failure complexity science is most often accused of.
Never make "complexity" a single tracked number. Any goal of the form "bring the complexity down" has to say which one: lower entropy (less uncertainty, usually good), lower Kolmogorov complexity (fewer rules, usually good), lower effective complexity (cutting out real structure, usually bad), lower logical depth (throwing away accumulated experience, almost always bad). That single "complexity" column in the reporting template should be split into those four or deleted — its only reliable effect right now is to make four different opinions look like a discussion of one thing.
An uncomfortable possibility: because we and everything we care about live in the middle, we have encoded "interesting" as "complex". That need not be wrong — rulers are built for uses — but it means the curve has the standing of an engineering spec, not a law of nature. The difference matters: a spec can be changed to suit the use, a law cannot. Anyone wanting to treat it as the latter owes a criterion independent of what we happen to find interesting.
No, and the shapes differ. Scott Aaronson, Sean Carroll and Lauren Ouellette ran a vivid simulation in 2014: let "coffee" and "cream" mix on a lattice, and entropy rises monotonically to the end while their complexity measure rises and then falls — two pure blocks at the start (simple), uniform grey at the end (also simple), and the tendrilled pattern in between at the peak. At minimum this shows entropy growth and complexity growth are different curves, and it hints that complex structure may be intrinsically a transient.
You can measure proxies, but you must pick a ruler first. For Kolmogorov complexity, count distinct process rules after removing duplicates. For logical depth, count how many of them trace back to a specific incident. For entropy, look at how spread out the handling paths are for one class of request. Those three numbers will point at different fixes — which is the useful part. The trouble with "our organisation is too complex" is precisely that it implies three mutually incompatible remedies at once.
Because it draws boundaries. The uncomputability of Kolmogorov complexity is itself a usable result: it means the simplest solution can never be found mechanically, so any claim of "we have reached the simplest form" exceeds what can be proven; and it means upper-bound estimates like compression ratio are an approximation that cannot in principle be removed, rather than a temporary technical shortfall. Sometimes the value of a quantity is not its number but what it proves cannot be done.