The Recovered
Graph

Twenty-one instruments follow. They cover erosion, combinatory logic, cellular automata, slime mould, index generation, map colouring, a twelve-hundred-year-old river puzzle, Mastermind and chess. Between them they use two spaces and no others.

A lattice is a set of cells with neighbours: terrain, a board, a tape, an address range, a grid of regions. A graph is a set of states with transitions: a drainage tree, a reduction sequence, a tube network, a puzzle's state space, a game tree. Every problem below is posed on one, or on a graph induced over the other. Nothing needed a third.

The instrument below is the smallest case of the claim: one line of arithmetic on a one-dimensional lattice, whose behaviour cannot be read off the rule. Robert May put it in Nature 261 (1976) as a warning to ecologists — simple deterministic models produce dynamics indistinguishable from noise.

You cannot shortcut it. To know what the rule does at a given r you have to iterate it — computational irreducibility stated in 1976, twenty-six years before the phrase existed.

The method of steepest descent is Augustin-Louis Cauchy, Méthode générale pour la résolution des systèmes d'équations simultanées (1847), on a variational tradition running back through Hamilton's principle (1834), Maupertuis's least action (1744) and Fermat's principle of least time (1662). A soap film spanning a wire frame solves the same class of problem with no computation at all — Plateau's laws (1873), made rigorous by Douglas and Radó independently (1930–31).

The algorithm inside a neural network is not new either. Reverse-mode automatic differentiation — now called backpropagation — is Seppo Linnainmaa's 1970 Helsinki master's thesis, described for arbitrary sparsely-connected networks with no reference to neurons. Werbos (1974) connected it to network training; Rumelhart, Hinton & Williams (1986) popularised it. The algorithm is Linnainmaa's. The fame is not.

Release two hundred walkers and count the distinct minima. The field fixes the set of possible outcomes; the starting point fixes which one you get. Nothing in the descent prefers a basin.

This is a theorem, not an impression. Cybenko (1989) and Hornik, Stinchcombe & White (1989) proved a one-hidden-layer network dense in the continuous functions — so the realised function is arbitrary and the architecture is a carrier, not a content. Wolpert & Macready's No Free Lunch theorems (IEEE Trans. Evol. Comput. 1(1), 1997) complete it: averaged over all cost functions every optimiser performs identically. Method choice is never intrinsically justified — only ever justified by matching the domain.

Robert Horton (1945) established quantitative regularities in stream networks — the bifurcation ratio, the law of stream numbers. For twenty years these were read as evidence of process, as if the ratios told you about the geology that produced them.

Ronald Shreve ended that reading. "Statistical law of stream numbers" (Journal of Geology 74(1), 1966) and the infinite topologically random channel network (1967) showed real drainage topology is statistically indistinguishable from topology drawn at random from the population in which all topologically distinct networks of a given magnitude are equally likely. Kirchner (Geology 21, 1993) reinforced it: Horton's laws are near-inevitable and therefore diagnose almost nothing.

Run it repeatedly. The terrain differs every time and R_b lands in the same narrow band. Then generate a network with no terrain at all and it lands in the same band again. The statistic that looked like a signature of erosion is a signature of branching.

Routing uses priority-flood depression filling (Wang & Liu 2006; Barnes, Lehman & Mulla 2014) before D8 — without it a noisy surface drains into thousands of pits and no hierarchy forms at all. The optimality reading arrives at the same place from the other side: Optimal Channel Networks minimise total energy expenditure and, per Rinaldo et al. (1992), evolve from arbitrary initial conditions to configurations statistically indistinguishable from natural ones. Chance and optimality produce the same form.

An elementary cellular automaton has eight neighbourhood cases and one output bit each: 256 rules, one byte apiece. Wolfram conjectured in 1985 that rule 110 is Turing-complete; Matthew Cook proved it (Santa Fe Institute, late 1990s; published Complex Systems 15, 2004). A maximally trivial nearest-neighbour rule is universal.

Cook's proof carries an instructive intellectual-property episode: Wolfram Research obtained a court order excluding the paper from the conference proceedings, claiming breach of a non-disclosure agreement. Corporate ownership contested a mathematical result before it could be published — a rehearsal of block b15.

