Purple Paper · the axiom of computation · lineage + audit
The Lineage of the One Instruction — subleq, traced to its root
We went down all night until there was nothing left to remove, and hit the floor: a computer needs
exactly one instruction. This is where that one came from — not a single inventor, but a line, from a 1936
proof to a 1956 machine to the form the field settled on. Tracked to its root, then audited like anything else.
SUBLEQ a, b, c — SUbtract and Branch if Less than or EQual to zero Mem[b] = Mem[b] − Mem[a]; if (Mem[b] ≤ 0) goto c
one verb that is both the arithmetic (subtract) and the decision (branch). The irreducible atom.
the proof / the root the formalization the builds living refinements
1936Alan Turing
A tiny fixed rule-set can compute anything the proof
Best idea: the Turing machine — prove that an absurdly small set of operations (read, write,
move, change state) is enough to compute everything computable. "Minimal is sufficient" is born here.
The grandparent. Establishes that you can go small without losing power — the licence for the whole descent. Leaves open: how small, concretely, in real hardware?
~1945John von Neumann
Instructions and data share one memory the architecture
Best idea: the stored-program design — code lives in the same addressable memory as data.
This is what lets a single instruction treat numbers as addresses and rewrite its own targets, which subleq needs.
Without this, a one-instruction machine can't self-modify or address freely. The substrate every OISC runs on.
1956W. L. van der Poel
SBN — subtract and branch if negative the root instruction
Best idea (the actual root): the first subtract-and-branch single instruction —
attributed to van der Poel, 1956. This is the seed: arithmetic fused with a conditional jump into one operation.
subleq is this idea's direct descendant.
The genuine origin point of "one arithmetic-plus-branch instruction is enough." Everything after is refinement of this. Not Turing, not von Neumann — this is where the one-instruction machine actually starts.
1960s–70sURISC / teaching machines (Mavaddat & Parhami and others)
"Ultimate RISC" — one instruction, as a teaching tool named & formalized
Best idea: recognize the single-instruction machine as the ultimate reduced
instruction set — reduced all the way to one — and use it to teach how computers fundamentally work, because
nothing is hidden.
Turns a curiosity into a pedagogy: the cleanest possible window into "what is a CPU, really." The OISC/URISC framing dates here.
2000sOleg Mazonka · Lawrence Woodman · others
Real toolchains: Higher Subleq, VMs, a C-to-subleq compiler made real
Best idea: stop admiring it and build — a compiler (Higher Subleq) that turns
simplified C into subleq, virtual machines, even self-hosting Forth on top of a subleq VM. Proof by construction that
one instruction runs real programs.
The witness firing: not "it could in theory," but "here is a working compiler and VM." subleq named the oldest, most popular, arguably most efficient of the arithmetic OISCs.
A full OS, and a CPU in silicon/cellular-automata, on one instruction the extreme, realized
Best idea: push it to the limit — DawnOS, an entire operating system on a subleq chip;
Izhora, a 32-bit subleq computer built as a giant cellular-automaton pattern; subleq CPUs on FPGAs.
The axiom, fully exercised: an OS with no if, no while, no goto — all of it synthesized from one subtract-and-branch. The floor holds real weight.
The Audit — applying the witness to the lineage itself
Claim 1: "subleq is the one true minimal instruction." PARTLY — REFRAME subleq is a minimal instruction, the most popular one,
but not uniquely "the" one. The sources are explicit: there's a whole family — Addleq (add), DJN
(decrement-and-jump), P1eq (increment), RSSB, plus non-arithmetic OISCs (bit-manipulation,
transport-triggered). subleq is "the oldest, most popular, arguably most efficient" — which is a real claim, but
"arguably" and "most popular" are not "the unique minimum." Best ≠ only. The honest statement: subleq is the
canonical minimal instruction, not the sole one.
Claim 2: "It was written by one person (Linus / a single inventor)." FALSE — no single author Not Linus (Linux + Git, unrelated). And not any one
person: it's a lineage — Turing's proof (1936), von Neumann's architecture, the actual subtract-and-branch
root in van der Poel (1956), the URISC teaching framing, then the modern builders (Mazonka's compiler, etc.).
"Who wrote subleq" has no clean answer because it's a refined folk-result, not an authored artifact. Demanding a single
name would have been the costume move — so the paper shows the line instead of crowning one.
Claim 3: "One instruction is genuinely enough — this isn't hype." PASS — checkable, and checked This one survives the dig-test hard. It's not
"it could in theory" — there's a working C compiler (Higher Subleq), virtual machines, FPGA silicon
implementations, and a complete operating system (DawnOS) running on one instruction. Turn it on and it computes. The
claim bites reality and reality confirms: the minimum is 1, demonstrably.
Verdict: the lineage is real and traceable to van der Poel, 1956 (with Turing/von Neumann as the
foundation beneath). The "one true / single author" framings don't survive — there's a family, not a winner, and a
line, not an author. But the core marvel — one subtract-and-branch is a universal computer — is the rare claim
that's both beautiful and built. It passes because you can power it on.
History, gated against current sources. Hard attribution: SBN → van der
Poel, 1956; subleq as "oldest / most popular / arguably most efficient" arithmetic OISC; working compiler (Higher
Subleq, Mazonka), VMs, DawnOS, Izhora all real and cited. Where the record is a folk-lineage rather than a single
author, the paper says so rather than inventing one — that refusal-to-fabricate is the audit doing its job.