Principia · companion · polygraphic computation
Mathematics that runs. How a law becomes a machine.
Category theory says what composes. A polygraph writes those laws as rules. Rules that fire locally, in any order, are a computer, and a computer built from proved rules does what the mathematics says, on whatever hardware runs it. This is how we carry abstract mathematics into the physical world.
01 · Why rules
A description informs. A rule acts.
Mathematics that only describes the world leaves it as it is. To govern machines, matter and the systems we depend on, a law has to run, and keep its guarantee while it does. Rewriting is that bridge.
Category theory is the mathematics of composition: which parts fit, and why fitting them together in different orders gives the same whole. David Spivak describes it as an accounting system for collective sense-making. A commuting square is a law. A polygraph, a presentation by generators and rewrite rules in every dimension, writes the same law as a rule that turns one path into the other.
And rules are computation. Each one is local: it touches only the two things that meet, so rules can fire everywhere at once, and confluence guarantees that the answer does not depend on which fired first. Proved laws become local rules; local rules become parallel machines; the machine’s answer is the law’s answer. What carries a rule is a polynomial comonoid, by an equivalence we proved, building on Niu and Spivak’s polynomial functors.
The rules are not arbitrary. The distinction Principia begins with returns here as an operator: the boundary of a state, ∂a = a ∧ ∼a, is exactly what a reduction erases, and the kernel below is built from the operators of that logic.
02 · The machine
Four agents. Five rules. Fire them in any order.
This is Boundary, our rewriting kernel, running its real rules in your browser. Each verdigris wire is an active pair: two agents meeting principal to principal. Click any of them, in any order you like, and watch where the net ends up.
- α
Alpha
meet
a ⊓ b - ν
Nu
closure (a nucleus)
a ≤ ν a, ν(a ⊓ b) = ν a ⊓ ν b - τ
Tau
interior: the check
τ a ≤ a, τ(a ⊓ b) = τ a ⊓ τ b - ε
Eps
erasure
ε a = ⊥
- Annihilateν ▷◁ ν
- two closures cancel; their data wires join, their witnesses are erased
- Commuteν ▷◁ α
- closure distributes across meet: the net grows by four agents
- Eraseε ▷◁ ·
- erasure dominates and spreads to everything its opponent held
- Checkτ ▷◁ ·
- the verifier passes its opponent on, or stops the run with a reason
- Associateα ▷◁ α
- two meets rewire in one local step
Each agent’s meaning is proved in Lean: α is meet, ν a closure that preserves meets, τ an interior that checks, ε erasure to ⊥, and ν and τ both respect α and ε. The net above has exactly 360 complete runs; the button beside it runs every one with the kernel and reports what it finds.
03 · Every system is rules
Give us the rules a system follows. We tell you whether its parts make a whole.
A controller’s mode table, a protocol’s messages, a device’s command set: each is a polygraph. The Gluing Engine reads it and answers four questions, each with a certificate a small proof kernel checks without trusting the program that found it.
- Q1
Which states are really the same?
- Congruence holds
- normal forms index the classes
- When it fails
- ambiguity
- Q2
Does the order of events change the outcome?
- Confluence holds
- one normal form, in any schedule
- When it fails
- a race
- Q3
What is protected when parts fail?
- Factorisation holds
- noise moves only what does not matter
- When it fails
- a protected twist (a code)
- Q4
Can every local view agree?
- Synchronisation holds
- a global section; a reset word
- When it fails
- curvature around a loop
Every answer is a construction (here is how) or a refutation (here is the conserved quantity that makes it impossible), in the sense of constructor theory. The same system is then compiled, from the proofs, into code that runs on hardware.
04 · One way a whole fails
Every failure is a zigzag. Some of them are races.
Two things that must stay distinct get joined. Where it happens decides the remedy. A twist lives in how the system is read, and is reframed or deliberately kept, like an error-correcting code. A race lives in the system itself, and only a new rule repairs it. Here is a real one, from a home with solar, wind and a battery.
An EV asks to start at the instant the battery reaches its reserve
Run both schedules.
05 · Proofs run
There is no compiler.
A proof checker is itself a rewriting machine. Every success of Lean’s kernel corresponds, in both directions, to reductions on a four-cell interaction net. Proofs do not need translating into computation. They already are computation.
06 · Same answer, any machine
Confluence survives the substrate.
If the answer cannot depend on the order of steps, it cannot depend on the hardware either. The same reducer runs on processors and graphics cards and returns the same bytes, and where it runs is chosen by measurement.
07 · Coherence with a receipt
Not only that branches meet. That they meet lawfully.
When two rules apply at once, their results must be reconciled. We draw each such critical pair as a square in cubical type theory: only a lawful reconciliation can fill it, so coherence arrives with its own receipt, and a scheduler learns exactly how freely it may reorder work.
And reduction loses nothing it cannot account for. A confluent calculus normalizes, which erases; its unused second negation splits every state into a reversible core and its boundary, and that boundary is at once a reverse, a derivative and a clock.
08 · The same rules, everywhere
Markets, knots and meaning answer to the same method.
Once a domain is written as rules, the questions above apply to it unchanged. Three of the places we have taken them, each with its paper.
Markets
When a market solves itself
A market is a graph of goods and substitutions. Its number of independent loops decides when the equilibrium computes itself in one step; each loop is a correction.
Knots
Confluent by construction
The trefoil built along two different paths, and the two proved to meet, across six verification kernels and a runtime.
Meaning
What meaning can copy
A pronoun copies its noun; a model reuses a weight. Copying is faithful exactly on the classical states, and a forbidden copy costs exactly its logical entropy.
09 · From the page to the physical world
This is how mathematics takes command of matter.
A proved law, written as rules, run by a machine, checked on every step: each of our research records is this method meeting real hardware, in service of the people who depend on it.
- Research 001
Solar, governed by proof
A supervisor whose rules are proved before they run, extracted from a safe formal core to native code.
- Research 002
AI with its paper trail
A certificate chain that exists only when every step’s witness composes with the next.
- Research 003
Readings that carry their argument
Measurement contracts that compose, stage by stage, from the probe to the study’s decision.
- Research 004
Wind that proves its decisions
The Gluing Engine checking every supervisory decision; the race above was found there, and fixed.
Our technology is ontological · Our engineering is constructive
Software = Mathematics · Hardware = Physics
Discover ⇒ Build ⇒ Grow ⇒ Learn ⇒ Teach
10 · The library
Ten papers. Read them in full.
From the kernel to the systems it checks, in the order the work was done. Every result is machine-checked, and every paper is open.
Boundary
A four-agent interaction-style rewriting kernel with a Lean 4 reference semantics
Four agents, five rules, one rule per pair, and a total dispatch table: the machine every later result runs on.
Confluent by Construction
Seven cross-kernel demonstrations of knot topology in the Heyting substrate
Knots built two ways meet in one certified result, across six verification kernels and a runtime.
There Is No Compiler
Lean’s kernel as an active-pair interaction net
Every success of a proof checker is a reduction on a net, and back; 10,000 Mathlib declarations agree.
Polygraphic Computation
The polynomial substrate: container as carrier, cofree as behaviour, tricategory as coherence
What carries a rewrite rule: every polygraphic generator is a polynomial comonoid, by a proved equivalence.
Confluence Survives the Substrate
Byte-equal interaction-net reduction on CPU, CUDA and GB10
Four implementations, byte-identical; the router chooses hardware by measurement, never by hope.
When a Market Solves Itself
The homology of free computation in exchange economies
One number, the market graph’s count of independent loops, decides when an equilibrium computes itself.
Both Halves of the Boundary
The reverse, the derivative and the clock a reduction calculus already contains
Normalizing erases; its unused second negation splits every state into a reversible core and its boundary ∂a = a ∧ ∼a, which is at once a reverse, a derivative and a clock.
Interaction Nets That Carry Their Own Coherence
n-cell confluence over cubical type theory and the Boundary polygraph
Each critical pair becomes a square that only a legal join can fill: coherence with its own receipt.
Where the Parts Make a Whole
A certified instrument for collective sense-making
The Gluing Engine: any system as rules, four certified questions, and the one way a whole can fail.
What Meaning Can Copy
Machine-checked copy laws, braiding limits and exact acceptance for compositional quantum models
Exactly what copying permits, from a pronoun to a tied weight to a qubit, and what braiding adds.