Rule 90 draws the Sierpiński gasket — deterministic and wholly predictable. Rule 30 is chaotic enough that it shipped as a pseudo-random generator. Rule 110 is universal. They differ by a handful of bits. Whatever separates a trivial system from one capable of arbitrary computation is not complexity of the rule, and it is not visible in the specification. Click any of the eight neighbourhood cases to flip its output bit and watch the class change.

Moses Schönfinkel, "Über die Bausteine der mathematischen Logik" (Mathematische Annalen 92, 1924, from a Göttingen talk of 1920), eliminated bound variables from logic entirely, leaving pure application. Haskell Curry developed the system from 1927 and established the foundations in his 1930 thesis (his primitives were B, C, K, W; the S-K-I naming is later). Church's lambda calculus and Turing's machine model, both 1936, reached effective calculability independently.

Three rewrite rules suffice for all computation: I x → x, K x y → x, S x y z → x z (y z). A combinator has no inside. It cannot hold anything. It can only be applied.

Try S I I (S I I). It reduces to itself forever. Self-calling is not a feature anyone added — it falls out of application alone. The formal account is Kleene's Second Recursion Theorem, proved in the closing lines of §2 of "On Notation for Ordinal Numbers" (Journal of Symbolic Logic 3(4), 1938); its lambda embodiment is the fixed-point combinator. A program that reads and calls itself is McCarthy's eval (CACM 3(4), 1960).

Every self-restarting job, every trigger that fires a trigger, every resolver that resolves a name into a call on itself, is this. It was finished in 1938.

Reduce a statement to its rule by taking every non-syntactic element and converting it to a parameter. What remains is a fixed template with named holes — the smallest complete carrier of its class, and the same object as an automaton rule: minimal, inert, productive only when run.

The instantiation step reads the rule by name and binds the holes from values fetched at run time; the value space is a cursor over the system catalogue. This is table-driven generation — decision tables (1950s–60s), articulated as data-directed programming in Abelson & Sussman's SICP (1985) — on Codd's relational model (1970), which made the catalogue a set of queryable relations, and McCarthy (1960), which made a rule storable as a value.

Switch on shape discovery and the resolver stops using a fixed template: it reads the columns at run time and builds the statement's shape from what it finds. That is the boundary between instantiating a known rule and generating one. Below it, substitution; above it, a program writing a program from metadata and running it immediately.

The target is arbitrary too, and this is the part usually asserted rather than shown. One specification row drives thirteen emissions below — shell, mainframe, database, desktop automation of the era, stylesheet, batch file, configuration, and three modern languages. The header block is identical across all of them because it addresses invocation, not syntax; the archive keywords $Workfile$, $Revision$, $Log$ are holes left for a downstream resolver — SCCS (Rochkind, Bell Labs, 1972), RCS (Tichy, 1982), and the PVCS flavour (1985) — that the emitter does not own.

Nothing in that output was written by hand, including the comment blocks. The artefact is exhaust; the specification row is the asset. Which is why version-controlling the emissions is a category error — you version the rule, and regenerate.

The other half of the estate is resolution by address rather than by search: ask once, hold the result locally, stop crossing the boundary. The lineage here is domestic — Acorn's BBC Micro (1981) to the first ARM (1985), whose small cache made resolve-by-address the defining move.

Physarum polycephalum is an acellular slime mould with no nervous system. Nakagaki, Yamada & Tóth reported it solving a labyrinth by the minimum-length path (Nature 407, 2000, p. 470). A decade later Tero et al. placed oat flakes at the positions of the cities around Tokyo and used light as topographic barrier; the organism produced a network comparable to the rail system in cost, transport efficiency and fault tolerance (Science 327, 2010, pp. 439–442), by local reinforcement of high-flux tubes and decay of the rest.

The model below is theirs: flux reinforces conductivity, disuse decays it, pressures resolve by conservation at every node. There is no optimiser and no objective function anywhere in it.

Overlay the exact minimum spanning tree and compare. The colony does not compute the tree; it converges toward the same region of the solution space by a rule with no representation of length, cost or destination.

The organisational reading is older than the biology: the colony rather than the individual as the unit is Wheeler's superorganism (Journal of Morphology, 1911), on Spencer's social organism (1860). A siphonophore is the sharper instance — genetically identical zooids differentiated to single tasks, none viable alone, assembled for a task rather than evolved as an individual. Callable single-task units, composed, coordinated by information flow with no brain anywhere: Wiener (1948) and Ashby (1956) in an organism that predates both by a few hundred million years.

