A head, a tape, and a table of rules — the whole definition of computation. Turing's 1936 a-machine is not a metaphor: it is runnable. Down the center, data flows — a binary number goes in on the tape, the head scans and rewrites cell by cell, and the successor comes out, halting in an exact step count. The blue team builds and defends it; the red team tries to break the one thing that makes it a machine: determinism.
source A. M. Turing, On Computable Numbers, with an Application to the Entscheidungsproblem (1936), Proc. London Math. Soc. ser. 2, vol. 42, pp. 230–265 — turingarchive.kings.cam.ac.uk · AMT/B/12 AMBER (page images, no single canonical open PDF). Rendered, not quoted.
A machine is its transition table. δ maps (state, read symbol) to (write, move, next state). The engine below runs this exact table — a binary-increment machine over the tape alphabet {0,1,_}. States: R scan right to the end, C carry the +1 leftward, H halt.
| state | read | write | move | next |
|---|---|---|---|---|
| R | 0 | 0 | R | R |
| R | 1 | 1 | R | R |
| R | _ | _ | L | C |
| C | 0 | 1 | L | H |
| C | 1 | 0 | L | C |
| C | _ | 1 | R | H |
Deterministic means exactly one row per (state, read) — six rows, six distinct keys. That is what makes δ a function. The row the engine is using lights up as it steps.
This is the substrate. A finite controller plus an unbounded tape is Turing-complete: by the Church–Turing thesis, anything computable at all is computable here. Every complexity class (P, NP, PSPACE…) is defined as "what a Turing machine does within a resource bound."
And its own shadow: ask whether an arbitrary machine + input ever reaches H, and you get the halting problem — undecidable, by a finite diagonal contradiction Turing drew in the same 1936 paper. This sphere is that sphere's premise.
The blue team's live check: rebuild the table, confirm δ is a function (one rule per key), re-run the increment on 0111, and re-run the busy-beaver. If red tampers, this badge is where it flips.
Formally a machine is a 7-tuple (Q, Γ, b, Σ, δ, q₀, F): states, tape alphabet, blank, input alphabet, transition, start, halts. But the input is small: a finite string written on an otherwise-blank, unbounded tape, plus where the head starts and in which state.
Here the input is a binary number, most-significant bit first, head on the left bit, state R. Blank cells read as ·. A configuration — (state, tape, head position) — is the machine's entire momentary reality; feed it to the panel below.
δ is applied write → move → transition, one cell per step. Nothing is looked up — the successor is scanned out of the tape.
What the machine produces, checked: the exact successor of each binary input, in an exact step count — and a second, constructed machine that halts on a KNOWN step with a KNOWN tape.
The blue witness (left) confirms these live; the red team (right) tries to make them wrong.
The model is also silent on cost. It says what is computable, not how fast — 9 steps to increment four bits scales, but the machine says nothing about efficiency. Complexity theory is a separate storey built on this floor.
"A Turing machine is how a computer works." Cut. Real computers are register/RAM machines; the TM is a model of computability, equivalent in power (Church–Turing) but not in architecture. Equivalence ≠ identity.
"Turing built this machine." Cut. The a-machine is a mathematical object in a 1936 paper. Turing later built real hardware (the Bombe; the ACE design) — not this.
"The tape is infinite." Kept, corrected. It is unbounded, not infinite: extendable without limit, but only finitely many cells are ever non-blank. The engine's tape is literally a sparse map.
The red team's move: add a second rule for the pair (R, 1). Now two rows share one key — δ is no longer a function, and the machine is no longer deterministic. The blue witness (window 7) is watching.