The swarm is a machine that reads a tape of cells, writes what a quorum agrees it saw, and folds the result into a single root. This page is that machine — the geometry below is the same projection the model renders, driven by the same numbers.
Consensus protocols are usually described by what they promise. This one is easier to describe by what it is: a six-tuple, four phases, five symbols. Nothing in the rest of this page is outside it.
A cell is never “unknown”. Absence is a symbol too, and it is hashed into the root like any other — which is what turns an uncovered chain from a gap in a report into a claimable object.
No operator covers this chain. Unwritten, and provably so.
Covered, but agreeing stake is below θ. Nothing is written. Yield stops.
Quorum agreed. The digest is written and enters the root.
A challenge is open against the written digest. Bonds are frozen.
Challenge upheld. The digest is retracted and bonds are slashed.
Most networks guarantee coverage with a scheduler, and a scheduler is a thing that can be captured, starved or bribed. Here the head simply steps by a fixed stride and wraps.
If gcd(s, N) = 1, the head visits every cell exactly once every N epochs, from any starting position. Not usually. Not with high probability. Because s generates ℤ/Nℤ under addition precisely when s is a unit mod N.
There is no configuration of the network — no outage, no collusion, no fee market — under which some cell is never read. Drag the stride and watch the orbit close or fracture.
# covering = total stake that covers this chain # votes = digest -> agreeing stake def delta(votes, covering): if covering == 0 or not votes: return DARK, None d, w = max(votes, key=votes.get) if w / covering < theta: return THIN, None return LIT, d
The asymmetry is deliberate and it is the whole design. A THIN cell costs the network some yield. A lit-and-wrong cell costs it the full value behind the lane. So θ is placed where liveness is sacrificed first — the network is built to go quiet before it goes wrong.
Every tape index has a leaf — including the dark ones — so the tree is total. The index is bound into the leaf, so a proof for one cell cannot be replayed at another. A proof is ⌈log₂N⌉ siblings: 8 hashes for a 512-cell lattice.
What the anchor actually buys, stated precisely: publishing Ae on an L1 makes every epoch up to and including e immutable relative to that publication. It says nothing about epochs after the last published anchor.
“Nobody can rewrite history” is false as usually written. “Nobody can rewrite an anchored prefix without forking the L1 underneath it” is true, and it is the one we ship. The gap between those two sentences is where most bridge post-mortems live.
The classic deterrence bond makes lying EV-negative for one operator. It is a theorem and it is not enough.
As q falls, b explodes. At q = 0.10 you must post nine times the value at risk. Any protocol quoting a cheap bond is implicitly quoting a high detection rate — and a detection rate is a measurement, not a parameter.
As q rises, the deterrence minimum collapses toward zero — and a bond of zero does not stop someone buying n operators. So a network is under-bonded exactly when it is proudest of its detection rate.
Above q* the quorum term binds and the deterrence inequality alone is the wrong constraint. The requirement is the maximum of the two — nobody sizes it that way, which is the point.
| q | deterrence | quorum | required | binds |
|---|
120 epochs, 512 cells, 40 operators, θ = ⅔, q = 0.85. Every row is a run of the model on this page — the numbers are not illustrative.
| byzantine | coverage | safety violations | voided | verdict |
|---|---|---|---|---|
| 0% | 99.7% | 0 | 0 | safe + live |
| 5% | 99.6% | 0 | 0 | safe + live |
| 10% | 99.0% | 0 | 0 | safe + live |
| 20% | 88.5% | 0 | 0 | safe + live |
| 30% | 87.4% | 0 | 0 | safe + live |
| 34% | 15.6% | 0 | 0 | safe · liveness lost |
| 40% | 11.1% | 0 | 0 | safe · liveness lost |
| 50% | 5.0% | 0 | 0 | safe · liveness lost |
| 60% | 4.9% | 0 | 0 | safe · liveness lost |
The cliff sits at 1 − θ = ⅓, and nothing in the code puts it there. It falls out of the threshold. Below it the adversary cannot write a wrong digest, so it attacks liveness instead: cells drop to THIN and yield stops. Read the coverage column as the honest price of that trade, not as an outage.
Two things this table does not claim. It does not model P+ε bribery, under which the honest equilibrium is not unique and the quorum bond above is optimistic. And q = 0.85 is an assumption until it is measured — which is what the canary command does, and why it ships in the same file.
One file, standard library only, no dependencies. Every claim on this page is a command you can run. Twenty-five assertions cover the traversal theorem, the Merkle construction, the waterfall invariant and the bond algebra.
# the formal model, printed python3 taifoon_lattice.py model # one small lattice, six epochs, fully traced python3 taifoon_lattice.py demo # 300 epochs: coverage, safety, slashing, tranches python3 taifoon_lattice.py simulate --epochs 300 # where the adversary breaks it (the 1/3 cliff) python3 taifoon_lattice.py attack # bond adequacy, both constraints, crossover python3 taifoon_lattice.py sweep --n 14 # measure q instead of assuming it python3 taifoon_lattice.py canary --epochs 300 # build and verify a superroot inclusion proof python3 taifoon_lattice.py proof # re-render the geometry above, as SVG python3 taifoon_lattice.py render --out lattice.svg # every claim, asserted python3 taifoon_lattice.py selftest
The projection constants used by the canvas at the top of this page are the same constants the renderer uses — CELL = 0.10, Z₀ = 0.055, Z₁ = 0.335, growth = 1.105 — so the picture and the model cannot drift apart without the file failing its own tests.