The four-colour problem begins as a pigment-economy question: Francis Guthrie, 1852, colouring English counties. Kempe published a proof in 1879 that stood eleven years until Heawood found the flaw in 1890 — and Kempe's chains survived as machinery of the eventual proof. Heawood generalised to surfaces of arbitrary genus, a programme completed by Ringel & Youngs (1968): a torus requires seven. Appel & Haken proved the planar case in 1976 by irreducible computer calculation; Gonthier machine-verified it in Coq in 2005.

Two things follow, and the second is usually missed. First, this is a proof you must run rather than survey — the signature shared with Hales's sphere packing (1998) and its Flyspeck verification (2014). Second, the hypotheses require every region to be connected. An exclave breaks the bound. A handle raises it.

Mastermind hides a code of four pegs from six colours: 1296 possibilities, fixed before play begins. Nothing about it is random once set, and nothing about recovering it is search in any interesting sense — each response partitions the remaining candidate set, and the only question is how well you choose the partition.

Donald Knuth settled it in "The Computer as Master Mind" (Journal of Recreational Mathematics 9(1), 1976–77): a minimax strategy — take the guess whose worst-case surviving set is smallest — solves every code in five guesses or fewer, mean 4.478. The implementation here reproduces that; run over all 1296 secrets it gives worst case five and mean 4.476.

This is the shape of every recovery in the estate. The system catalogue, the workflow repository, the copybook, the running process — each holds a determined structure that is not hidden, only unstated, and each yields to elimination against its own responses. Codebreaking did not come from nowhere; neither did reverse engineering. Reverse-engineering a business process is no different from reverse-engineering code, because the process is a deterministic program the organisation executes and its traces are open.

Note what Knuth's result is not: it is not a learned policy. It is a bound, derived once, over a space small enough to enumerate. Where you can enumerate, you do not learn.

A man must ferry a wolf, a goat and a cabbage across a river. The boat holds him and one item. The wolf eats the goat unattended; the goat eats the cabbage. The puzzle appears in Propositiones ad Acuendos Juvenes — "Problems to Sharpen the Young" — attributed to Alcuin of York, c. 800 AD, and it is among the oldest surviving state-space search problems in the Western record.

Sixteen configurations exist; six are fatal; ten are legal. Draw an edge wherever one legal state reaches another in a single crossing and the puzzle disappears: what remains is a graph whose shortest path is seven. Breadth-first search finds it without knowing what a wolf is.

The difficulty was never in the river. It is in the representation: state the problem as four bits and the search becomes trivial, which is the whole content of the puzzle as a teaching device. Alcuin was teaching representation, and the answer is a path, so it belongs to the second space.

Chess breaks every condition the rest of this page relies on. The rules are maximally open — more open than any schema — and yet nothing is recoverable, because the answer is not stored anywhere. There is no ALL_DEPENDENCIES for a position. von Neumann's minimax theorem (1928) defines optimal play in principle; Shannon's conservative game-tree estimate of order 10¹²⁰ ("Programming a Computer for Playing Chess", Philosophical Magazine 41(314), 1950) makes exhaustive solution impossible. Turing and Champernowne's Turochamp (1948–50) was executed by hand, at roughly half an hour per move, because no machine could run it.

The engine below is alpha-beta over a move generator verified against published perft counts — 20, 400 and 8,902 at depths one to three, and 197,281 at depth four, which exercises castling, en passant and promotion. The generator is correct, so the tree it walks is the real one.

This is the method-matching point, and it is why the position throughout is not an argument against learning. Where the generating structure is open and determined — a codebase, a catalogue, a dependency graph — it can be read, and recovery is correct; a statistical learner there pays enormous cost to approximate what a cursor returns exactly. Where there is nothing to recover and the space is unsearchable and adversarial, a learned evaluator is the right instrument, and AlphaZero (2017) demonstrated it.

Applying neural methods to code is the first case dressed as the second. That is the whole of the joke.

Each preceding block demonstrated one form in one setting. The obvious objection is that these are analogies — that a river and a reduction sequence merely resemble one another. The matrix below answers it by enumeration: take the eight forms the instruments have executed, and locate each in cybernetics, game theory, machine learning, computer games, cellular automata, agentic AI, and the working estate.

Click a column to read a domain, a row to read a form. The interesting operation is Count the cells, and the interesting column is the sixth.

The agentic column is fully occupied and contributes nothing. ReAct (Yao et al., 2022) is a feedback loop; a sub-agent is self-application; retrieval is resolve-by-name; a skill library is chunking; debate (Irving, Christiano & Amodei, 2018) is minimax. Each is a competent restatement, each is useful, and none opens a row that Wiener, von Neumann, Cauchy or Kleene had not already filled. That is not a criticism of the work — it is the reason the work succeeds so quickly. Restating a settled form in a new substrate is cheap, and it inherits the guarantees.

The estate column is missing exactly one entry, and the gap is informative: it has no adversary. A catalogue does not fight back, a copybook does not conceal, a dependency graph does not bluff. That single absent cell is the whole of the method-matching argument in one square — where minimax is empty, recovery is available, and learning is the expensive way to reach an answer you could have read.

Game theory earns its own instrument because it is the cleanest case of efficiency inside a competitive space. Robert Axelrod invited strategies for an iterated prisoner's dilemma and ran them round-robin ("Effective Choice in the Prisoner's Dilemma", Journal of Conflict Resolution 24(1), 1980). The winner, submitted by Anatol Rapoport, was Tit for Tat: four lines, no model of the opponent, no memory beyond the last move.

The robust finding was not that one program won. It was that the top of the table was occupied by nice strategies — those that never defect first — and that elaboration bought nothing. The tournament below is the standard payoff matrix (R=3, S=0, T=5, P=1) over 200 rounds, all pairs.

Add misimplementation noise and the ranking reorders: Tit for Tat locks into an echo of its own accidental defection, while forgiving and error-correcting strategies rise — Nowak & Sigmund's win-stay-lose-shift result (Nature, 1993). The lesson is the one No Free Lunch states formally: no strategy is good in itself, only good against a field. Competitive spaces have no intrinsically best method either.

Which leaves the last mechanism, and the one that ties the loops to the chains. A recurring sequence gets named once and is thereafter invoked as a single thing. Miller called it chunking (Psychological Review, 1956); Laird, Rosenbloom & Newell made it the entire learning mechanism of Soar (Machine Learning 1(1), 1986); Fitts & Posner (1967) described the same passage from deliberate to automatic in skill acquisition. Independently, Gage published byte-pair encoding as a compression method (1994), and Sennrich, Haddow & Birch (2016) applied it to subword units — which is the tokeniser under every current language model.

Those are the same algorithm arrived at four times from four directions — psychology, cognitive architecture, data compression, and language modelling — and the estate is the fifth. A task becomes a script; recurring scripts become a chain; the chain is named and becomes one call; the call joins the library and is available to be chunked again. Tasks, then chains of tasks, then the call for them: exactly the reactions people learn until they are automatic, and exactly why they build objects — so as to stop having to think about them.

Reduction to simplicity, then calls to complexity. That is the higher-level learning, and it has no substrate preference: it runs on a lattice of tokens, a graph of tasks, a colony of zooids or a library of stored procedures. Which is the thesis, one last time, arrived at by counting rather than by assertion.

Record-and-replay automation drives an application's object model with deterministic, unattended calls across a trust boundary. That capability was withdrawn within weeks in mid-2000 — not against malware specifically, but against all unattended application-to-application automation, because a synchronisation utility and a worm are indistinguishable to the guard that stops them.

What looks like a retreat from user-interface automation is a lateral move onto surviving ground. The estate that results automates the infrastructure layer — ingestion, build, deployment, regulation — end to end, and is deliberately bounded. Every generated artefact traces to a specification row; nothing is inferred; nothing reaches outside its schema.

The earliest recorded use of "business intelligence" is Devens's Cyclopædia of Commercial and Business Anecdotes (1865), describing a banker profiting by gathering information ahead of competitors. The computational sense is H. P. Luhn, "A Business Intelligence System" (IBM Journal of Research and Development 2(4), 1958) — automatic abstracting and selective dissemination to action points by interest profile. Both senses are about gathering. The older military sense of the word is intelligence gathered on a target.

Frederick Winslow Taylor stated the mechanism in his own words in The Principles of Scientific Management (1911): management assumes the burden of gathering together the traditional knowledge previously possessed by the workmen, and of classifying, tabulating and reducing that knowledge to rules, laws and formulae. He is explicit that this knowledge is the principal asset of every tradesman. Braverman (1974) named the consequence: the separation of conception from execution. Polanyi (1966) named the residue that resists capture; Nonaka & Takeuchi (1995) supplied the programme for capturing it anyway, whose Externalization step converts individual tacit knowledge into organisationally owned assets.

The defaults are the trap, and the escape hatch is the same in both jurisdictions: an agreement in writing, made before the work exists. The only statutory relief in the UK — compensation for a patent of outstanding benefit under s.40 — reached the Supreme Court for the first time in Shanks v Unilever [2019] UKSC 45, thirteen years after the claim began, awarding £2 million as a 5% share of roughly £24 million of benefit. The exception establishes the rule.

Current vendor framing restates the programme at machine scale. Products marketed as enterprise intelligence describe ingesting proprietary internal content and rendering it as actionable intelligence; adjacent services exist to convert internal corpora into model inputs. Training a model on employee mail, documents, tickets and code is the Externalization step of 1995 executed automatically under the ownership rules of 1988 and 1976. The mechanism is Taylor's, with a training run in place of a stopwatch.

The term is an aspersion. There is no novel structure of intelligence for an enterprise to instantiate — the structures are arbitrary, old and public, as blocks b03 through b13 demonstrate by execution, on two spaces and no more. What remains, once the prestige is subtracted, is the gathering.

This is not a priority argument. Several of these results were co-discovered or repeatedly rediscovered — backpropagation especially: Kelley 1960, Linnainmaa 1970, Werbos 1974, Parker 1985, Rumelhart, Hinton & Williams 1986. The claim is not that someone was first. The claim is that the results are settled, old and public, so that modern framing supplies prestige rather than content.

Every preceding block asserted something and then ran it. This one does the same for the page itself. Content arriving from anywhere has to satisfy three questions before it can be trusted, and each has a working answer that needs no server: does it have the declared shape, which audience is reading it, and can the order be checked rather than believed.

Take presentation first, because it is the one usually solved by duplication. A paragraph is read by a general reader, a technical reader and an executive; the common response is to write three documents and watch them drift. The alternative is to hold the content once and attach stylesheets, each of which becomes a reader. Selecting a reader selects a view. The source does not move.

That is the transforms organelle, and the discipline it enforces is worth naming: content lives once, audiences vary, and no register is the canonical one. The academic prose is authored inline in this page; lay and executive are held in a separate source and rendered on demand by the browser's own XSLT processor.

Structure is the second question, and the useful part is what happens on failure. A declarative schema states required attributes, forbidden attributes, child counts and an allow-list. In strict mode anything failing is quarantined rather than dropped — it stays in the tree, visibly marked, and is excluded from clean output. Silent discarding is the failure mode to avoid; a region that vanished cannot be argued about.

Inject a violation and one section loses its required @space and gains a forbidden @legacy-id. Under strict mode it quarantines; turn strict off and it is admitted with a warning instead. The rules are the ones shipped in schema-recovered-graph.xml, so the file is now load-bearing rather than decorative.

Order is the third question, and it is the one a flat list of hashes cannot answer. Seventeen independent digests are a set: they prove each block's contents but say nothing about sequence, and a block could be moved or removed without any of them changing. Chaining fixes that — each block's hash is computed over the previous block's hash together with its own content, so position becomes part of what is signed.

Alter four characters in block seven and every hash from there to the end changes. Nothing detects the edit by inspection; the break is arithmetic. That is the difference between claiming a sequence and computing one, and it is the same control an evidential record requires — implemented in about two hundred lines, running in the browser, portable to any static host.

The sidecars carry all of this in portable form: app-spine.xml, canvas-package.xml, block-ledger.json, content-recovered-graph.xml in <doc>/<section>/<paragraph> form, registers.xml holding the alternate registers, schema-recovered-graph.xml declaring the rules enforced above, and feature-instruments.xml declaring the readers. The page needs none of them to run, which is the point of the format — the surface is readable standalone and the capsule is recoverable from it.