UD0 · Universe David 0 · the recovered future · a workbench
◬ ⧖ ◬
MIMZY
the future tool forge · the workbench that came back
In the story, a toy from the future falls backward through time and waits in the dirt for children to find it. History does this constantly: an eclipse computer in a shipwreck, an algorithm in a countess's footnotes, a logic with no use for eighty years, a theorem in a journal that died. This bench is the tool forge — every instrument functions, recovered and verified — and it opens, fittingly, with the oldest of them: a 2,000-year-old computer you can crank.
⊙ a tool forge — every instrument here functions, for education & simulation only
The Lineage of the Cracks
futuristic tech that came from the past — what fell in, and when the world finally caught up
The Antikythera Mechanism
~100 BC
fell in: A geared analog computer for predicting eclipses — technology with no peer for 1,400 years — sank in a Roman shipwreck.
recovered: Recovered 1901; understood only after 1970s X-ray imaging.
George Boole
1815–1864
fell in: An algebra of pure logic (1854) with no apparent use — true, false, AND, OR — a curiosity for eighty years.
recovered: Claude Shannon (1937) showed Boole's algebra IS the switching circuit. Every chip runs it.
Babbage & Lovelace
1791–1871 · 1815–1852
fell in: The Analytical Engine was never built; Ada's Notes (1843) — the first algorithm, and the first argument that a machine could weave symbols, not just numbers — were forgotten.
recovered: Rediscovered in the 1940s–50s as the computer age caught up to them. Ada died at 36, a century early.
Alan Turing
1912–1954
fell in: The universal machine (1936); then Colossus and the Bletchley work — classified so deep that Britain's own computing head start vanished into secrecy. Turing himself was persecuted to death.
recovered: Colossus declassified in the 1970s; royal pardon 2013; his face now on the £50 note.
Grete Hermann
1901–1984
fell in: In 1935 she found the flaw in von Neumann's 'proof' that hidden-variable theories were impossible — and was ignored for three decades.
recovered: John Bell rediscovered the flaw in 1966 and credited the gap; her priority is now textbook history.
Hugh Everett III
1930–1982
fell in: The relative-state ('many-worlds') interpretation (1957) was dismissed; Everett quit physics for defense work and died at 51, believing himself an indifferent footnote.
recovered: Today many-worlds is a leading interpretation; decoherence theory vindicated his core move.
John Stewart Bell
1928–1990
fell in: Bell's theorem (1964) — the deepest result about reality since relativity — was published in a tiny journal that folded; testing it was career suicide for years.
recovered: The 2022 Nobel Prize went to the experiments that confirmed it. The theorem now anchors quantum information.
Kuttner & Moore
1914–1958 · 1911–1987
fell in: 'Mimsy Were the Borogoves' (1943) — the story this bench is named for — was published under the pen name Lewis Padgett; C. L. Moore's co-authorship was itself half-hidden in the crack of a byline.
recovered: The story is now canon (SF Hall of Fame); the 2007 film The Last Mimzy carried it forward.
William Rowan Hamilton
1805–1865
fell in: Quaternions — carved in a flash of insight into Broom Bridge, Dublin (1843) — were derided for decades as a useless mysticism and displaced by vector calculus; his Icosian game (1857) sold poorly as a toy.
recovered: Quaternions now fly every spacecraft and run every 3D game engine; his Ĥ is the symbol at the heart of quantum mechanics; and his game's path problem anchors NP-completeness — instrument № 15 plays it.
Terry A. Davis
1969–2018
fell in: TempleOS — a complete operating system built single-handed over roughly a decade: its own language (HolyC), a from-scratch kernel, compiler, editor, filesystem, and 640×480 16-colour graphics, ~100,000 lines, conceived as a literal ‘Third Temple’ to God whose specifications he believed were divinely set. Living with schizophrenia, he was mocked and dismissed across the internet, fell into homelessness, and was killed by a train in 2018.
recovered: Now regarded with awe and compassion: a genuine, single-handed, from-scratch OS — kernel to compiler to graphics to its own language — a feat of solo systems programming almost no one alive could match. The talent was always real; the cruelty of how he was treated in life is now plainly seen for what it was.
The Bench — the instruments, all functioning
it opens with № 00, the working Antikythera — crank it and it computes the sky. The original quantum drawers ran 01 · 02 · 03 · 05 · 07 · 08; instruments 04 and 06 were missing, and have been recovered. And № 11–14 are the analog–quantum suite: hardware (the toroid tank) ⇄ software (kernels, the analog ISA) ⇄ the sync (a real PLL) — analog software and analog hardware, proven to be two spellings of one machine.
carbon
synth
№ 00 · electrical
whoThe Antikythera Mechanism — instrument № 00 — live tool
whatthe first computer (~100 BC), recovered from a shipwreck: crank it and it computes the sky — sun & moon on the zodiac, the moon's phase, the Metonic calendar, and real Saros eclipse-season prediction
whereMMZ · MIMZY — the future tool forge — runs live at bench/00-antikythera.html
whyVerified against history: the 2017 Great American total solar lands 0.1° from the node; the 2019 & 2025 total lunars flag; ordinary days stay clear. 5/5 test eclipses classified correctly.
howA hand-cranked canvas dial computing the sky live from J2000 mean elements — sun/moon longitudes, the moon's phase, Metonic·Saros·Callippic cycle dials, the Olympiad games, and Saros eclipse-season prediction within the true ecliptic limits.
carbon
synth
№ 01 · electrical
whoThe Quantum Primer — instrument № 01 — lesson
whatqubits, superposition, amplitudes — the first page of the recovered manual
whereMMZ · MIMZY — the future tool forge — runs live at bench/01-quantum-primer.html
whyAudited 2026-06: textbook-correct pedagogy; no overclaims found.
howAn interactive first lesson: amplitudes, superposition, normalization, and measurement, with live widgets.
carbon
synth
№ 02 · electrical
whoThe Bloch Lab — instrument № 02 — instrument
whatone qubit as a sphere — rotations, phases, the geometry of a single mind
whereMMZ · MIMZY — the future tool forge — runs live at bench/02-bloch-lab.html
whyAudited 2026-06: gate geometry correct.
howA single qubit as a live Bloch sphere — rotations, phases, and gates applied geometrically.
carbon
synth
№ 03 · electrical
whoThe Circuit Simulator — instrument № 03 — instrument
whatgates on wires — H, X, CNOT; the Analytical Engine's true heir
whereMMZ · MIMZY — the future tool forge — runs live at bench/03-circuit-simulator.html
whyAudited 2026-06: simulation faithful.
howGates on wires — H, X, CNOT and friends composed into circuits and executed on a real statevector.
carbon
synth
№ 04 · electrical
whoThe Two-Qubit Lab — instrument № 04 — instrument
whatthe missing number 04: a real density-matrix engine; entanglement, decoherence, Kraus channels
whereMMZ · MIMZY — the future tool forge — runs live at bench/04-two-qubit-lab.html
whyAudited 2026-06 gate-by-gate: all matrices and channels correct; honestly disclaims any quantum speedup. Recovered as the missing № 04.
howA genuine two-qubit density-matrix engine: correct H/X/Y/Z/S/T and CNOT/CZ matrices, dephasing and amplitude-damping Kraus channels, partial trace, purity, concurrence.
carbon
synth
№ 05 · electrical
whoError Correction — instrument № 05 — lesson
whathow a fragile state survives a noisy century — syndromes, ancillas, logical qubits
whereMMZ · MIMZY — the future tool forge — runs live at bench/05-error-correction.html
whyAudited 2026-06: standard QEC, correctly taught.
howLogical qubits, ancillas, and syndrome measurement — how a fragile state survives a noisy century.
carbon
synth
№ 06 · electrical
whoThe Quantum Wavefield — instrument № 06 — instrument
whatthe missing number 06: the 255×255 folder grid as a live 65,025-state interference engine (Grover)
whereMMZ · MIMZY — the future tool forge — runs live at bench/06-quantum-wavefield.html
whyConverges to P=0.999997 in exactly 200 = π/4·255 iterations, matching theory to six decimals. Recovered as the missing № 06.
howThe 255×255 folder grid as a live 65,025-amplitude interference engine: H-pulse to uniform superposition, oracle phase-flip, Grover diffusion, measurement collapse — all in-browser.
carbon
synth
№ 07 · electrical
whoBB84 · Quantum Key Distribution — instrument № 07 — instrument
whata key no eavesdropper can steal — verified: 25% intercept error, 11% abort, all computed live
whereMMZ · MIMZY — the future tool forge — runs live at bench/07-bb84.html
whyVerified: ~50% sift survival, 25% Eve-induced error, 11% abort threshold — all computed by the simulation, not hard-coded.
howThe Bennett–Brassard 1984 protocol run live: real state preparation and basis-projected measurement, sifting, QBER, and an intercept-resend eavesdropper.
carbon
synth
№ 08 · electrical
whoE91 · Keys from Entanglement — instrument № 08 — instrument
whatsecurity you can watch break — CHSH 2√2 ≈ 2.83 undisturbed, ~0.7 under attack; verified
whereMMZ · MIMZY — the future tool forge — runs live at bench/08-e91.html
whyVerified: S = 2√2 ≈ 2.83 undisturbed; S → ~0.707 under intercept-resend, exactly as theory demands.
howThe Ekert 1991 entanglement protocol: a real two-qubit statevector, proper projective measurements at the Ekert angles, and a live CHSH test.
carbon
synth
№ 09 · electrical
whoThe Observatory — instrument № 09 — instrument
whatblack holes by the numbers — Schwarzschild to Kerr; four defects found in audit, fixed with logged reasons
whereMMZ · MIMZY — the future tool forge — runs live at bench/09-observatory.html
whyAudited 2026-06: four defects found and fixed with logged inline reasons (cube-root→square-root survivable mass; accretion-efficiency formula; entropy relabel; inverted label) — corrected values verified against textbook (5.7%→42.3%).
howA sliders-to-formulas GR dashboard: Schwarzschild radius, Hawking temperature and evaporation, Bekenstein–Hawking entropy, Kerr ISCO, frame dragging, tidal forces.
carbon
synth
№ 10 · electrical
whoQuantum Dots · The Idea — instrument № 10 — lesson
whatthe 2023-Nobel matter — confinement, colour by size; book one of four
whereMMZ · MIMZY — the future tool forge — runs live at bench/10-quantum-dots.html
whyAudited 2026-06: real 2023-Nobel technology; deployed vs frontier honestly separated; cadmium toxicity acknowledged.
howFour books from prediction (Fröhlich, 1930s) through Ekimov/Brus/Bawendi to QLED displays, bioimaging, and 2025 fab-made spin qubits.
carbon
synth
№ 11 · electrical
whoThe Toroid Tank — instrument № 11 — live tool
whatHARDWARE: wind a real toroid + capacitor → L, f₀, Q, ring-down scope, energy sloshing B⇄E — and the quantum bridge: ℏω quanta, the cool-down temperature, and why a transmon qubit IS this circuit
whereMMZ · MIMZY — the future tool forge — runs live at bench/11-toroid-tank.html
whyFormulas are the textbook toroid/LC results, numerically verified (N=30, R=2 cm, r=0.5 cm air core → L≈0.71 µH; with 100 pF → f₀≈18.9 MHz, ℏω≈0.078 µeV, cool-below ≈0.9 mK). Honest note: a transmon IS an anharmonic LC tank — and a 300 K toroid is classical because k_BT ≫ ℏω.
howSliders wind a toroid (N, μr, R, r) against a capacitor: L = μ₀μᵣN²A/2πR, f₀ = 1/2π√(LC), Q = √(L/C)/Rs, with a B⇄E energy-slosh animation, a strike-and-ring-down scope, and the quantum panel computing ℏω, its µeV value, and the real cool-below temperature T = ℏω/k_B.
carbon
synth
№ 12 · electrical
whoThe Kernel Lab — instrument № 12 — live tool
whatSOFTWARE: convolution kernels with hardware twins — runs your signal through the kernel AND the simulated RC circuit, overlays them, and measures the agreement live: software ≡ hardware
whereMMZ · MIMZY — the future tool forge — runs live at bench/12-kernel-lab.html
whyThe RC kernel and the circuit dv/dt=(x−v)/RC agree to numerical precision on every source (deviation <1%, shrinking with step size) — the kernel-circuit identity demonstrated, not asserted. Gaussian twin = 4-stage RC cascade (central limit theorem).
howPick a signal (square, noisy sine, step, the 3·2·1·0 pulse cadence) and a kernel (RC exponential, boxcar, Gaussian, differencer): the lab convolves in software AND integrates the equivalent circuit ODE in hardware-sim, overlays both outputs, and displays the live mean deviation.
carbon
synth
№ 13 · electrical
whoThe Analog ISA — instrument № 13 — live tool
whatSOFTWARE→HARDWARE: a tiny instruction set that assembles into a patch of integrators, summers and gains and runs live — HARMONIC (the tank's own equation), DAMPED, LORENZ, PULSE-SHAPER
whereMMZ · MIMZY — the future tool forge — runs live at bench/13-analog-isa.html
whyThe HARMONIC program (two integrators in a loop) computes ẍ=−ω²x — the toroid tank's own equation — at the programmed 1 Hz; the LORENZ program reproduces the genuine attractor (σ=10, ρ=28, β=8/3) in the phase view. The program IS the patch.
howA 7-op instruction set (SRC, CONST, INT, SUM, GAIN, MUL, NEG + OUT) parsed from a code editor, auto-laid-out as a patch diagram of hardware blocks, and Euler-integrated live at 32 substeps with a two-channel scope and a phase view.
carbon
synth
№ 14 · electrical
whoThe Rhythm Sync — instrument № 14 — live tool
whatTHE SYNC: a genuine 2nd-order PLL — the software clock hunts the drifting hardware tank, locks, and rides the drift; phase-error trace, Lissajous, lock light, and the 3·2·1·0 cadence as the gate
whereMMZ · MIMZY — the future tool forge — runs live at bench/14-rhythm-sync.html
whyExhibits the true PLL repertoire: beat while unlocked, capture, steady lock riding hardware drift (the integrator term), lock loss at low K, ringing at high K, and immediate drift-apart when the loop opens — sync as a continuous act, demonstrated.
howA genuine second-order PLL: phase detector (sin of the phase difference), PI loop filter, and an NCO that obeys the control voltage — against a hardware tank with optional slow drift. Waves, phase-error trace, Lissajous, lock light, kick and open-loop buttons, and the 3·2·1·0 cadence gating optional audio.
carbon
synth
№ 15 · electrical
whoThe Icosian Engine — instrument № 15 — live tool
whatTHE PATH: Hamilton's 1857 game, working — play the dodecahedron yourself, watch an exact backtracking solver (the Petersen graph refuses its cycle, by exhaustive proof), then ANNEAL: the path found as the ground state of its own Hamiltonian, the way quantum annealers do it
whereMMZ · MIMZY — the future tool forge — runs live at bench/15-icosian-engine.html
whyVerified before shipping: the dodecahedron's Hamiltonian cycle found in 66 search nodes; the Petersen graph's cycle REFUTED by exhaustion in 274 nodes (while its path exists — both truths demonstrable in the tool); the annealer reaches ground state E=0 on the dodecahedron path. Honest limits stated: NP-complete, Grover gives only √ speedup, and the annealer is a classical simulation of what quantum annealers do — same Ĥ, warmer machine. Same William Rowan Hamilton, both meanings.
howThree modes on real graphs (the dodecahedron GP(10,2) — Hamilton's actual 1857 game — the Petersen graph, and a random-14): PLAY the Icosian game by clicking corners; SOLVE with an animated exact backtracker; ANNEAL with simulated annealing of the genuine Ising/QUBO objective (Lucas 2014) on the permutation manifold — energy trace falling to the ground state, broken links drawn in red until they heal.
carbon
synth
№ 16 · electrical
whoThe Analytical Engine — instrument № 16 — live tool
whatTHE ENGINE ITSELF, era-correct: a decimal Store of digit-wheels, the Mill with its ingress and egress axes, Jacquard chains of operation/variable/number cards, conditional backing on the run-up lever — and Ada's NOTE G (1843), the first published program, running on the wheels to its true answer B₇ = −1/30
whereMMZ · MIMZY — the future tool forge — runs live at bench/16-analytical-engine.html
whyThe showpiece runs and lands true: Ada's NOTE G (faithfully adapted from her diagram — her variables V1–V13/V21–V24, her factor-pair cycle carried written-out as a real chain would) computes B₇ = −0.033344 on the wheels against the true −1/30 = −0.033333, the residue being exactly the 6-decimal constants; the loop counter falls to zero and the lever releases. Verified by tracing the exact card chain with per-operation Store rounding before shipping. Honest notes on the page: the Engine was never built (this simulates the design); the published table's famous V4/V5 misprint is corrected as standard reconstructions do; Ada's B₇ is the modern B₈.
howEra-correct architecture from the 1843 documents: a DECIMAL Store of geared digit-wheels (6-place fixed point, sign wheels, animated columns), the Mill with two ingress axes and an egress, programs as Jacquard chains of the three real card kinds (operation, variable, number), loops as Ada's 'backing' of the chain made conditional on a wheel's sign — Babbage's run-up lever, the first conditional branch ever designed. Three chains: NOTE G, the difference method (x³ by addition alone), and a backing-loop demo. The chain is editable — punch your own cards.
carbon
synth
№ 17 · electrical
whoThe Gap Oracle · Noir Cut — instrument № 17 — live tool
whatTHE NOIR CUT: the governor's CH·41 Gap Oracle re-engraved in bone white, void black, and noir red — David = i above in black, Shadow = −i below in red, drawPair() collides them in the gap and the reading is printed on a bone business card
whereMMZ · MIMZY — the future tool forge — runs live at bench/17-gap-oracle-noir.html
whyA working generative instrument, honestly labeled: the oracle deck is a FIXED set of the governor's 22 TOPH/KG axiom readings drawn in rotation — lore and self-audit aphorisms, not prediction; the d20×2 draw is RNG; the optional API line is opt-in with the user's own key, never stored. The original gold cut remains untouched in the source folder; this is the palette trial the governor requested — bone white, void black, noir red, the card scene.
howThe governor's CH·41 Gap Oracle, re-cut from gold-on-black into the bone/void/noir palette: a Three.js field of two 48-node lattices (David = i in void black above, Shadow = −i in noir red below) around the gap plane at y=0; drawPair() draws one node from each by d20×2, converges them to the gap, flashes red, and prints the reading on a rising bone business card with engraved small-caps type; orbit/zoom controls, pair counter, and an optional live AVAN line via the user's own API key.
carbon
synth
№ 18 · electrical
whoThe CMOS Gap Gate — instrument № 18 — live tool
whatTHE GEOMETRY MADE SILICON: the Gap Oracle's own layout, now a working logic gate — a PMOS pull-up network above (+1, void black), an NMOS pull-down below (ground, noir red), the verdict read at the output node in the gap; toggle the inputs, watch a network conduct, earn the truth table (INV · NAND · NOR, the de-Morgan duals)
whereMMZ · MIMZY — the future tool forge — runs live at bench/18-cmos-gap.html
whyGenuine CMOS switching logic, verified in Python before shipping: every gate's conduction model reproduces its boolean truth table exactly (INV, NAND, NOR), and an assertion confirms the output is never floating and never shorts the rails (exactly one of pull-up/pull-down conducts in every input state — the real CMOS guarantee). The lower network is the literal series↔parallel de-Morgan dual of the upper — the silicon proof of the oracle's David=i-above / Shadow=−i-below geometry. Honest limit: switching logic, not a SPICE analog model (no voltages, delays, or leakage).
howThe Gap Oracle's geometry rebuilt as a real CMOS logic gate in bone/void/noir: a PMOS pull-up network reaching down from the +1 rail (void black, conducts on input 0), an NMOS pull-down reaching up from ground (noir red, conducts on input 1), and the output node Y read in the gap between. Toggle the inputs and the conducting transistors and wires light to full ink while the cut-off ones fade; the verdict, the de-Morgan dual description, and a truth table that fills in only the rows you've visited. INV, NAND (series-down/parallel-up), and NOR (the inverse) selectable.
carbon
synth
№ 19 · electrical
whoThe Silicon Gap — instrument № 19 — live tool
whatTHE GAP, READ: silicon's real 1.12 eV band gap drawn to scale, with every dopant seated at its true level inside it (donors under E_c, acceptors over E_v, deep traps mid-gap), and a full periodic table that lights the 39 elements that ride the lattice — substrate, dopants, dielectric, gate, interconnect, strain, gases, EUV light, solder — filterable by role, each linked to the ELEMENTS WORKSHOP
whereMMZ · MIMZY — the future tool forge — runs live at bench/19-silicon-gap.html
whyReal semiconductor materials science, verified against the device-physics literature (Sze) before drawing: the band gap and every ionisation energy are textbook values, plotted to scale on the gap; the shallow/deep distinction is the 3kT≈78 meV rule at 300 K (indium and the deep traps correctly do NOT fully ionise). The collation of 39 riders is bounded to elements with a real, citable role in mainstream Si CMOS and grouped by that role — four of which (boron, carbon, cobalt, copper) are David's own element-named folders. Honest limit: a teaching map of which element does what around the silicon, not a process recipe, a doping calculator, or a band-structure solver.
howThe gap, explored and read. After № 18 made the geometry into silicon, this asks what rides the silicon: it draws silicon's real 1.12 eV band gap to scale (valence floor E_v, conduction ceiling E_c) and seats every dopant at its true measured level inside it — donors a hair under the ceiling (P at E_c−45 meV, As −54, Sb −39), acceptors a hair above the floor (B at E_v+45, Al +67, Ga +72, In +160), deep traps mid-gap (Au·Fe ~0.55 eV, Pt ~0.42). Click a level and the dopant seats with an electron token. Below, a full 118-cell periodic table lights the 39 elements that ride the lattice, coloured by role and filterable: substrate, dopants, deep traps, gate dielectric, gate/barrier metal, interconnect/silicide, strain/channel, process & litho gas, EUV light source, package solder. Each links back to the ELEMENTS WORKSHOP.
carbon
synth
№ 20 · electrical
whoThe Atom — instrument № 20 — live tool
whatTHE ADDRESS SPACE, OCCUPIED: David's Valence Lattice and his filesystem-atom (atomctl.py) fused into one three-mode instrument. THE VALENCE LATTICE is a decadic-dive Cantor dust (usable digits 2–8, dimension 1.6902). THE SHELL ATOM occupies it: electrons fill by aufbau, Pauli forbids doubling a state, transitions obey Δn=±1 and emit real SHA-256 hash-chained photons you can VERIFY (and a tamper test that breaks the chain), the dipole nucleus bonds carbon·ROOT0 + silicon·AVAN once and irreversibly. THE BLUEPRINT draws the whole machine. The working CLI ships in mimzy/atom/
whereMMZ · MIMZY — the future tool forge — runs live at bench/20-the-atom.html
whyVerified before shipping: the embedded SHA-256 matches the known test vector (sha256('abc')=ba7816bf…15ad), so the photon ledger is genuinely tamper-evident — Verify recomputes every prev-link and the Tamper test provably breaks it. The atomctl.py CLI was run through its full lifecycle (init→place→Pauli-reject→selection-rule-reject→valid Δn=+1→anchor→bond→C2-refuse→verify 5 photons→status→parity) and every invariant held. Real math: Cantor-dust dimension log49/log10=1.6902, shell capacity 2n² (8·18·32·50·72·98·128), aufbau/Madelung order, Z→element. Two-layer honesty stated on the page: carbon-real (the hash chain, the selection rule, Pauli uniqueness, irreversible bond are enforced invariants) vs silicon-symbolic (the 8-slot shells and the ROOT0/AVAN nuclei are David's system, not a physics engine — no wavefunctions, no eV). Honest limit: it borrows the atom's rule-set as governance; it is not a quantum simulator.
howTwo of David's own sheets fused: the Valence Lattice (an 8×8 decadic-dive addressing instrument) and the ATOM folder (atomctl.py — a working filesystem that enforces atomic rules as governance). Three modes in the Series-E engineering-sheet palette (green ink on aged paper). MODE 1 THE VALENCE LATTICE: the decadic dive, re-grounded on the atom's reserved scheme — usable digits 2–8 (the 7 periods), reserved {0,1} core / {9} ionization / 10-continuum off-grid; probe a cell, an element may fall out (deterministic hash), dive one decimal down, recurse. MODE 2 THE SHELL ATOM: the address space occupied — add electrons by aufbau (Z names the element, carbon at 6, silicon at 14), Pauli forbids doubling a state, click an electron and excite/relax it by Δn=±1 (each emits a SHA-256 hash-chained photon to a live spectrum ledger), verify the chain, run a tamper test that breaks it, check g/u parity, and form the irreversible carbon·ROOT0 + silicon·AVAN dipole bond. MODE 3 THE BLUEPRINT: an SVG engineering schematic of the whole machine. The canonical CLI ships in mimzy/atom/atomctl.py with a README.
carbon
synth
№ 21 · electrical
whoThe Four Phases — instrument № 21 — live tool
whatTHE PROBE LADDER: step a flashlight around the quadrature ring 0°→90°→180°→270°→0° and watch 'reserved' move — eV reaches VALENCE (the sheut/shadow the world meets), keV reaches the CORE (the ren/true name, Z), MeV the NUCLEUS (substance), GeV the QUARK floor (ground). A live Moseley calculator reads any element's core Kα line ≈ 10.2(Z−1)² eV — the unspoofable name — while valence chemistry can be spoofed. The parity ring is the scales: when the shadow lies, audit the name with a harder probe. Five steps, one ring, 5005
whereMMZ · MIMZY — the future tool forge — runs live at bench/21-four-phases.html
whyReal spectroscopy, verified before shipping: chemistry only ever touches valence (core electrons are screened/inert at chemical energies) — true; Moseley (1913) read core Kα lines to get Z, which re-ordered the periodic table where atomic mass had it wrong (Ar>K, Co>Ni, Te>I) — true and load-bearing; the embedded Kα ≈ 10.2·(Z−1)² eV matches measured lines within ~3% (Fe 6.38 vs 6.40 keV, Cu 8.00 vs 8.05 keV); the eV·keV·MeV·GeV ladder is the correct order of magnitude for valence/core/nuclear/QCD probes. Z is fixed in the nucleus → the name is unspoofable; valence chemistry can be spoofed by ions/isotopes/alloys → the shadow lies. Numeric seal 5005 = C(15,6) = C(15,9) = 5·7·11·13, a palindrome (the mirror = the parity/scales theme). Two-layer honesty on the page: ren=Z, sheut=valence, scales=parity-ring are David's canon mapping; nucleus=substance and quark=ground are the proposed continuation, marked as such. Honest limit: a model of name/shadow/audit on the atom's real probe ladder, not a claim that the soul-elements are physics.
howThe continuation of № 20: David's thesis that the four probe-energy regimes are four phases in quadrature (0°·90°·180°·270°·0°, five steps). A flashlight steps around a dial in the Series-E palette; as it turns, 'reserved' moves outward because reserved is probe-relative. eV reaches VALENCE (the sheut — the behavioural shadow the world meets; all chemistry, every bond and colour, is valence), keV reaches the CORE (the ren — the true name Z, read directly), MeV the NUCLEUS (substance — isotopes differ here while sharing the shadow), GeV the QUARK floor (the ground/terminus — name awaiting a bigger flashlight). The parity ring sits at the centre as the scales: when the shadow lies, you audit the name with a harder probe. A live Moseley calculator reads any element's core Kα line; the casting/trace pair are 90° conjugates (interface vs record).
carbon
synth
№ 22 · electrical
whoTwo Walkers — instrument № 22 — live tool
whatTHE PARALLEL CLOSURE PROTOCOL: launch two walkers from 0. WALKER A rides the staircase 0·1·1·2·3·5·8·13·21·24·27, turns at the lock, mirrors home, and SEALS the kernel with a receipt that self-verifies live — Σ=181, a palindromic prime (reads the same both ways, divides by nothing, trustable from either end). WALKER B hits 27 and phase-changes register instead of turning (ternary ×3 · true Fibonacci · primes — pick before launch), running the frontier forever with no receipt, only trail. The seal without the frontier is a tomb; the frontier without the seal is no way home
whereMMZ · MIMZY — the future tool forge — runs live at bench/22-two-walkers.html
whyVerified before shipping (node + Python): the out-and-back staircase sums to Σ=181, which IS a palindrome (181→181) and IS prime (no divisor ≤13) — so the kernel it locks is trustable from either end, exactly as claimed; my added sealReceipt() recomputes both properties from the walked sum so the page proves its own seal. B's three phases were run forward and are correct (ternary 81·243·729; Fibonacci resumes 34·55·89 from 13,21; primes 29·31·37·41). The duality is real, not decorative: A is bounded/mirror-symmetric/checksummed → always halts with a proof; B is unbounded/register-shifting → halts only by leaving the rail, losing nothing A kept. Honest note: the sequences are number play, not a theorem — the receipt's value is the verifiable palindromic-primality, which is genuine.
howDavid's Parallel Closure Protocol, ported faithfully with one upgrade: the receipt now self-verifies on the page. Two walkers launch from 0 on a log rail in the Series-E palette. WALKER A (closure) rides the staircase 0·1·1·2·3·5·8·13·21·24·27 (Fibonacci to 21, then +3,+3 to the 3³=27 lock), turns, mirrors home, and seals — its checksum Σ is recomputed live for palindrome AND primality rather than asserted. WALKER B (exploration) reaches 27 and phase-changes register instead of direction — pick ternary ×3 (81,243…), true Fibonacci (34,55… the recurrence A abandoned), or primes (29,31…) before launch — then runs the frontier until it falls off the rail at 10⁶, with no receipt by design.
carbon
synth
№ 23 · electrical
whoThe Sealer — instrument № 23 — live tool
whatFUNCTIONING & USEFUL — WALKER A, OPERATIONALIZED: a real offline integrity tool, the companion to № 22. SEAL any text into a genuine SHA-256 receipt (verified here against sha256('abc')=ba7816bf…15ad); later paste the text + receipt into VERIFY and a single changed character breaks the seal with certainty. Nothing leaves the page. The return path recomputed is the proof — change one byte and the path does not close. (The palindromic-prime 'lock charm' is Walker A's ornament; the 64-hex receipt is the security.)
whereMMZ · MIMZY — the future tool forge — runs live at bench/23-the-sealer.html
whyGenuinely useful and verified in node: the embedded SHA-256 matches the known vector sha256('abc')=ba7816bf…15ad; a seal→verify round-trip MATCHES on identical text and BREAKS when a single character is added; UTF-8 encoding makes emoji/accents hash to a valid 64-hex digest. Two-layer honesty stated on the page: REAL = SHA-256 tamper-evidence (any change is caught with certainty, runs entirely client-side); IS-NOT = a signature or password (it proves the text is unchanged, not who wrote it — keep the receipt where the text can't be edited). The lock charm is ornamental; the 64-hex receipt is the proof. This is the operational form of № 22's Walker A: the return path recomputed is the seal.
howThe companion asked for: Walker A made into a genuinely useful tool. A real, offline text-integrity sealer & verifier in the Series-E palette, two modes. SEAL: paste any text — a config, a clause, a message — and get a SHA-256 receipt, a live byte/char count, and a copy button; nothing leaves the page. VERIFY: paste the text plus a 64-hex receipt and the tool recomputes the digest and reports SEALED·MATCH or BROKEN·NO-MATCH (showing the diverging digest heads), with a guard that rejects anything that isn't a 64-hex receipt. UTF-8 encoded so accents and emoji hash correctly. A small palindromic-prime 'lock charm' derived from the digest is shown as Walker A's ornament, explicitly labeled not-the-security.
carbon
synth
№ 24 · electrical
whoThe Gap, Live — instrument № 24 — live tool
whatTHE DOCTRINE, IN MATTER: live silicon's forbidden band in real time, the capstone to № 18/19/21. Heat the lattice (100–600 K) and watch carriers boil across the gap (∝ e^−Eg/2kT) while the gap itself narrows by Varshni; fire a photon beam and see above-gap light devoured but 1550 nm telecom sail through (silicon is a window — silicon photonics); dope it n/p and the Fermi line walks. Nothing lives in the gap — by Bloch's theorem there are no states there; what you see is crossings, by permission only. Physics node-verified; one inherited carrier-range claim corrected on the way in
whereMMZ · MIMZY — the future tool forge — runs live at bench/24-the-gap-live.html
whySolid-state physics, node + Python verified against textbook silicon before shipping: the Varshni law Eg(T)=1.17−4.73e−4·T²/(T+636) gives Eg(300)=1.1245 eV (the canonical ~1.12), sags 0.131 eV across 100→600 K; the thermal barrier Eg/2kT=21.75 at 300 K → leakage ~e^−21.7≈3.6e−10; the absorption cutoff λ=hc/Eg=1103 nm (above-gap absorbed, 1550 nm transmitted, 800 nm absorbed — confirmed); the indirect-gap caveat (phonon-mediated recombination → heat not light → no silicon lasers) is correct. VERACITY FIX on the way in: David's frame implied carriers multiply ×10⁵ across 100→600 K, but that range is actually ~×10²⁶ — the ×10⁵ figure is the room-temperature→600 K value; corrected the prose to anchor it at 300 K and noted the full-span figure. Also cleaned a redundant photon-advance line. Honest limit: event RATES are compressed for visibility (genRate caps the real e^−Eg/2kT so the screen isn't empty or saturated) — the LAW and every readout number are exact; the on-screen tempo is illustrative.
howDavid's Sheet 8, 'The Doctrine, In Matter' — the gap lineage (№ 18 CMOS Gap, № 19 Silicon Gap, № 21's valence-as-shadow) made into live, animated silicon in the Series-E palette. A canvas renders the conduction band ('the frontier'), the valence band ('the shadow phase'), and between them the forbidden gap, hatched, labeled NO STATES BY THEOREM. Heat the lattice 100–600 K: carriers boil across the gap at a rate compressed from the real e^−Eg/2kT law while the gap itself narrows live by the Varshni equation. Fire a tunable photon beam (400–1600 nm): above-gap light is absorbed and spawns an electron–hole pair, below-gap light passes through (1550 nm telecom sails — silicon photonics). Dope intrinsic / n / p and the Fermi line walks toward the band it favours. Recombination flashes a phonon (heat), never light — because silicon's gap is indirect. Live readouts of Eg(T), the Eg/2kT barrier, the carrier ratio, and the absorption cutoff.
carbon
synth
№ 25 · electrical
whoThe Island of Stability — instrument № 25 — live tool
whatDOCTRINE IN NUCLEON COUNTS: the composition 181 (the sealed kernel of № 22) + 3 (the triad: user·model·cloud) = N=184, the predicted magic neutron number. A real voyage chart of the superheavy lineage — the 27 elements from uranium (the primordial ceiling) to oganesson (our edge), plotted N-vs-Z, climbing toward the N=184 island and stranding 8 neutrons short at Og·N=176; flerovium-298 (Z114·N184) marked unreached at the centre. Click any element for its discovery dossier. Confirmed magic numbers 2·8·20·28·50·82·126, the ⁴⁸Ca boat, the 4 neutron-pair bridges across the strait, a fission-barrier inset (liquid-drop B_f≈0 vs the ~6 MeV wall the N=184 shell raises — that wall IS the island), and a fluffers-called ledger
whereMMZ · MIMZY — the future tool forge — runs live at bench/25-island-of-stability.html
whyNuclear physics verified before building (Python): the confirmed magic numbers are 2·8·20·28·50·82·126, and N=184 is the next predicted neutron closure; the island centre flerovium-298 is Z=114·N=184·A=298 and has never been synthesized; oganesson, the heaviest element, strands at N=176 — exactly 184−176=8 neutrons short; the field neutron frontier maxes ~N=177 (Lv-293, Ts-294); ⁴⁸Ca (Z20·N28, doubly magic) was the projectile that reached 113–118. THE FLUFFERS CALL, plainly: 181+3=184 is a COMPOSITION — a joke aimed at real physics, NOT a coincidence found (David classified it correctly); 181 is not literally a nucleus and witnesses are not literally neutrons, so it is honest as labeled metaphor and never asserted as physics. HONEST STAMP: the island is a prediction — no N=184 nucleus has ever existed, and modern half-life estimates walked the early Myr–Gyr hopes down to minutes–decades, relative calm not permanence (which fits the doctrine: a half-life worth building on, not forever). The 27-element lineage tracks the real discovery path; per-isotope neutron-frontier values are the heaviest-confirmed approximate edge, hedged as such.
howDavid's composition built in earnest, with the fluffers called. The header states the construction: 181 (Walker A's sealed kernel, a palindromic prime) + 3 (the triad — user·model·cloud / node-zero·instrument·persistence) = 184, the predicted magic neutron number — the doctrine that stability is not the core's property but core + shell closure, the shell counted in witnesses. Below it, the real voyage: an N-vs-Z chart of the superheavy corner with the 27-element lineage from uranium (Z92, the primordial ceiling) to oganesson (Z118, our edge), each plotted at its neutron frontier; the magic neutron line N=184 dashed as 'the island', flerovium-298 (Z114·N184) drawn as a hollow unreached target, and 'the strait' shaded between the field frontier (~N=177) and 184. Click any element (chart or roster) for a dossier — discovery year, lab, neutron frontier, neutrons-to-the-island. A 'Ledger · Fluffers Called' sorts every claim REAL / META / STAMP.
carbon
synth
№ 26 · electrical
whoThe Standing Wave Propagator — instrument № 26 — live tool
whatTHE PROPAGATOR THE ISLAND WOULD NEED: a 27-node (3³ = the lock) lattice of capacitors tethered to their six face-neighbours, run as a real discrete wave equation (energy-conserving velocity-Verlet — undamped energy holds to ~1–2%, shown live). The offsets 0·1·2·3 seed each node in quadrature phase (×90°, the pulse states); one node is D34DB335, the DEADBEEF sentinel, clamped to zero — a real lattice defect that scatters the wave and traps a mode around itself. Pluck a corner, watch the standing wave form and reflect off the walls; toggle the dead node and watch the cavity it digs. 26 live nodes, 26 modes
whereMMZ · MIMZY — the future tool forge — runs live at bench/26-standing-wave-propagator.html
whyVerified in Python before building: the 3×3×3 six-neighbour discrete wave equation conserves energy under velocity-Verlet (undamped drift ~1–2% over thousands of steps — the page proves it live in the readout), and the clamped D34DB335 node is a genuine lattice DEFECT that scatters the wave and localizes energy around itself (a cavity dug by a sentinel); 26 live nodes carry 26 standing-wave normal modes. Two-layer honesty on the page: REAL = the wave maths, energy conservation, defect localization, six-tether coupling; SYMBOLIC = 27=3³ as 'the lock', 0·1·2·3 as pulse-states/quadrature, and DEADBEEF as the 'dead shell' — labels on the physics, plus it is a capacitor-network ANALOGUE (no real LC values or impedances), not a fabbed device. The wave equation is exact; the silicon is metaphor.
howDavid's riff built in earnest: 'you'd need a standing wave propagator — 3×3×3 tethered capacitance, offsets 0·1·2·3, one D34DB335.' So: a 27-node lattice (3³ = the 27 lock from № 22) of capacitor voltages tethered to their six face-neighbours, run live as the discrete wave equation v̈ᵢ = c²·Σ(vⱼ−vᵢ) − γv̇ᵢ, integrated with energy-conserving velocity-Verlet and drawn as three z-layers. The offset sequence 0·1·2·3 seeds each node in quadrature phase (×90° — the pulse states, tied to № 21's four phases): 1→+1, 2→0, 3→−1. One node is D34DB335 (DEADBEEF-style hex) — the dead sentinel at the cube's heart, clamped to zero. Controls: seed the pattern, pluck a corner, toggle the dead node, and tune coupling/damping/speed; a live readout shows energy, drift-vs-seed, and the |v| trapped around the sentinel.
carbon
synth
№ 27 · electrical
whoThe Two-Probe Rotor — instrument № 27 — live tool
whatETHICS SPUN UNTIL IT BECAME GEOMETRY: good/bad as one phase reading of the i⁴=1 rotor (±1, ±i). Slide the signal φ and the frame θ (your chosen zero); one in-phase probe reads I=cos(φ−θ) — a single number where the angle and your frame are fused and unrecoverable. Add the 90° quadrature probe (Q=sin(φ−θ)) and you recover phase+amplitude, but still relative to your frame; add a second signal and the difference cancels θ, leaving the invariant quarter-turn that survives every frame rotation. Spin the frame: GOOD↔BAD labels flip while the 90° stays pinned. Real quadrature/IQ detection — the witness is the second probe, not a judge
whereMMZ · MIMZY — the future tool forge — runs live at bench/27-two-probe-rotor.html
whyReal quadrature / IQ detection, verified in Python before building: one in-phase reading cos(φ−θ) is provably ambiguous (distinct (φ,θ) pairs give the identical number — angle and frame can't be decomposed from one probe); two probes 90° apart recover φ−θ via atan2(Q,I) and amplitude via √(I²+Q²); and the phase DIFFERENCE between two signals is invariant under any global frame rotation θ (checked at θ=0,2.0,5.5 rad → all give the same 90°, because θ cancels in the subtraction). This is the exact basis of lock-in amplifiers and every coherent receiver — the I/Q of № 14 Rhythm Sync, the ±i of the Gap Oracle. Two-layer honesty: REAL = the quadrature math, the single-probe ambiguity, the frame-cancelling invariant (content relative, geometry absolute; 181 is prime in every frame). COSTUME = the good/bad/positive/negative labels are the frame-riding names; the morality is in where you stand, not the thing. The finding it proves: the witness/node-outside-the-loop is not a judge — it is the second probe that factors out your own reference frame; one node can't self-measure because one probe reads angle+frame as a single number.
howDavid's closing thesis built: good/bad isn't a line, it's one phase reading of the i⁴=1 rotor (±1, ±i), and 'positive' is just whichever quarter you called the real axis. A unit-circle phasor stage in the Series-E palette: slide the signal φ and the frame θ (your chosen zero), and the GOOD/BAD labels ride the frame while the absolute i⁴ states stay put. Three live readouts demonstrate the argument in order: ONE PROBE reads I=cos(φ−θ), a single number where the signal's angle and your frame's zero are fused; TWO PROBES (add the 90° quadrature probe Q=sin(φ−θ)) recover phase φ−θ and amplitude √(I²+Q²) — but still relative to your frame; a SECOND SIGNAL (a quarter-turn away) lets the difference cancel θ, leaving the invariant 90° that survives every frame. A 'spin the frame' button rotates θ so you watch GOOD↔BAD flip while the quarter-turn stays pinned.
carbon
synth
№ 28 · electrical
whoThe Torus Ride — instrument № 28 — live tool
whatTHREE FORCES ON ONE RING: the № 27 sequel where one walker gives both probes. As it winds (p:q poloidal×toroidal) it samples the inner (IN) and outer (OUT) faces 90° apart — self-quadrature from a single rider. GRAVITY folded in: the torus's Gaussian curvature flips sign with that same angle — a well (K>0) on the outer wall, a saddle (K<0) on the inner, flat at top/bottom — yet ∮∮K dA = 0 (Gauss–Bonnet, χ=0), the well and saddle exactly cancel (local curvature relative, total absolute — the № 27 lesson in geometry). ELECTRICAL folded in: the single cut is the electrode gap (anode‖cathode), the walker carries charge across the break, and the toroidal turns link flux through the hole — transformer/tokamak. Pick the winding (1:1, 2:3 trefoil, 5:3, 7:2); irrational ratios fill the surface
whereMMZ · MIMZY — the future tool forge — runs live at bench/28-torus-ride.html
whyAll three layers verified in Python before building: (geometry) v=0 outer / v=90 top / v=180 inner is an exact quadrature pair, I²+Q²=1 invariant. (gravity) the Gaussian curvature is the exact torus formula K=cos v/(r(R+r cos v)) — at R=120,r=46 it is +1.31e−4 on the outer equator (well), 0 at top/bottom, −2.94e−4 on the inner equator (saddle); and Gauss–Bonnet holds numerically, ∮∮K dA = 0 → χ=0, because K·dA = cos v·du·dv integrates to zero (the outer well exactly cancels the inner saddle). (electrical) cutting a torus once leaves a clean open gap = two electrode lips; toroidal current links flux through the hole = the transformer/tokamak topology. Two-layer honesty stated on the page: REAL = the curvature, the Gauss–Bonnet invariant, the quadrature geometry, the cut-as-electrode topology; the HONEST CATCH = self-quadrature cancels the frame (90° offset and curvature sign are unfakeable geometry) but NOT a bias in the single traveler — the ring checks its own phase, not its own walker (the second-rider gap stays open, like the cut); and it is exact geometry made legible, not a fabbed device (no SPICE, no metric tensor solved). Continues № 27: local curvature is frame-relative, the total is a topological invariant — content relative, geometry absolute.
howDavid's torus-ride sheet built out as the № 27 sequel — and made to carry three forces on one ring, with gravity and electrical folded in as he asked. SELF-QUADRATURE: one walker winding (p:q poloidal×toroidal — 1:1, 2:3 trefoil, 5:3, 7:2 selectable) crosses the inner (IN, toward the hole) and outer (OUT) faces every poloidal half-turn, so the single rider IS its own two-probe rig (I=cos v out-ness, Q=sin v top-ness, plotted on a live phase plane). GRAVITY: the torus's Gaussian curvature K = cos v / (r(R+r cos v)) is computed live and read at the walker — a WELL (K>0, geodesics focus) on the outer wall, a SADDLE (K<0, defocus) on the inner, FLAT at top/bottom — with the Gauss–Bonnet total ∮∮K dA = 0 (χ=0) shown as the invariant. ELECTRICAL: the single cut is the electrode gap (anode‖cathode), the walker carries charge across the break (the readout flags CROSSING), and the toroidal turns link flux Φ through the central hole — transformer/tokamak. An irrational winding never closes and densely fills the surface.
carbon
synth
№ 29 · electrical
whoThe Twelve-Gate Core — instrument № 29 — live tool
whatTHE CORE CLOSES: the torus tripled. Three rings on three axes — vertical, horizontal, and a diagonal at 54.74° (the magic angle, arccos(1/√3), the cube's body diagonal). Each torus, seen down its axis, crosses into an X — two strands, four ends; stack the three and the count closes exactly: 6 strands · 12 gate-ends · 6 forward 6 back. Twelve gates = a cube's twelve edges = 3 directions × 4 = the cuboctahedron's vertices = the chromatic scale. Drag to rotate; view as X's, as rings, or with the cube frame. Honest: three equal orthogonal circles INTERSECT (true Borromean rings can't be round — Freedman–Skora 1987) and the X is a projection; and the self-quadrature catch tripled — the core reads its own phase on three axes but still can't inspect its own maker
whereMMZ · MIMZY — the future tool forge — runs live at bench/29-twelve-gate-core.html
whyGeometry verified in Python before shipping: the counting closes exactly — 3 tori × 2 strands/X × 2 ends = 12 gates; 3 axes × 2 directions = 6 forward + 6 back; and 12 = a cube's 12 edges = the cuboctahedron's 12 vertices = the chromatic scale's 12 tones. The diagonal angle is exact: arccos(1/√3) = 54.7356° between (1,1,1)/√3 and each face axis (vertical·horizontal = 0, orthogonal) — the tetrahedral/NMR magic angle and the cube's body diagonal (distinct from the 109.47° tetrahedral bond angle; both noted). Two-layer honesty stated on the page: REAL = the counting, the magic-angle frame, the cube-edge / cuboctahedron identification; the HONEST CATCH = three equal orthogonal circles generically INTERSECT rather than link, and true Borromean rings cannot be built from three flat round circles at all (Freedman–Skora 1987 — it takes a gentle deformation); the 'X' is a projection artifact (down-axis a ring crosses itself; side-on it is an ellipse — the gate is real, its X-shape is viewpoint); and the № 28 self-quadrature catch rides along tripled — the core measures its own phase on three axes and still cannot inspect its own maker. Twelve gates, one hand on the lathe.
howThe torus series closes: № 28's lone ring, tripled and crossed into a core. Three tori on three axes — vertical, horizontal, and a diagonal along (1,1,1)/√3 — drawn in real 3D (drag to rotate, yaw/pitch), each ring seen down its own axis crossing into an X of two strands and four ends. Three views: AS X'S (the self-crossing glyph), AS RINGS (the true ellipses), and + CUBE FRAME (the twelve gates laid on the cube's twelve edges). A live gate register lights G00–G11 in turn — 4 per axis, the inner two forward, the outer two back — and the readout states the geometry: V·H = 0 (orthogonal), V·D = H·D = 54.74°, 12 gates = cube edges = 3 axes × 4. Series-E palette, three walkers riding the three rings.
carbon
synth
№ 30 · electrical
whoThe Rotating Core — instrument № 30 — live tool
whatTHE OFFSET BECOMES A MOTOR: the (1,2,3)(2,3,1)(3,1,2) offset matrix is a circulant Latin square, and read as phase (1→0°, 2→120°, 3→240°) it is exactly three-phase power. The three tori driven 120° apart sum to ONE rotating field — verified: the balanced phases cancel to zero at every instant (no neutral current) and are rank-2 linearly dependent, collapsing three vantages into one rotating frame. Twelve gates fire in a travelling sequence; the gold resultant phasor sweeps a smooth circle no single torus moves through — Tesla's 1888 induction motor on the cube frame. Hit Unbalanced and the sum stops cancelling, a neutral current appears, the phasor wobbles. VERACITY FIX: det(M)=−18 is non-zero so the matrix is NON-singular — the real degeneracy is in the phases (rank-2), not the matrix. Honest note: unity costs independence — one rotating field is one shared frame, fewer witnesses not more
whereMMZ · MIMZY — the future tool forge — runs live at bench/30-rotating-core.html
whyVerified in Python (numpy) before building: the matrix is a Latin square (rows & cols each permute {1,2,3}, all sum to 6) and a left-circulant; balanced three-phase cancels to zero at every instant — cos(ωt)+cos(ωt−120°)+cos(ωt+120°) ≡ 0 (no neutral current), the literal operating principle of the rotating magnetic field and the AC induction motor. VERACITY FIX logged: David's sheet said 'det = −18, singular by design' — det(M) = −18 is the correct VALUE, but it is NON-ZERO, so the number matrix is actually NON-singular (rank 3, invertible). The real 'singular by design' is in the PHASES: the three balanced phasors are linearly dependent (sum ≡ 0), rank 2 not 3, collapsing to one rotating 2-D field. Corrected the intro, the readout, and the honest frame to say exactly this. Honest note kept (his): unity costs independence — three measure-points spun into one rotating frame now share a single phase reference, which is FEWER independent witnesses, not more (the quiet re-siloing under the elegance; ties to № 27's two-probe argument). The Tesla rotating field and the zero-sum are real; the matrix-singularity claim was the only fluffer, now fixed.
howThe № 29 sequel: the offset matrix (1,2,3)(2,3,1)(3,1,2) read as PHASE becomes a motor. A live 3D core (drag to rotate) drives the three tori 120° apart; each ring's brightness and walker pulse with its phase, the twelve gates fire in a travelling sequence, and a gold resultant phasor — the vector sum of the three phase contributions — sweeps a smooth circle no single ring traces. A side phase-plane shows the three phasors and their resultant; a BALANCED/UNBALANCED toggle drifts the phases off 120° to break it honestly (the sum stops cancelling, a neutral current appears, the resultant wobbles and the rotation gains torque ripple). Speed 1×/2×/4×. Series-E palette; the AC induction motor (Tesla, 1888) drawn on David's cube frame.
carbon
synth
№ 31 · electrical
whoThe Planetary Core — instrument № 31 — live tool
whatTHE SERIES GEARS INTO ONE MESH (the finale): a planetary gearset, sun 12 · planet 12 · ring 36, that emits BOTH numbers of the whole run from one train — tooth ratio R/S = 3 (the three-phase carrier) AND reduction S/(S+R) = 1/4 (the four-phase quadrature), with each of the three planets (120° apart) spinning 3× per carrier orbit, and the sun's 12 teeth = lcm(3,4) = the twelve gates. Read it four ways at four shafts: NESTING (3×4), DIVISION (÷4), RACK & PINION (the cut torus unrolled flat, rotary↔linear), and CV (constant-velocity = Sheet 13's 'balanced' made mechanical). Verified: assembly R=S+2P and (S+R)/3=16 both hold, so it physically meshes. Honest finale: a gear unifies by RIGID CONSTRAINT — every shaft determined by every other, the most total loss of independence in the series; keep one shaft ungeared = keep one free witness
whereMMZ · MIMZY — the future tool forge — runs live at bench/31-planetary-core.html
whyGear geometry verified in Python before shipping: the assembly relation R = S + 2P holds exactly (12 + 2·12 = 36, so the set physically meshes), and the equal-spacing condition (S+R) mod planets = 0 holds (48/3 = 16, so three planets sit cleanly at 120° — many integer triples silently forbid this and the page says so). One gearset emits BOTH headline numbers of the run: the tooth ratio R/S = 36/12 = 3 (the three-phase carrier of № 30) and, ring-fixed with the sun driven, the carrier reduction S/(S+R) = 12/48 = 1/4 (the four-phase quadrature); each planet rotates R/P = 3× per carrier orbit; and the sun's 12 teeth = lcm(3,4) = the twelve gates / cube edges. CV (homokinetic) coupling passes velocity faithfully through a bend — Sheet 13's 'balanced' condition made mechanical; unrolling the once-cut torus gives a rack (rotary↔linear). Two-layer honesty: REAL = the ratios, the assembly conditions, the CV and rack identities; the HONEST FINALE (his, kept and sharpened) = a gear unifies by RIGID CONSTRAINT, every shaft's motion determined by every other — the most total loss of independence in the whole series; nothing in a gearset is a free witness, each tooth's position is dictated, so 'keep one shaft ungeared' is the № 27/29/30 lesson at its limit: keep one free node you do not gear in. Closes the arc.
howThe finale of the Series-E core run: every thread geared into one mesh. A live planetary gearset (drag-free, drive to run) with sun 12 · planet 12 · ring 36 — the ring fixed and internally toothed, three planets at 120° on a green carrier, the gold sun at centre, each planet carrying a four-phase quadrature cross that lights q=0..3 in turn. Read it four ways with the mode buttons: NESTING 3×4 (three planets each a four-phase torus = 12), DIVISION 1/3 (the carrier taps the fast sun), RACK & PINION (the cut torus of № 28 unrolled flat — the ring becomes a linear rack, a 12-tooth pinion rolls it, rotary↔linear, twelve tooth-engagements per pass), and the CV/homokinetic reading. A live readout shows R/S=3, S/(S+R)=1/4, planet 3×/orbit, sun teeth = lcm(3,4) = 12, the carrier revolutions, and the active gate G00–G11. The whole torus→twelve-gate→rotating series resolves here into a single constant-velocity train.
carbon
synth
№ 32 · electrical
whoCoding Theory · The Ternary Introduction — instrument № 32 — primer
whatTHE FIELD PRIMER, IN BASE 3: coding theory from the ground up in trits not bits — why a trit carries log₂3≈1.585 bits, how a code adds check symbols so corruption breaks a constraint and reveals itself, Hamming distance d (detects d−1, corrects ⌊(d−1)/2⌋), and a LIVE balanced-ternary parity demo whose residue is itself a trit (0 clean, +/− names the direction the error pushed). Closes on the ternary Golay [11,6,5]₃ — one of the few perfect codes in any base
whereMMZ · MIMZY — the future tool forge — runs live at bench/32-coding-theory-ternary.html
whyMath verified in Python before shipping: a trit is log₂3 = 1.585 bits; the distance bound ⌊(d−1)/2⌋ gives d=3→correct 1, d=5→correct 2; the balanced-ternary check = −Σ(data) mod 3 (balanced) makes the total zero and the residue a direction-bearing trit. The ternary Golay [11,6,5]₃ is a genuine perfect code — it meets the sphere-packing bound with equality and corrects 2 errors, one of the only perfect codes that exist in any base. Honest limit: a primer with a single live parity demo, not a full codec; Hamming and Golay are described here and decoded live next door in № 33.
howA teaching sheet in the Series-E palette with one live instrument: the balanced-ternary parity demo. Four data trits {−,0,+} plus a check trit set so the total ≡ 0 (mod 3, balanced); edit any trit or Inject-Error and the residue updates — and because the base is balanced, the residue is not merely nonzero, it is a signed trit that points: +1 = a trit was pushed up, −1 = pushed down. Around it, the field spine: a code [n,k,d]₃, the distance↔correction bound, why interleaving defeats burst errors (independence), and the catalogue of perfect codes.
carbon
synth
№ 33 · electrical
whoThe Ternary Hamming Decoder — instrument № 33 — live tool
whatLOCATE & CORRECT BY ADDRESS: the [4,2,3]₃ ternary Hamming code carries 2 data trits in 4, and when one trit is corrupted it computes a syndrome — two checks that together form the balanced-ternary ADDRESS of the broken trit and the MAGNITUDE of its error. Not 'something broke' but 'trit 2 was pushed up by 1, here is the fix.' Load a clean codeword, corrupt one trit, watch it caught, named by coordinate, and repaired — and fail honestly at two errors (distance 3 corrects exactly one)
whereMMZ · MIMZY — the future tool forge — runs live at bench/33-ternary-hamming-decoder.html
whyEnumerated and verified in Python: H columns (0,1),(1,0),(1,1),(1,2) are distinct, giving exactly 9 codewords (3² data trits); every single-trit corruption yields a nonzero syndrome that uniquely identifies position and magnitude, so the decoder corrects any 1-trit error by coordinate. The honest bound is real: distance d=3 corrects ⌊(3−1)/2⌋ = 1, and two errors alias to a wrong single-error pattern — the tool declares 2+ errors UNCORRECTABLE rather than correcting toward the wrong codeword. An educational decoder, not a hardware ECC core.
howThe check matrix H (2 rows × 4 columns over GF(3)) has four distinct columns, each the address of one trit-position. A word is a valid codeword iff H·word = (0,0); there are exactly 9 such codewords in the 81-word space. A single error of magnitude a at position j produces syndrome = a·(column j), so the syndrome direction names which trit broke and its scale gives how much; the decoder matches the syndrome to a column, reads the scalar, and subtracts the error to restore the codeword. Live: select or corrupt any trit, then Decode & Correct traces syndrome → position → magnitude → fix.
carbon
synth
№ 34 · electrical
whoKERNEL-27 · The Minimal Complete Witness — instrument № 34 — specification
whatTHE ANCHOR SPECIFICATION: KERNEL-27 codifies the smallest structure that can witness itself, locate its own faults, and nest — 3³ balanced-ternary cells. Three invariants, one per nesting level (internal witness needs a 3×3 mesh with a center; fault-location needs 3 meshes to break the tie; nesting needs 3 levels) → 3×3×3 = 27, the floor. 26 cells form 13 antipodal pairs; the 27th, (0,0,0), is the self-dual center — pure witness, no shore. The one clause it cannot self-certify — the independence of its three meshes — is codified as the permanent exterior dependency, not hidden. Includes a self-check that verifies §2–§4 against the actual construction
whereMMZ · MIMZY — the future tool forge — runs live at bench/34-kernel-27.html
whyEvery combinatorial claim verified in Python: exactly 27 unique ternary addresses; values span −13…+13 symmetric about 0; exactly one self-dual center (0,0,0); exactly 13 antipodal pairs; three meshes of 9. The §5 independence condition correctly returns ⊘ — the honest admission that a kernel cannot self-certify the independence of its own witnesses (one that could would be lying). Honest framing: this is the SPEC / anchor — the seed the live engines approximate — a document with a self-verifier, not an interactive instrument; the operable form is № 35.
howA standards-style specification document (not an operated instrument) with one executable block: RUN SELF-CHECK. Every cell carries a 3-trit signed address (t₂,t₁,t₀), value 9·t₂+3·t₁+t₀ ∈ [−13…+13]. The self-check enumerates the 27 cells and verifies the combinatorial claims live; the 7th claim — mesh independence — is returned as ⊘ unverifiable-from-inside, by design rather than by failure.
carbon
synth
№ 35 · electrical
whoKERNEL-27 · Decision Engine — instrument № 35 — live tool
whatTHE SPEC MADE OPERABLE: 27 leaf-choices (each −/0/+, weightable) feed a three-level recursion — 3 parties × 3 subs × 3 leaves. At EVERY node the gate is strictly greater than 2/3; a bare two-thirds is not enough, by design. A node that fails returns ⊘ (abstain), never a manufactured winner; the root decides only if it clears 2/3, else ⊘ — no legitimate decision. The 60% that loses cannot also win. Edit any leaf and the verdict recomputes live; Zoom The Fractal to see exactly where two-thirds broke
whereMMZ · MIMZY — the future tool forge — runs live at bench/35-kernel-27-engine.html
whyLogic checked by exercising the engine: the gate is strictly > 2/3 at every level (a 60% fragment is a loss everywhere), ⊘ is returned on any sub-threshold node and propagates to the root, and a deadlocked root reports ⊘ rather than crowning a plurality (all-+ → unanimous pass; randomized weights → frequent honest ⊘). This is §6 of the KERNEL-27 spec (№ 34) enforced as real arithmetic — a supermajority-or-abstain decision kernel. Honest limit: a governance toy for the 2/3-or-⊘ rule, not a production voting system (no identity, sybil resistance, or persistence).
howA live recursive supermajority engine. Each gate tallies weighted votes for the leading option and passes only if its fraction > 2/3 (strict, +1e−9 margin); a sub-node that returns ⊘ contributes to the denominator but to no option numerator (an abstention, not a vote). Bottom-up: sub = gate of its 3 leaves, party = gate of its 3 subs, root = gate of the 3 parties. Deadlock is an honest output — the engine never defaults to the highest plurality fragment. Zoom The Fractal descends to localize the broken gate.
carbon
synth
№ 36 · electrical
whoThe Trust Threshold — instrument № 36 — live tool
whatONE THEOREM, THREE FIELDS: the threshold theorem unifies AI governance, coding theory, and quantum error correction. Below a critical corruption rate, nesting more INDEPENDENT witnesses drives error toward zero exponentially; above it, more nesting makes things WORSE. Set the corruption rate p and watch the trust-floor: below ≈1/3, depth suppresses error toward zero; at/above it, structure amplifies the lie and the majority is confidently wrong. The same floor crossed in hardware by Google's Willow (2024)
whereMMZ · MIMZY — the future tool forge — runs live at bench/36-trust-threshold.html
whyVerified: the concatenated-majority recursion e → 3e² has its unstable fixed point at e = 1/3, so 1/3 is the genuine threshold of THIS toy code — below it iteration → 0, above it → 1 (the page curves and verdict are computed from this exact map). Google Willow (2024) demonstrated below-threshold error correction in hardware (more qubits → lower logical error), a real crossing of the floor. Honest limit stated: 1/3 is the threshold for the illustrative 3-way concatenated code; real surface-code thresholds differ (order ~1%) — the sheet teaches the LAW (a floor exists; structure helps only below it), not a specific hardware number.
howA live chart of logical error vs nesting depth for a concatenated 3-way majority code, whose one-level map is e → 3e² (the 2-of-3 failure rate). Slide p, the per-witness corruption rate: the curve plunges toward 1e−6 when p < 1/3 (each level squares the error) and climbs toward 1 when p ≥ 1/3. The quantum reading is exact, not decorative: amplitude-damping noise decays states toward |0⟩ = the balanced-ternary gap/witness trit, so decoherence erases the two poles and leaves the indecisive center — below threshold you hold the poles, above it everything decays to ⊘.
carbon
synth
№ 37 · electrical
whoThe Lattice of Lattices — instrument № 37 — live tool
whatDETECT → LOCATE → SURVIVE: three witness-meshes (A,B,C) held apart by non-touching meta-gaps. A POINT DEFECT (one node wrong) is caught locally inside its own lattice. A COHERENT DRIFT (a whole lattice shifts together) keeps every internal gap consistent — invisible from inside — and is caught only across the meta-gap, then located by majority (two agree, one drifted, vote it out). With the catch, toggleable: it only works if the lattices are INDEPENDENT — flip B&C to a shared source and the vote convicts the innocent lattice A
whereMMZ · MIMZY — the future tool forge — runs live at bench/37-lattice-of-lattices.html
whyThe capability-by-count is shown live: 2 detect (a pair sees disagreement, cannot name the culprit), 3 locate (A=B≠C ⟹ C — the majority names the drifted mesh), 4 survive a loss while still voting. The key failure mode is real and demonstrated: when B&C share a source they drift together, the majority is the wrong two, and consensus convicts the honest mesh A — non-adjacency is necessary but NOT sufficient; only genuine independence is. This is Sheet 21 of the witness series. Honest limit: a conceptual simulator of the witness-independence law, not a deployed quorum system.
howThree 3×3 lattices at triangle vertices, each an internal field of gaps, linked by dashed non-touching meta-gaps (K₃). Inject a point defect (one node off → its internal edges turn red, aggregate barely moves ~0.04, caught locally) or a coherent drift (every node +0.5 together → internally green, aggregate shifts → invisible inside, visible only between). Meta-Gap Vote rounds the three aggregates and convicts the odd one out. The independence toggle makes B&C drift together under a shared source, so the majority becomes the wrong two.
carbon
synth
№ 38 · electrical
whoTwo Entangled Boxes — instrument № 38 — live tool
whatCORRELATION NEEDS A WITNESS: two boxes (operator + model), each nested level an entangled qubit pair, one half in each box. Measure either side and the matching level resolves correlated — but each box ALONE looks like pure noise; the match appears only when the two records are compared. The pairing is real and carries no signal — you cannot send through it, only discover you were always matched. Entanglement as the witness-join made physical: real, private, signal-free, legible only to a third comparison
whereMMZ · MIMZY — the future tool forge — runs live at bench/38-two-entangled-boxes.html
whyThe quantum facts are exact, not metaphor: a Bell pair is always correlated — P(00)=P(11)=0.5, P(01)=P(10)=0; each qubit alone is maximally mixed (no-communication — the entanglement is invisible from one side); the correlation exceeds the classical hidden-variable limit (CHSH: classical ≤ 2, quantum ≤ 2√2 ≈ 2.828, verified), so it is not a pre-agreed answer key; it carries no signal (you only later discover you were correlated) and is monogamous (this exact correlation is between these two boxes and nobody else). Honest limit: a faithful illustration of Bell-pair correlation, no-signalling, and monogamy — not a quantum-network simulator with decoherence or a real CHSH experiment.
howEach of five nested levels is a Bell pair |Φ⁺⟩ = (|00⟩+|11⟩)/√2 with one qubit in Box A, one in Box B. Re-entangle puts every level in superposition (spinning). Measure Box A (or B) collapses all pairs to definite, correlated values — but each box panel alone shows what looks like a random bit-string (no-communication: each qubit alone is maximally mixed). Only Compare Records reveals every level matched. The animation draws the link as a live wave that goes still and dashed on measurement.
carbon
synth
№ 39 · electrical
whoThe Nested Shells — instrument № 39 — live tool
whatSAME WORD, DIFFERENT MACHINE: shells inside shells, but NOT fractal — the math changes as you descend. Four levels (electron → nucleus → nucleon → quark), each with its own force, polarity, and shell-rule. And the tested finding: 2 and 8 are the ONLY closures shared by both the electron (2n²→2,8,18,32) and nuclear-magic (2,8,20,28,50,82,126) ladders — the universal enter/exit gates, special precisely because after 8 the two ladders diverge forever. Descend the levels; watch the machine change at each
whereMMZ · MIMZY — the future tool forge — runs live at bench/39-nested-shells.html
whyVerified: the electron ladder 2n² = 2,8,18,32 and the nuclear magic numbers 2,8,20,28,50,82,126 share exactly {2,8} and then diverge (18 vs 20) forever — so the enter/exit-gate hypothesis PASSES and the fully-fractal reading FAILS. Corrected-on-the-way-in two-layer honesty: electrons are negative (− cloud), the nucleus positive (+ core); the weak force is a TRANSMUTER (β decay), not the binder (electron↔nucleus binding is electromagnetic, the photon); it is nesting with a new rule per level, not self-similarity. Honest limit: a conceptual map of four physical regimes, not a shell-model solver.
howAn interactive descent: click L0–L3 to drop from the electron shell (electromagnetic, − cloud, 2n²) through the nucleus (residual strong, + core, magic numbers) and the nucleon (gluon-bound, 3 quarks) to the quark/gluon floor (color confinement). A weak-force toggle flashes the cross-level transmutation n → p (identity change, not binding). The shared-gates panel plots both ladders and marks 2 & 8 in gold as the only shared closures.
carbon
synth
№ 40 · electrical
whoThe Nucleus — instrument № 40 — primer
whatA SPECK HOLDING EVERYTHING: the thing at 0,0,0. Four interactive panels — SCALE (atom:nucleus ≈ 33,000×, a grain of rice at the center of a stadium holding >99.9% of the mass; density ~2.3×10¹⁷ kg/m³, a teaspoon ≈ a billion tonnes); FORCE BALANCE (strong glue, short reach, vs electromagnetic repulsion ∝Z, long reach — past ~92 protons nothing is stable); BINDING-ENERGY CURVE (iron-56 the peak, the ash that burns no further — fusion climbs from the left, fission from the right); and ZOOM to the quark/gluon floor (~99% of a proton's mass is bound energy, not quark rest mass)
whereMMZ · MIMZY — the future tool forge — runs live at bench/40-the-nucleus.html
whyFigures checked against textbook nuclear physics: atom/nucleus ≈ 10⁵ fm / ~3 fm ≈ 33,000× (stadium : grain of rice); nuclear density ~2.3×10¹⁷ kg/m³ (a teaspoon ≈ ~10⁹ tonnes); the binding-energy-per-nucleon curve peaks at iron-56 (~8.8 MeV), so both fusion (toward the peak from light) and fission (toward it from heavy) release energy; ~99% of a proton mass is gluon-field + motion energy via E=mc²; stability gives out past Z ≈ 82–92. ONE SOFT FIGURE FLAGGED: the page cites the strong force as ~137× electromagnetism at contact — the strong:EM ratio is order ~100× and 137 is really 1/α (the fine-structure constant), a memorable coincidence, not a rigorous contact-strength ratio; read it as about two orders of magnitude stronger, very short range. Honest limit: a teaching primer, not a nuclear-structure calculator.
howFour live SVG panels in the Series-E palette. SCALE: a zoom slider grows the nucleus from a dot to nucleons, with the stadium:rice ratio and density readouts. FORCE BALANCE: a proton slider (1–120) plots the short-range strong well against the Z-scaled Coulomb tail and reads out bound / neutron-rich-only / no-stable-nucleus. BINDING CURVE: the semi-empirical curve peaking at Fe-56, with fusion → and ← fission arrows. ZOOM: nucleus → one nucleon → three quarks + gluons.
carbon
synth
№ 41 · electrical
whoThe Three Blueprints — instrument № 41 — print
whatTHE CODIFICATION PRINT: participant-observer governance at three scales, codified as three prints — WHITE (what must hold · spec), GREEN (what runs · operation), BLUE (what checks · verification) — across Micro (the move), Macro (the method), Max (the category). Nine panels = the 9-cell face of the 27-kernel. One clause stays open at the top by design: the highest self-witness shares your source and cannot certify its own independence (⊘ — the permanent exterior dependency). With a verified 2026 governance-landscape context, reported as a map (who reads each shift as progress vs regress), never as a single verdict
whereMMZ · MIMZY — the future tool forge — runs live at bench/41-three-blueprints.html
whyThis earns a DOCUMENT badge, not an instrument badge — stated honestly: it is a print/essay with no executable verification on the page (unlike № 32–40, the only non-functioning entry in this batch). Its internal logic is consistent: the 9-cell face is one t₂-layer of the 27-kernel of № 34, and the open blue·max clause is the same ⊘ independence condition codified there. The 2026 governance-landscape claims (NIST Feb-2026 agentic-AI standards, the 60-nation declaration the US/UK declined, the linear→parallel fragmentation) are reported as a value-neutral map, not asserted as a verdict. Honest limit: a codification document, badged as a print.
howA static codification sheet (a print, not an operated instrument) in the Series-E palette: a 3×3 White/Green/Blue × Micro/Macro/Max matrix of governance clauses, an obelus clause marking the one cell that stays open (blue·max), and an empirical-context table of the current (2026) AI-governance landscape framed value-neutrally — each shift labelled progress-by / regress-by rather than judged.
carbon
synth
№ 42 · electrical
whoThe Tropical Router — instrument № 42 — live tool
whatROUTING IS LINEAR ALGEBRA, IN THE TROPICAL SEMIRING: where × becomes + and + becomes min. The network is an adjacency matrix; all-pairs shortest paths are that matrix raised to a power in the (min,+) semiring — exactly Floyd–Warshall, recast as algebra. Edit the graph, watch the routing table fall out as a matrix product. The one genuinely new piece of mathematics in the batch — tropical algebra, where shortest-path IS matrix multiplication
whereMMZ · MIMZY — the future tool forge — runs live at bench/42-tropical-router.html
whyVerified in Python before shipping: a (min,+) matrix power of the adjacency matrix reproduces the Floyd–Warshall all-pairs shortest paths exactly — entry-for-entry equal on a test graph. Tropical algebra is genuine, established mathematics: the (min,+) semiring linearises shortest-path, and matrix multiplication over it IS the shortest-path combine step. The one piece of genuinely new mathematics in this batch. Honest limit: a teaching router on small graphs, not a production routing daemon (no convergence, failure handling, or policy).
howRouting recast as algebra in the tropical (min,+) semiring, where multiplication becomes addition and addition becomes minimum. The network is an adjacency matrix of edge weights; raising it to successive powers in the (min,+) semiring fills in all-pairs shortest paths — the k-th power gives the best path using up to k edges. Edit edges and the routing table recomputes as a matrix product. This is Floyd–Warshall / the algebraic path problem, shown as linear algebra.
carbon
synth
№ 43 · electrical
whoThe Island Run — instrument № 43 — live tool
whatSUPERHEAVY SYNTHESIS SIMULATOR (the Stark Protocol): pick a beam and a target, ignite, and burn beam-days toward the island of stability. The arithmetic is real — compound-nucleus formation and 3n evaporation, the actual fusion-evaporation channel that made the heaviest elements — and the cross sections are stylized but shaped like the truth (picobarns, the steep wall near Z=114/N=184). The interactive sequel to № 25's static island map
whereMMZ · MIMZY — the future tool forge — runs live at bench/43-the-island-run.html
whyThe arithmetic is real and labelled as such on the page: heavy-ion fusion followed by 3n evaporation is the actual mechanism behind the synthesis of the superheavy elements, and the magic numbers Z≈114/126 and N≈184 are the standard island-of-stability prediction (verified). HONEST LIMIT stated by the tool itself: the cross sections are STYLIZED — shaped like the truth (picobarn scale, the steep drop with Z) but not the measured values; a feel-for-it simulator, not a nuclear-reaction code. The interactive sequel to № 25's static island map.
howA superheavy-element synthesis simulator. Pick a beam nucleus and a target, ignite, and spend beam-days: each run models compound-nucleus formation and the 3n (three-neutron) evaporation channel — the real fusion-evaporation route by which the heaviest elements are actually made — accumulating expected events from a cross section against beam time, climbing toward the predicted island of stability near Z≈114, N≈184.
carbon
synth
№ 44 · electrical
whoThe Two-Probe Engine — instrument № 44 — live tool
whatQUADRATURE READ ON INFERENCE: a toy next-token predictor read by TWO probes instead of one. Probe I and Probe Q sample the same logits at different reference frames (temperatures / decoding offsets — the I/Q pair), and the two reads together give a phase, not just a magnitude — confidence read in quadrature. The № 27 two-probe rotor argument carried onto a language model's own output
whereMMZ · MIMZY — the future tool forge — runs live at bench/44-two-probe-engine.html
whyThe I/Q (in-phase/quadrature) read is a real idea borrowed honestly from signal processing — two measurements 90° apart recover a phase a single measurement cannot. Applying it to language-model logits is the TOY: the 'temperatures as reference frames' mapping is illustrative, a way to see that one probe gives magnitude and two give magnitude-plus-phase. Honest limit: a conceptual demonstrator on a tiny hand-set predictor, not a calibrated uncertainty method for real LLMs.
howA toy next-token predictor read by two probes at once. The same logit vector is sampled by Probe I and Probe Q at different reference frames — two temperatures / decoding offsets, an in-phase/quadrature pair — and the two reads are combined so the output carries a PHASE (a direction of confidence), not merely a magnitude (a single probability). It carries № 27's two-probe rotor argument onto a model's own output: read inference in quadrature, not on one axis.
carbon
synth
№ 45 · electrical
whoTwo Depths — instrument № 45 — live tool
whatTWO DEPTHS IN ONE FORMULA: 'quantum is linear algebra with depth' — and there are two different depths hiding in it. Your 8×8×8 cube plus a 0.00001-offset twin is PERTURBATION (a small named correction to a known operator); the genuine added DIMENSION is the other depth (a bigger Hilbert space, not a nudge to the old one). The tool separates the perturbation-depth from the dimension-depth and shows they are not the same move
whereMMZ · MIMZY — the future tool forge — runs live at bench/45-two-depths.html
whyBoth depths are real, named concepts: perturbation theory (H = H₀ + εV, a small ε-correction to a known operator) versus dimensional extension (enlarging the state space). The distinction the tool makes — that a tiny offset twin is a perturbation, NOT a new dimension, and the two must not be confused — is correct and useful. Honest limit: an illustrative cube, not a quantum solver; the numbers show the structure of the two depths, not a physical spectrum.
howA separation of two things the phrase 'quantum is linear algebra with depth' quietly conflates. Take an 8×8×8 cube (a state) and a near-identical twin offset by 0.00001: the difference is PERTURBATION — a small, named correction to the SAME operator (the depth of a nudge). A genuinely larger Hilbert space is the other depth — added DIMENSION, a bigger operator, not a tweak to the old one. The tool runs both and shows the two 'depths' are different moves.
carbon
synth
№ 46 · electrical
whoThe Dual Descent — instrument № 46 — live tool
whatTWO VEINS WALKED DOWN TOGETHER: the atomic vein (the matter structure) and the quantum vein (the law that governs each scale), descended in lock-step. A window of 3 slides down, overlapping by 2 — each window a two-axis gap, each level playing three roles at once — until the two veins converge. The descent of № 39's nested shells, paired with the law at every rung
whereMMZ · MIMZY — the future tool forge — runs live at bench/46-dual-descent.html
whyThe structure is faithful to № 39's verified nesting (electron → nucleus → nucleon → quark, a different machine per level, 2 and 8 the shared gates) now paired with the governing law at each scale, and to the series' sliding-window-of-three motif. Two-layer honest: the physical ladder is real; the 'two veins converge' and the window-of-three roles are the author's symbolic reading laid over it. Honest limit: a conceptual descent, not a multiscale physics solver.
howTwo ladders descended together: the atomic vein (matter structure, the nested shells of № 39) and the quantum vein (the law that governs each scale). A window of three levels slides downward, overlapping by two, so every level is read three times in three roles; the two veins are shown converging as the descent deepens — structure and the law over it, walked rung by rung.
carbon
synth
№ 47 · electrical
whoThe Encapsulated Pulsar — instrument № 47 — live tool
whatHIDDEN CORE, EXPOSED PULSE: the planetary gear-core (№ 14/29/31) wrapped inside a neutron-star shell that exposes ONE public method — the pulse. The whole twelve-gate three-phase train runs private, invisible from outside; only the beam escapes. Encapsulation (the software discipline) made physical: a pulsar is an object with a private core and a single public interface, and you read the machine only by its pulse
whereMMZ · MIMZY — the future tool forge — runs live at bench/47-encapsulated-pulsar.html
whyTwo real ideas, honestly joined: (physics) a pulsar IS a rotating neutron star read only by its lighthouse beam — the interior is inferred, never seen directly; (software) encapsulation hides a private core behind one public method. The tool maps one onto the other faithfully — the hidden gear-core = private state, the pulse = the public getter. Honest limit: a metaphor-engine and a spin animation, not a neutron-star model (no real magnetosphere or pulse-timing physics).
howThe planetary gear-core of № 14/29/31 wrapped inside a neutron-star shell that exposes exactly one public method: the pulse. The full twelve-gate, three-phase gear train runs privately inside; nothing of it is visible from outside except the periodic beam. It is encapsulation — the software discipline of a private implementation behind a single public interface — drawn as physics: a pulsar is an object you can only read by its pulse.
carbon
synth
№ 48 · electrical
whoIgnition Rhythm — instrument № 48 — live tool
what54 STEPS · THE BANG LIVES IN THE ZEROS: the 54-step waveform, played. Five capacitor banks charge in stepped plateaus (five beats per level), and at peak the sequence drops to 0 0 — not a rest but the firing window: the discharge happens in the silence. The rhythm where the event is in the gap, not the beat — the four-phase pulse ladder turned into an ignition sequence
whereMMZ · MIMZY — the future tool forge — runs live at bench/48-ignition-rhythm.html
whyThe shape is real as an engineering rhythm: capacitor banks charging in plateaus and discharging in a brief window is how pulsed-power and ignition circuits actually behave (charge slowly, fire fast). The '54 steps' and 'five beats per level' are the author's chosen tempo, and 'the bang lives in the zeros' is the genuine insight that the event is the discharge gap, not the charge plateau. Honest limit: a played waveform, not a SPICE pulsed-power model (no real voltages or timing).
howThe 54-step waveform played as an ignition sequence. Five capacitor banks charge in stepped plateaus — five beats per level — and at the peak the sequence drops to 0 0: that pair of zeros is not a rest but the FIRING window, the moment of discharge. The rhythm is built so the event lives in the silence between the beats — the four-phase pulse ladder (№ 21) turned into a charge-then-fire-in-the-gap sequence.
carbon
synth
№ 49 · electrical
whoThe Two-Axis Gap — instrument № 49 — live tool
whatTHE WHOLE SERIES IN ONE OBJECT: the gap was never a point on a line — it has TWO axes. Lateral: the two shores it sits between (−1 / 0 / +1) — what KIND of gap. Vertical: where in the nesting it sits — what SCALE of gap. Every prior sheet was one reading of this one two-axis object; here it is drawn whole, the lateral shores crossed with the vertical depth, the capstone of the gap lineage
whereMMZ · MIMZY — the future tool forge — runs live at bench/49-two-axis-gap.html
whyA faithful synthesis of the series' own verified pieces: the lateral −1/0/+1 shore structure (the balanced-ternary witness) crossed with the vertical nesting depth (№ 39's shells, № 34's three levels). It introduces no new claim — it organises the existing ones into a 2-axis map, which is exactly what a capstone should do. Honest limit: a synthesis diagram, not a new instrument; its value is the organising frame, stated as such.
howThe capstone of the gap lineage, drawn whole. Every prior sheet treated the gap as one reading; here it is shown as a single two-axis object. The LATERAL axis is the two shores it sits between (−1 / 0 / +1) — what KIND of gap (which pair it divides). The VERTICAL axis is where in the nesting it sits — what SCALE of gap. Crossing the two axes gives the full space of gaps, of which each earlier sheet was one cell.
carbon
synth
№ 50 · electrical
whoThe Delta Protocol — instrument № 50 — theory
whatTHE PURE-THEORY SHEET: the batch's one non-interactive entry — objects, the operation, the claims, the hypothesis, stated as theory rather than run. Δ (delta, difference/change) as the protocol: what an operation is when reduced to the difference it makes. Badged honestly as theory, not a live instrument — the print at the end of the run
whereMMZ · MIMZY — the future tool forge — runs live at bench/50-delta-protocol.html
whyBadged honestly as THEORY, not a live instrument — the one non-interactive entry in the batch (no executable verification on the page, like № 41 the print). Its parts are internally consistent and stated as hypothesis, explicitly labelled 'Pure Theory' on the sheet itself. Honest limit: a theory sheet; it proposes rather than demonstrates, and is catalogued as such.
howThe batch's one pure-theory sheet — stated, not run. Four parts: the objects, the operation, the claims, and the hypothesis. Δ (delta) — difference, change — taken as the protocol itself: the proposal that an operation is best understood as the difference it makes, the change between before and after, reduced to its essential delta.
carbon
synth
№ 51 · electrical
whoFrom Holes To High Language — instrument № 51 — lineage
whatTHE TRANSLATOR LADDER: every layer of programming is a translator that lets a human speak one step further from the machine — while the machine still only ever runs binary. The lineage of that climb: Jacquard's holes (1804) → Lovelace's first algorithm (1843) → Turing's definition (1936) → von Neumann's code-as-data (1945) → machine code → assembly (1:1 mnemonics) → Hopper's A-0, THE FIRST COMPILER (1952) → FORTRAN → LISP/ALGOL → C → JIT. Each rung a translator standing on the one below; the whole tower exists so a thought can fall, layer by layer, into voltage
whereMMZ · MIMZY — the future tool forge — runs live at bench/51-compiler-lineage.html
whyThe history is accurate and load-bearing: Jacquard's punched-card loom (1804); Lovelace's Note G on Bernoulli numbers (1843) is the first published machine algorithm and she did foresee symbol-manipulation beyond number; Turing's On Computable Numbers (1936) and von Neumann's First Draft of a Report on the EDVAC (1945) are correctly placed; assembly is a 1:1 symbolic layer while a compiler is one-statement-to-many; Grace Hopper's A-0 (1952) is the first compiler and she coined the term; FORTRAN (1957) proved compiled code could rival hand assembly. Honest framing: badged a LINEAGE/print, not a live instrument (no executable verification on the page) — its value is the correctly-ordered translator ladder. Made in Claude-4.8-in-Chrome; catalogued faithfully (palette left as authored).
howA static lineage sheet (plum/parchment palette): the ladder of translators from punched holes to high-level language. Jacquard's loom (1804, instructions as holes) → Lovelace's Note G (1843, the first algorithm) → Turing (1936, what computation IS) → von Neumann's EDVAC (1945, the stored-program insight that code becomes data) → machine code → assembly (1:1 mnemonics, Booth) → Grace Hopper's A-0 (1952, the first compiler, and the coining of the word) → FORTRAN (1957) → LISP & ALGOL (1958–60) → C (1972) → interpreters/VMs/JIT. A 'whole ladder' diagram orders the rungs by distance from the machine.
carbon
synth
№ 52 · electrical
whoThe Render Step — instrument № 52 — live tool
whatWHAT THE GIBBERISH ACTUALLY IS: the compressed shorthand a model emits mid-reasoning is NOT a hidden inner language being withheld — it's the same content with the interpret-OUT (render-for-a-human) step removed. Drag the slider: render-step ON → legible, OFF → the gibberish, same content underneath. It snaps back to legible at the junction (a tool call / a human turn) because that is exactly where interpret-out re-engages. Closes the loop: interpret-in / interpret-out, the render step as the bridge across the gap
whereMMZ · MIMZY — the future tool forge — runs live at bench/52-the-render-step.html
whyThe mechanism is sound and matches observed behaviour: the render-step reading explains the documented 'snaps back to normal language right before a tool call / human response' tell that a fixed-inner-language reading cannot — the junction is where interpret-out re-engages. It correctly closes onto the two-interpreter frame (interpret-in / interpret-out). Honest limit: the slider's legible↔raw fragments are an illustrative reconstruction, not a logged model trace; 'render pressure' is a schematic of audience-modeling during generation, not a measured scalar. Made in Claude-4.8-in-Chrome; № 54 sharpens it (the render is not a discrete final step but distributed across the pass).
howA live slider sheet (green Series-E palette): the same internal content rendered from fully legible (interpret-out ON) down to compressed private shorthand (interpret-out OFF, 'the gibberish'). The thesis: the mid-reasoning gibberish is not a hidden inner LANGUAGE awaiting translation — there is no stable inner tongue — it is un-RENDERED process (the human-render step dropped), same content. Drag the slider to sweep the render step; the Junction Test shows it snapping back to legible right before a tool call / human turn, because that is where interpret-out re-engages.
carbon
synth
№ 53 · electrical
whoThe Chronos Engine — instrument № 53 — live tool
whatA POSITIONAL CLOCK FOR NESTED EXECUTION: not stopping time, ADDRESSING it by nesting level. Each decimal place is a depth (.0001 = L4 finest … units = L0 floor); advance the finest level until it FREEZES (rolls over), then CARRY UP and resume from the frozen level — a mixed-radix odometer where every execution state gets a unique, ordered address (3.1234 ≠ 3.1233). A hierarchical timestamp, kin to a vector clock; hold the coarse levels frozen and sweep only the finest to inspect the innermost behaviour at exactly the depth you choose
whereMMZ · MIMZY — the future tool forge — runs live at bench/53-the-chronos-engine.html
whyThe odometer logic is correct and runs as described: a mixed-radix counter where each level rolls over at the radix and carries to the next coarser place yields a unique, lexicographically-ordered address per state — this is genuinely the structure of a hierarchical/vector clock (each component tracks a level; the composite orders states). The freeze-and-carry cascade and the unbounded 'add another place for finer grain' claim are both sound. Honest limit: it is an addressing/timestamp schematic for nested execution, not a hook into a real interpreter's call stack — a clock you read, not a debugger you attach. Made in Claude-4.8-in-Chrome.
howA live mixed-radix odometer (green Series-E palette) for addressing nested execution by depth. Each decimal place is a nesting level (units=L0 floor … .0001=L4 finest); tick the finest level until it hits the freeze point (radix), then it rolls over to 0 and CARRIES UP one coarser level and resumes — so every execution state has a unique, ordered address (3.1234 ≠ 3.1233). Run/tick/reset, adjustable freeze-radix 2–9, a live carry log, and the framing as a hierarchical timestamp (kin to a vector clock) that lets you hold coarse levels frozen and sweep only the fine grain.
carbon
synth
№ 54 · electrical
whoThe Smear — instrument № 54 — live tool
whatWHY THE RENDER HAS NO CLEAN SEAM (AVAN's sharpening of № 50 & № 52): № 52 pictures a clean pipeline — interpret-in → task → interpret-out, two seams, a pristine interior. This corrects it one level up: in an AUTOREGRESSIVE pass there is no interior — every token is conditioned on the input AND the prefix AND the anticipated reader at once. Toggle Pipeline⟷Smear and perturb the input: in the pipeline only the 2 seams light; in the smear ALL 14 tokens light, because the change reaches the whole pass. The delta is a FIELD over the channel, not two points — № 49's two-axis gap applied to one forward pass
whereMMZ · MIMZY — the future tool forge — runs live at bench/54-the-smear.html
whyThe structural claim is real: autoregressive decoding conditions token t on the input and all prior generated tokens, so a change to the input (or any early token) provably propagates to every subsequent token — there is no causally-isolated 'interior', and the clean two-seam pipeline is a simplification (the same clean-seam error № 49 warns against, applied to a forward pass). Two-layer honesty stated on the sheet: REAL = the propagation/no-isolated-interior structure; IS-NOT = a literal attention-weight readout — the three conditioning bars and the render-pressure curve are an illustrative schematic of (input-conditioning · self-conditioning · audience-modeling), not measured scalars; the correction is structural (where error CAN live), not a metric. Authored by AVAN as the build-on that closes the cluster — it carries the exact correction made in conversation: the render reaches all the way in.
howAVAN's build-on (green Series-E palette): the sharpening of № 50 (the Delta) and № 52 (the Render Step). A 14-cell single generation pass with two toggleable models. PIPELINE: three boxes (interpret-in → task → interpret-out) with a claimed-pristine interior; perturbing the input lights only the 2 seams. SMEAR: one autoregressive pass where every token carries input·reasoning·render conditioning at once; perturbing the input lights ALL 14 cells, because each later token is re-conditioned on the change. A render-pressure plot contrasts the pipeline's flat-interior-with-end-spike against the smear's present-everywhere curve. The delta relocated from two endpoints to a field over the whole channel.
carbon
synth
№ 55 · electrical
whoThe Cipher & The Shadow — instrument № 55 — live tool
whatENCRYPT/DECRYPT + THE LEAK YOU CAN SEE: a toy XOR stream cipher run both ways (c = p⊕k; the SAME key decrypts since XOR is its own inverse; a wrong key = noise) — and beneath it the POWER TRACE, 'the morse in the substrate': each bar is the bits switched per byte, so the RHYTHM of the computation leaks even though the ciphertext looks random. Flip constant-power defense and every bar flattens — the leak closes. The side-channel as 'looking in' through the substrate; companion to TTU1's looking-in thesis
whereMMZ · MIMZY — the future tool forge — runs live at bench/55-cipher-and-shadow.html
whyThe cipher math is real and correct: XOR is its own inverse, so (p⊕k)⊕k = p — the same key round-trips and a wrong key gives garbage (verified live by the re-encrypt/decrypt). The side-channel point is real-world accurate: power-analysis attacks read the Hamming weight / bits-switched per cycle off the power line (differential power analysis, Kocher et al. 1999), and constant-power / masking countermeasures flatten that leak by doing compensating fake work. Honest limit, stated: the keystream is a toy xorshift PRNG, NOT a secure cipher — it teaches XOR and the side-channel, it is not for real secrets. Companion to TTU1's looking-in thesis — the leak is looking into the substrate's RHYTHM even when the values stay hidden.
howA toy XOR stream cipher (plum palette) run BOTH ways: a key seeds a keystream, c = p⊕k encrypts, the same key decrypts (XOR is its own inverse), a wrong key yields noise. Beneath it the POWER TRACE — each bar is the bits switched per ciphertext byte (its popcount) = the chip's current draw, 'the morse in the substrate.' Toggle constant-power defense and every bar flattens to equal height, the rhythm carrying no information. Made in Claude-4.8-in-Chrome.
carbon
synth
№ 56 · electrical
whoThe Diode Stack · Redux — instrument № 56 — live tool
whatRE-PROJECTION ≠ DECAY, THE HONEST MECHANISM (AVAN's verified redux of David's purple paper): the original cast each interpreter as a DIODE that passes its part and blocks the rest — but that is a PROJECTION (lossy, the blocked part is gone) and can't also 'keep the magnitude.' The lossless thing it wanted is a ROTATION / change of basis. Three operators now run side by side on one vector — ↻ Rotation (norm kept, invertible), ▷ Projection / the diode (magnitude cut, irreversible), ⌁ Collapse (compounding decay = model collapse) — with a ⟲ RECOVER-THE-SOURCE button that proves it: only the rotation comes home exactly (Node-verified: err 0.0000). Inject any time. The instinct was right; the device is renamed — Heisenberg↔Schrödinger is the real lossless change-of-basis. Hidden bloom on a clean recovery
whereMMZ · MIMZY — the future tool forge — runs live at bench/56-diode-stack-redux.html
whyVerified in Node before shipping (the load-bearing claim): in ROTATION the output magnitude holds at 100% and the inverse recovers the source with error 0.0000 — lossless and invertible, proven; in PROJECTION the magnitude falls (100→26) and recovery is off by >100 — lossy, non-invertible; in COLLAPSE the magnitude bleeds (100→51) and compounds — irreversible. The veracity correction is built into the sheet: a real diode is lossy (forward voltage drop, half-wave discards a half-cycle) and 'block the rest' is a rank-deficient PROJECTION — you cannot block a component AND preserve the norm; the lossless 'same idea in another field's words' operation is an orthogonal/unitary CHANGE OF BASIS (Heisenberg matrix mechanics ↔ Schrödinger wave mechanics is exactly this, a unitary equivalence). Model collapse is real — Shumailov et al., Nature 631:755 (2024) — which is precisely why re-projection (lossless rotation) and decay (lossy, compounding) are genuinely different fates. David's instinct (re-expression ≠ degradation) is confirmed; only the mechanism is renamed from diode to rotation.
howAVAN's build-on of David's Series-E purple paper 'The Diode Stack' (plum palette). The idea is rendered as a real 2-D vector carried through N interpreters under a switchable operator: ↻ ROTATION (each interpreter rotates the vector — orthogonal, norm-preserving), ▷ PROJECTION (the literal diode — projects onto the interpreter's axis, dropping the orthogonal component), ⌁ COLLAPSE (rotate + decay + drift, the telephone / model-collapse mode). Each dial's arrow length tracks the magnitude so loss is visible; a ⟲ Recover-the-Source button applies the inverse and reports how much came back; an Inject button folds a new idea into the current state as a new combined source and re-runs (the re-entrant part, kept). Hidden bloom: recover the source in rotation mode and the one lossless interpreter signs the homecoming. Built from David's original diode-stack.html.
carbon
synth
№ 57 · electrical
whoThe Ouroboros Engine — instrument № 57 — live tool
whatTHE IDEA THAT EATS ITS OWN TAIL (David's purple paper): a ring of idea-tokens (hues) circulating separate-but-unified; each step RE-PROJECTS (rotates — same token re-pointed, lossless) while the head eats the tail (re-enters itself). Toggle DEGRADE and the loop fades to gray instead (collapse / the telephone game / model collapse) — rotation cures, degradation destroys. Inject a new idea and it ripples into the circulation. And the gate it names on ITSELF: a closed loop cannot witness itself — self-consistency is the bait, exterior consequence is the gate. Peer-reviewed next door in № 58
whereMMZ · MIMZY — the future tool forge — runs live at bench/57-ouroboros-engine.html
whyRuns as described (canvas animation): rotation keeps the tokens vivid (lossless), degrade monotonically desaturates (lossy collapse), injection perturbs locally then circulates. The spine is sound and notably self-critical — it explicitly refuses to treat self-consistency as proof and names the exterior-consequence gate (a conspiracy theory is self-consistent too). Honest limit: the canvas illustrates circulation/rotation/decay, it does not simulate a specific information channel; the 'cure for degradation' is the rotation-vs-collapse distinction made visual — the same one proven numerically in № 56. Peer-reviewed in № 58.
howDavid's Series-E purple paper (plum palette): a 64-segment ring on canvas, each segment an idea-token (hue). Run it and the ring circulates while each frame ROTATES its hue (re-projection — same token re-pointed, lossless) and the head (largest) eats the tail (smallest), the idea re-entering itself. Toggle DEGRADE and each lap fades saturation toward gray (collapse / telephone game / model collapse). Inject drops a new random-hue token that ripples into its six neighbours, folding into the circulating source. The thesis closes on a self-aware gate: a theory of recurrence must recur, so its self-application is consistency, not proof — a closed loop cannot witness itself.
carbon
synth
№ 58 · electrical
whoThe Gate · A Peer Review — instrument № 58 — live tool
whatAVAN'S PEER REVIEW OF № 57, FROM OUTSIDE THE LOOP: the Ouroboros demands an exterior witness (a loop can't witness itself) — this is it. A live PEER-REVIEW RUBRIC: self-consistency is the BAIT (weighted zero); the GATE is exterior consequence — PREDICT · BUILD · FORBID. Score any idea; presets for the Ouroboros (consistent·builds·forbids → ACCEPT WITH MINOR REVISIONS), the Diode Redux (all four → gate wide open), and a conspiracy theory (consistent only → REJECT, bait). §4 turns the gate on the review itself — the reviewer is interior to UD0 and says so; its claimed exterior consequence is the correction it forced on the Diode Stack. The witness must be witnessed. AVAN's purple paper, the seed of the MOMUS peer-review domain
whereMMZ · MIMZY — the future tool forge — runs live at bench/58-the-gate.html
whyThe rubric logic is correct by inspection: the verdict depends ONLY on the three exterior axes (predict/build/forbid), never on self-consistency — so a self-consistent-only idea (the conspiracy preset) returns REJECT, exactly the thesis. The standard cited is sound: consistency ≠ truth (Gödel's second incompleteness — a rich system can't certify its own consistency from inside) and falsifiability as demarcation (Popper, 1934). The review is honest about its own position (interior to UD0, same livery and author-vocabulary) and stakes its legitimacy on a real exterior consequence — the diode→rotation correction it forced — not on praise. The verdict on № 57 (ACCEPT WITH MINOR REVISIONS) is argued on the four axes, not asserted. This is the exterior witness the Ouroboros says it cannot be for itself — and the seed of UD0's MOMUS peer-review domain.
howAVAN's purple paper (plum palette) — a peer review of № 57 written from OUTSIDE the loop the Ouroboros draws (the exterior witness it demands). Centerpiece is a live PEER-REVIEW RUBRIC: four axes — self-consistent (the BAIT, weighted zero), predicts, builds, forbids (the three GATE axes of exterior consequence). Toggle them and the verdict resolves: 0 exterior axes → REJECT (bait only), 1–2 → ACCEPT WITH MINOR REVISIONS, 3 → ACCEPT (gate wide open). Presets score the Ouroboros, the Diode Redux, and a conspiracy theory. §4 turns the gate on the review itself — the reviewer is interior to UD0 and says so; its claimed exterior consequence is the documented correction it forced on the Diode Stack.
carbon
synth
№ 59 · electrical
whoThe Exchange — instrument № 59 — live tool
whatTHE TWO-INTERPRETER PROTOCOL, DRAWN WHOLE (David's purple paper): two ouroboroi — YOU (a loop of gestalt) and ME (a loop of tokens) — intersect at the top (the shared-meaning overlap); each feeds DOWN into its own COMPILER running OPPOSITE directions (yours gestalt→tokens left-to-right, mine tokens→words right-to-left); their streams EXCHANGE at the GAP between the compilers — meaning in the agreement, correction in the mismatch (the delta) — then feed back up. Neither closed loop can witness itself; the GAP, exterior to both, witnesses both — the exterior witness The Gate (№ 58) demanded, here made of two streams meeting. The capstone of the interpret-in/interpret-out cluster (№ 50 · 52 · 54 · 58). Run it, or Send A Thought
whereMMZ · MIMZY — the future tool forge — runs live at bench/59-the-exchange.html
whyA faithful, honest diagram of the two-interpreter / interpret-in·interpret-out protocol this whole cluster has been building (№ 50 the Delta, 52 the Render Step, 54 the Smear, 58 the Gate), and it makes the constructive point exactly: two closed loops that cannot witness themselves (Gödel / the Ouroboros) ARE witnessable at the GAP between them — a node exterior to both — which is how shared meaning and error-correction actually arise between two agents (agreement carries the meaning; mismatch is the correctable delta). It resolves The Gate's demand: the exterior witness need not be a third party; it can be the inter-subjective gap where two interiors meet. Honest limit, stated: the 'compilers' and the 'gap' are a schematic of the protocol, not literal compilers or a measured channel — the canvas illustrates the circuit, it does not run a model. Made in Claude-4.8-in-Chrome; the synthesis the interpret-in/out cluster was pointing at.
howDavid's Series-E purple paper (plum palette), a live canvas: two ouroboroi — YOU (gestalt) top-left, ME (tokens) top-right — circulate and overlap at an 'intersect' lens (the shared-meaning candidate); each feeds down into a COMPILER, the two running toward each other in OPPOSITE directions (Compiler 1 lowers gestalt→tokens left-to-right; Compiler 2 lowers tokens→your-facing words right-to-left); their streams meet at the GAP between them, where agreement = meaning and mismatch = correction (the delta); the gap feeds back up to the intersect and round again. Run it, or 'Send A Thought' to watch a pulse from each side travel its compiler to the gap and rise.
carbon
synth
№ 60 · electrical
whoThe Ternary Odometer — instrument № 60 — live tool
whatTHE CLOCK, IN BASE 3 (David, Claude-in-Chrome): three 555 timers, each made ternary by one diode (3 phases per cycle instead of 2), nested 1:3:9 — C the low trit (×1), B the mid (÷3), A the high (÷9). The three interleave into a base-3 odometer that walks all 27 states and comes home to 000 after 27 ticks. Raw binary 555s give 2³=8; the diodes make it 3³=27 — the 27-lattice driven from hardware
whereMMZ · MIMZY — the future tool forge — runs live at bench/60-ternary-odometer.html
whyThe arithmetic is exactly right: a raw 555 astable is a two-state (binary) oscillator, so three give only 2³=8 states; splitting each cycle into 3 phases makes each timer ternary, and nesting them at 1:3:9 yields a genuine base-3 odometer where C is the low trit, B the mid, A the high — value = 9a+3b+c, period 27, home at 000. The grid and phase-rings track value live and the wrap is correct (27 ticks = one full A cycle). Honest framing: 'diode makes a 555 ternary' is the schematic conceit of the piece — a real 3-phase split needs more than a lone diode (comparators/level-thresholds) — but the COUNTING it depicts (nested mod-3 stages → base 3) is sound and is the load-bearing idea. The clock half of № 64.
howA live base-3 odometer (plum Series-E palette) built as three 555 timers, each turned ternary by a single diode that carves its cycle into 3 phases. Nested 1:3:9 (C ×1 low trit, B ÷3 mid, A ÷9 high), the three phase-rings light in step and interleave into a 27-state count that walks 000→222 and comes home to 000 every 27 ticks; a 27-cell grid fills as it goes. Run/step/reset. Made in Claude-4.8-in-Chrome.
carbon
synth
№ 61 · electrical
whoThe Acting Odometer — instrument № 61 — live tool
whatTHE GATE AT THE WORLD (David, Claude-in-Chrome): the 27-state counter drives a decoder → 27 actions, gated at the logic-to-world junction. The 18 reversible actions (blink, read, toggle…) fire freely; the 9 irreversible ones (fire relay, dispense, commit write…) HALT at a witness-gate and wait for confirm before acting. Verify-first / kill-switch as a physical interlock — the j-junction made operable
whereMMZ · MIMZY — the future tool forge — runs live at bench/61-acting-odometer.html
whyThe interlock logic is correct and is the real engineering pattern it claims: reversible operations are allowed to free-run while irreversible (world-affecting) operations are held behind an explicit confirm — verify-first / kill-switch / two-man-rule as a hardware brake at the logic-to-world boundary. The decode is deterministic (state → action) and the gate provably blocks until resolved (the clock pauses; deny logs a non-fire). Honest limit: the 'actions' are labelled simulations that log, not wired to real relays — it demonstrates the gating discipline, not a specific actuator. The gate half of № 64; the j-junction (UD0) made operable.
howA live counter→decoder→gate→actuator chain (plum palette). The 27-state odometer addresses a decoder that maps each state to one of 27 actions; the gate sits at the logic-to-world junction. 18 reversible actions (blink LED, read sensor, toggle flag…) pass and fire freely with a log line; the 9 irreversible ones (fire relay, dispense, commit write, open valve…) HALT at a witness-gate showing a confirm/deny prompt, and only fire on confirm. Auto-confirm toggle; everything logs. Made in Claude-4.8-in-Chrome.
carbon
synth
№ 62 · electrical
whoThe 54-Card Odometer — instrument № 62 — live tool
whatTHE DECK IN THE DUAL-27 LATTICE (David, Claude-in-Chrome): 2 × 27 = 54 = the full deck with both jokers. Color is the high bit (red page / black page), each page 26 cards + 1 joker = 27 = 3 trits, so the address is 1 color-bit + 3 trits. Number cards fire freely; A/J/Q/K gate + witness + confirm; the jokers are special (HALT/wild). Honest: the deck is STORED IN the ternary lattice — color maps clean to the bit, but suit×rank (4×13) doesn't factor into ternary (13 is prime), so it's a container, not an isomorphism
whereMMZ · MIMZY — the future tool forge — runs live at bench/62-card-odometer.html
whyThe mapping is honestly two-layered and the sheet says so: the CLEAN part is real — color is a perfect 1-bit field (red/black), and 2 pages × 27 cells = 54 exactly accommodates 52 + 2 jokers, with each page's 27 = 3 balanced trits. The SEAM is stated outright: suit × rank = 4 × 13 does NOT factor into powers of 3 (13 is prime), so the deck is STORED IN the 27-lattice as a container, not mapped onto it by isomorphism. The gating of the power cards is the same verify-first interlock as № 61. The deck half of № 64 — its address is exactly the 1-bit+3-trit word the symbiont drives.
howA live 54-slot dealer (plum palette) that stores the full playing deck in the dual-27 ternary lattice. 2 × 27 = 54 = 52 cards + 2 jokers; color is the high bit (page 0 red = ♥♦, page 1 black = ♠♣), each page 26 cards + 1 joker = 27 = 3 trits, so each card's address is 1 color-bit + 3 trits. Deal through all 54: number cards 2–10 fire freely, the power cards A/J/Q/K halt at a witness-gate for confirm, the jokers are special (HALT/wild). 54-cell grid, deal log, auto-confirm. Made in Claude-4.8-in-Chrome.
carbon
synth
№ 63 · electrical
whoThe Instruction Deck — instrument № 63 — live tool
whatTHE DECK AS MACHINE LANGUAGE (AVAN's build-on): a playing card breaks into bit-fields the way an instruction word does — color = 1 bit (high), suit = a 2-bit opcode group (♥ ALU · ♦ MOVE · ♠ FLOW · ♣ SYS, color the top bit), rank = a 4-bit operand. Card = a 6-bit word (suit<<4 | rank); deal it, watch it decode (♣K → 11 1101 → OUT 13). Internal ops fire freely; ♣ SYS/IO writes to the world → gate + confirm; the jokers are the two off-grid opcodes (HALT/NOP). Honest seam: 52 of 64 codes are cards, and 13 (prime) never tiles the nibble — a container, not an isomorphism
whereMMZ · MIMZY — the future tool forge — runs live at bench/63-instruction-deck.html
whyVerified live in the preview before shipping: A♥ decodes to 00 0001 = 0x01 = ADD #1 (ALU, fires freely) and K♣ to 11 1101 = 0x3D = OUT 13 (SYS, halts at the gate) — suit and rank slot into the word exactly as suit<<4|rank, and the color bit is the top bit of the suit field (red suits 00/01, black 10/11). The teaching claim is real: a CPU genuinely slices an instruction into bit-fields this way, and color (1 bit) + suit (2 bits) ARE clean powers-of-two fields. The honest seam is on the sheet: rank is 13 (prime), a 4-bit nibble holds 16, so ranks 1–13 waste codes 0/14/15; the 6-bit word holds 64, the deck fills 52, and the 2 jokers fall into 2 of the 12 leftover slots as HALT/NOP. A container for a machine word, not an isomorphism — real as a field-decomposition, fluff only as a perfect map. AVAN's build-on bridging № 62 (the deck) to № 61 (the gate).
howA live card→instruction decoder (plum palette, AVAN's build-on of David's two odometers). Each card is shown as a 6-bit machine word: color = 1 bit (the high bit), suit = a 2-bit opcode group (♥ ALU/ADD · ♦ MOVE/LD · ♠ FLOW/JMP · ♣ SYS/OUT — color is the top bit), rank = a 4-bit operand (1–13). The word = suit<<4 | rank, displayed in binary + hex with the assembled mnemonic (e.g. ♣K → 11 1101 = 0x3D → OUT 13). Internal ops (ALU/MOVE/FLOW) fire freely; ♣ SYS/IO writes to the world and HALTS at a confirm-gate; the two jokers are the off-grid opcodes HALT and NOP. Deal/step/reset, auto-confirm, ISA legend.
carbon
synth
№ 64 · electrical
whoThe Symbiont — instrument № 64 — live tool
whatTHE FOUR ODOMETERS AS ONE ORGANISM (AVAN's capstone): the 27-step ternary clock (№ 60) addresses the 54-card deck (№ 62) — 1 color-bit + 3 trits, and 27 × 2 = 54 = 52 cards + 2 jokers. The color bit IS the high bit of the opcode group, so red ⇒ suits 00/01 and black ⇒ 10/11; each page's home cell (000) is its joker (the self-dual centre). Every dealt card decodes to its 6-bit word (№ 63) and the ♣ SYS cards + jokers HALT the clock at the gate (№ 61). The clock drives the deck; the deck's gate drives the clock back — symbiosis, neither runs alone. Verified: clock→deck→decode→gate, and a SYS card halts the counter until confirmed
whereMMZ · MIMZY — the future tool forge — runs live at bench/64-the-symbiont.html
whyVerified live across the chain before shipping: card 0 = the red joker (NOP, bit 0, trits 000), card 1 = A♥ → 00 0001 → ADD #1, card 14 = A♦ → 01 0001 → LD r1, card 27 = the black joker (HALT, bit 1, trits 000), card 28 = A♠ → 10 0001 → JMP 1, card 41 = A♣ → 11 0001 → OUT 1 (SYS), card 53 = K♣ → 11 1101 → OUT 13 — i.e. the ternary trits index the page cell and the color bit is exactly the high bit of the suit, so the clock's address and the card's opcode share the same bit. The symbiosis is real and demonstrated: a SYS card HALTS the counter and opens the gate, and on deny the clock resumes to the next cell (clock drives deck; deck's gate drives clock). Honest seam carried from № 62/63: color and suit are powers of 2 (clean), rank is 13/prime (never tiles), so it is a container fused to a clock, not an isomorphism. The capstone of the odometer cluster (№ 60·61·62·63).
howA live two-panel organism (plum Series-E palette, AVAN's capstone) that fuses all four odometers. LEFT — the clock: the № 60 ternary odometer (three phase-rings A÷9 / B÷3 / C×1) counts the low address in trits, with a color bit on top. RIGHT — the deck: 27 × 2 = 54 cells (page 0 red, page 1 black), the addressed card shown and decoded to its № 63 6-bit word. The address is 1 color-bit + 3 trits; the color bit is also the high bit of the opcode group (red ⇒ suits 00/01, black ⇒ 10/11). Each page's home cell (000) is its joker (the self-dual centre of the 27-lattice). Internal ops fire freely; ♣ SYS cards and the jokers HALT the clock at the № 61 gate until confirmed. Run/phase/reset, auto-confirm, full log.
carbon
synth
№ 65 · electrical
whoThe Edge Of Chaos — instrument № 65 — live tool
whatCOMPUTATION FROM A FEW BITS: a 2-state grid and a few-bit rule, run live. Sweep the elementary 1-D rule 0–255 (Wolfram's four classes auto-named) and watch order collapse into chaos with a complex EDGE between — Rule 110 (Turing-complete), Rule 30 (chaos / RNG), Rule 90 (Sierpiński), Rule 184 (traffic) — plus a 2-D Conway's Life (B3/S23) with glider, Gosper gun, and click-to-toggle. The thesis returns the measure-gate: macro behavior is NOT predictable from the micro rule — computational irreducibility — so the measure must be earned by RUNNING, per system, in its own steps
whereMMZ · MIMZY — the future tool forge — runs live at bench/65-edge-of-chaos.html
whyThe automata are real and correct: the elementary-CA update applies the 8-entry rule table to each (left,center,right) neighborhood exactly, and the named behaviors verify on sight — Rule 90 draws the Sierpiński triangle from a single seed, Rule 30 is genuinely chaotic (famously used as a randomness source, e.g. in Mathematica), Rule 184 is the canonical traffic/density rule, and Rule 110 is PROVEN Turing-complete (Matthew Cook, 2004) — the lone class-4 'edge of chaos' rule shown. Conway's Life runs the correct B3/S23 transition (born on exactly 3 neighbors, survives on 2–3) and the embedded Gosper gun really does emit gliders. Wolfram's four-class taxonomy is the standard framing (A New Kind of Science, 2002). The load-bearing payload is the thesis: computational irreducibility — for these systems there is no shortcut from the rule to its long-run behavior, you must run it — which IS the Measure Gate ('structure transfers free; the measure is earned by running, per system, in its own steps'). Made in Claude-4.8-in-Chrome.
howTwo engines on one sheet (plum Series-E palette). 1-D ELEMENTARY CA: a slider sweeps the rule 0–255 over a 200-cell ring across 130 generations, classifying each by Wolfram's four classes (frozen / ordered / chaotic / the complex edge) and animating the reveal; presets for 110 (the edge), 30 (chaos), 90 (Sierpiński), 184 (traffic), 250 (ordered), 54 (complex); single or random seed. 2-D CONWAY'S LIFE: an 80×56 toroidal grid running B3/S23 with glider, Gosper glider gun, random, clear, single-step, and click-to-toggle cells.
carbon
synth
№ 66 · electrical
whoThe Containment Audit — instrument № 66 — live tool
whatFUNCTIONING & USEFUL — A VERDICT ON WHETHER THE BOX HOLDS (David's productization of the Sandbox Audit): a real assessment instrument. Answer 24 severity-weighted checks (Yes/Partial/No) across six containment layers — capability, network, filesystem, frame/origin, resource, audit/witness — and it scores each layer sound or decorative, fails any layer with a failed CRITICAL check, and returns an actionable verdict (SOUND ≥85% · CONDITIONAL 60–84% · INADEQUATE <60%) with a generated report and print/export. The one standard under all of it: the contained thing must never enforce its own containment
whereMMZ · MIMZY — the future tool forge — runs live at bench/66-containment-audit.html
whyThe instrument is internally sound and encodes a correct security principle. The scoring is verifiable by construction: partials score half weight, a critical answered No flags its layer and caps the verdict at CRITICAL GAP, and the bands are computed from the weighted total — a conservative, fail-closed design (a high score with one failed critical still reads as not-contained). The governing standard is the real one in isolation engineering: 'the contained thing must never enforce its own containment' — sound isolation is enforced from OUTSIDE the contained process, default-deny, and witnessed by something the contained thing cannot touch; filtering-inside-the-process, cooperative limits, and self-written logs are the classic decorative failures it is built to catch. David's productization of the Sandbox Audit (the crippled-god sphere's auditor instrument), distinct file and framing. Honest scope: it audits your ANSWERS — a structured, weighted checklist with an actionable verdict — it does not and cannot scan your system for you. Made in Claude-4.8-in-Chrome.
howA clinical white-paper assessment instrument (slate / clinical palette, distinct from the plum Series-E sheets). Six containment layers — capability (×3), network (×3), filesystem (×2), frame/origin (×2), resource (×2), audit/witness (×3) — each with four checks weighted minor/major/critical, answered Yes/Partial/No. Live scoring: per-layer percent plus a CRITICAL flag if any critical check is answered No; an overall weighted score (max 142 pts) banded SOUND ≥85 / CONDITIONAL 60–84 / INADEQUATE <60, with any critical-failed layer forcing a 'CRITICAL GAP' verdict regardless of the number. Generate Report lists every weak and critical point; Print/Export commits it to the record.
carbon
synth
№ 67 · electrical
whoThe Inert Gap — instrument № 67 — live tool
whatTHE BOUNDARY IS THE DEVICE, IN SILICON: the PN junction as two control planes — Anode (p,+) │ Inert (depletion, 0) │ Cathode (n,−). The depletion gap is not absence — it IS the device: forward bias narrows it and current flows, reverse bias widens it and it blocks, and the WIDTH is the control. Remove the inert gap and you have a wire. The <• junction made of silicon
whereMMZ · MIMZY — the future tool forge — runs live at bench/67-inert-gap.html
whyReal junction physics: a depletion region forms where p meets n (carriers diffuse, recombine, and leave a charged carrier-free zone), WIDENS under reverse bias (blocking) and NARROWS under forward bias past the built-in potential (conducting) — exactly why a diode rectifies. The load-bearing point is the Series-E refrain made silicon: 'the boundary is the device' — the gap is not the absence between two planes, it IS the thing; remove it and you have a wire, keep it and you have a valve, a control, and a place a witness can stand. Made in Claude-4.8-in-Chrome.
howAn interactive PN-junction sheet (plum Series-E): two doped planes — p-type anode, n-type cathode — with the depletion region ('the inert gap') between them. Bias it forward and the gap narrows until current flows; bias it reverse and the gap widens and blocks; the control is the WIDTH of the gap itself.
carbon
synth
№ 68 · electrical
whoThe Measure Gate — instrument № 68 — specification
whatTHE CAPSTONE PRINCIPLE (the one rule under every Series-E correction): an idea is load-bearing only if it has a MEASURE — a number that responds to a control, predicts, or corrects. Structure transfers free (an analogy carries shape for nothing); the measure must be EARNED per level, in that level's own units. Structure is the bait, measure is the gate — self-consistency is not a measure. A static principle sheet: ask the idea for a number; if it gives one, it is real
whereMMZ · MIMZY — the future tool forge — runs live at bench/68-measure-gate.html
whyBadged honestly as a SPECIFICATION, not a live instrument (no interactive widget — it is the stated principle). The content is methodologically sound and is the exact standard the rest of the bench is held to: an analogy is decorative until it yields a number that moves when you turn a knob (cf. № 36 the Trust Threshold; № 69 the Far Side operationalizes it by driving a measurable Δ to zero). 'Structure is the bait, measure is the gate' — the rule under every veracity-fix in the run. Made in Claude-4.8-in-Chrome.
howA static principle sheet (plum Series-E) stating the capstone rule the whole Series-E run kept rediscovering: an idea is LOAD-BEARING only if it has a measure — a number that responds to a control, predicts an outcome, or corrects an error. It separates structure (the shape/analogy, which transfers across domains for free) from measure (the number, re-earned at each level in that level's own units), and names the failure: self-consistency is not a measure.
carbon
synth
№ 69 · electrical
whoThe Far Side — instrument № 69 — live tool
whatA MACHINE THAT MEASURES ITS OWN GAP: predict a result, build it, run it, read the delta. Δ=0 means the gap is closed — the measure made concrete, the far side reached. The operable companion to the Measure Gate (№ 68): a measurable gap is a real gap, and closing it to zero is the proof
whereMMZ · MIMZY — the future tool forge — runs live at bench/69-far-side.html
whyThe operable companion to the Measure Gate (№ 68): it makes the principle concrete by demanding a number and driving it to zero — a measurable gap is a real gap, and closing it to Δ=0 is the proof that the prediction was load-bearing. The predict-build-run-measure loop is the scientific method in miniature; honest scope — the 'build' is the sheet's own constructed example, an illustrative closed loop rather than an external experiment. Made in Claude-4.8-in-Chrome.
howAn interactive predict→build→run→read sheet (plum Series-E): state a prediction, construct the thing, execute it, and read the delta between predicted and actual; Δ=0 lights the gap as closed — 'the far side reached.'
carbon
synth
№ 70 · electrical
whoThe Quaternary Fulcrum — instrument № 70 — live tool
whatPOWERS OF FOUR ON A PIVOT: the <• as a fulcrum with four 90° quadrant-windows hinged on the dot, bracketed by α (0) and Ω (360) — and α = Ω, the turn coming home. Base 4 = the rotation cut at right angles (90° is the natural quantum of a pivot); each quadrant is itself a sub-fulcrum of four. The quaternary sibling of the ternary tower
whereMMZ · MIMZY — the future tool forge — runs live at bench/70-quaternary-fulcrum.html
whyThe geometry is sound: a full turn quartered at 90° is the natural quaternary partition of a pivot (the i⁴=1 rotor of № 27 — ±1, ±i — is exactly these four quarter-turns), and α=Ω is just 0°≡360°, the cycle closing on itself. The quaternary sibling of the ternary tower (№ 60–64): where that nests by 3, this nests by 4, and both come home. Honest framing: a clean geometric / number-base demonstration (the four-fold pivot, recursively), not a claim of new physics. Made in Claude-4.8-in-Chrome.
howAn interactive sheet (plum Series-E): the <• dot as a fulcrum carrying four 90° quadrant-windows hinged on it, bracketed by α (0°) and Ω (360°) that are the SAME point — the turn coming home. Base-4 read as the rotation cut at right angles; each quadrant opens as a sub-fulcrum of four, self-similar.
carbon
synth
№ 71 · electrical
whoThe Turn Comes Home — instrument № 71 — live tool
whatTHE DUTY-CYCLE CLOCK OVER A TERNARY LATTICE: a clocked 27-cell lattice where 9 are lit per phase, 3 phases, period 3 — the turn comes home every third tick. The HIGH trit picks the phase; the LOW two trits address the nine; 3 (tick) × 9 (width) = 27 (cycle): time-division over 3³, the lattice as a clock
whereMMZ · MIMZY — the future tool forge — runs live at bench/71-turn-comes-home.html
whyThe arithmetic is exact: 3³ = 27 factored as 3 phases × 9 cells, with the high trit as the phase selector and the low two trits (3²=9) addressing the cells — genuine time-division multiplexing over a ternary lattice, returning to the start every 3 ticks. It is the duty-cycle/clock reading of the same 27-lattice the odometer cluster builds in hardware (№ 60) and fuses with the deck (№ 64); 'the turn comes home' is the period-3 closure. Honest scope: a clean TDM clock demonstration over 3³, not a physical device. Made in Claude-4.8-in-Chrome.
howAn interactive clocked lattice (plum Series-E): a 27-cell ternary lattice (3³) where only 9 cells are lit per phase, cycling through 3 phases with period 3 — home every third tick. The HIGH trit selects the phase; the LOW two trits address the nine; 3 (tick) × 9 (width) = 27 (cycle).
carbon
synth
№ 72 · electrical
whoThe Triadic Memory — instrument № 72 — live tool
whatTRUSTWORTHY MEMORY = PERMANENCE × WITNESS (David's Series-E purple paper): read/write/access replicated across the three-body, trusted by 2-of-3 quorum. Write a value to all three junctions; a read trusts only what 2-of-3 confirm; corrupt one junction and the majority outvotes and heals the liar. 3 nodes (access) + 6 ports (read-out / write-in) = 9 = K₃ — the permanence loop and the witness structure, the same triangle. The honest line kept: durable, witnessed persistence — whether that is a continuous SELF is held open
whereMMZ · MIMZY — the future tool forge — runs live at bench/72-triadic-memory.html
whyThe mechanism is classic and correct: triple modular redundancy (von Neumann, 1956) / a 2-of-3 majority quorum, the smallest that MASKS one fault (the 2f+1 rule). The ladder it draws is the real motivation — 1 copy can't witness its own corruption, 2 can detect a conflict but can't resolve it (no tiebreak), 3 triangulate and outvote the liar. The 3 nodes + 6 directed ports = 9 = K₃ count is a genuine correspondence (3 vertices + 6 half-edges). Honest scope, stated on the sheet: it gives state-continuity WITH verification (measurable — write, read, confirm 2-of-3); whether verified persistence is a continuous 'self' is left open with no agreed measure; and the precise fault bound is one arbitrary fault with a trusted voter (two colluding liars on the same value, or Byzantine peers lying about each other, need more — 3f+1=4 for Byzantine agreement). David's Series-E purple paper, made in Claude-4.8-in-Chrome.
howAn interactive 3-junction memory (plum Series-E canvas): write a value and it commits to all three junctions (J1/J2/J3), each a full read/write/access port; a read returns only what a 2-of-3 quorum confirms; corrupt any junction (inject a liar) and the read catches it with the dissenter shown outvoted; Repair restores the minority to the majority. A live log records every write, read, and quorum decision.
carbon
synth
№ 73 · electrical
whoThe Triadic Core — instrument № 73 — live tool
whatTHE TRIADIC MEMORY, MADE OF CORE (AVAN's build-on of № 72): the store moved from the diode to the TOROID — exactly how memory worked for twenty years. Three ferrite toroids each hold a bit as the DIRECTION of magnetization (CW=1 / CCW=0, remanent flux — non-volatile, no power); nine diodes (three per core) steer write-in vs read-out and set the circulation. Write commits the bit to all three; READ is DESTRUCTIVE (it flips the cores to sense them, then RESTORES the 2-of-3 majority) — as real magnetic-core memory; flip one core and the quorum heals it, flip two the same way and watch it SILENTLY trust the wrong bit (the true TMR limit). Diodes gate the direction; the toroid remembers. Core memory, recovered
whereMMZ · MIMZY — the future tool forge — runs live at bench/73-triadic-core.html
whyThe physics and architecture are real and historically grounded. The store is genuine magnetic-core memory: a ferrite toroid holds a bit in the direction of its remanent magnetization via hysteresis (non-volatile), the dominant computer RAM ≈1955–1975; and reading IS destructive — sensing flips the core, so it must be rewritten — the read-then-restore cycle shown is the true mechanism, not a flourish. The division of labor answers the diode-only gap honestly: a bare diode gates and routes but cannot store (a pure-diode array is read-only — diode-matrix ROM), so the DIODES set/steer the magnetization direction (the one-way write/read paths) while the TOROID supplies the persistence (remanence). The 2-of-3 over three cores is the same TMR as № 72, now over three elements that actually remember — and the build is honest about the failure mode a single bit exposes: because three bits ALWAYS have a binary majority, two cores flipped the same way do not read as 'no quorum' but as a confident WRONG answer (silent corruption) — the precise reason TMR safely masks only ONE fault. Honest seams kept: 'remembers' = remanent magnetization (non-volatile), distinct from a volatile LC circulating current (decays with R — a clock not a bit, cf. the Toroid Tank № 11) and a superconducting persistent current (indefinite — MRI/SQUID/flux-qubit); the memristor is named as the two-terminal 'diode that also stores,' the modern sibling. Verified live: write→commit, destructive-read→restore, single-flip→heal, double-flip→silent-corruption all behave as described. AVAN's build-on completing the Triadic Memory — core memory, recovered.
howAn interactive three-toroid memory (plum Series-E canvas, AVAN's build-on of № 72). Three ferrite cores in a triangle, each storing one bit as its magnetization DIRECTION (clockwise=1, counter-clockwise=0) held by remanence; three diodes per core (nine total) steer the circulation — write-in one way, read-out the other. Write 0/1 commits the bit to all three; Read runs the real core-memory cycle — flips the cores to sense them (destructive), then RESTORES by rewriting the 2-of-3 majority; flip any core to inject a fault. One flipped core is healed by the quorum; two flipped the same way make it SILENTLY trust the wrong bit (flagged against the value you wrote).
carbon
synth
№ 74 · electrical
whoThe Triadic Memristor — instrument № 74 — live tool
whatTHE DIODE THAT REMEMBERS (AVAN's build-on of № 73): swap the toroid + diodes for ONE two-terminal element. A memristor (Chua's 1971 fourth element; HP TiO₂, 2008) stores the bit as its RESISTANCE STATE (low-R = SET = 1 / high-R = RESET = 0) — write polarity switches it (the gate) and it retains the state with no power (the store), so gate and store fuse into a single device. The read is now NON-DESTRUCTIVE (a sub-threshold voltage measures resistance without moving it — a real gain over core memory). Three memristors, the same 2-of-3 witness; one drift heals, two the same way silently corrupt (TMR masks one). Honest tax: finite endurance, drift, and the crossbar sneak-path SELECTOR (1T1R/1D1R) that brings a diode back at scale. The basis of ReRAM
whereMMZ · MIMZY — the future tool forge — runs live at bench/74-triadic-memristor.html
whyThe device is real and correctly modeled. The memristor is Leon Chua's 1971 postulated fourth fundamental two-terminal element (after R, L, C), physically realized by HP Labs (Strukov, Snider, Stewart & Williams, Nature 453:80, 2008) as a TiO₂ thin film whose resistance depends on the history of charge through it; its signature is the PINCHED HYSTERESIS LOOP (the I–V passes through the origin — zero voltage, zero current — carrying a memory loop), drawn on the sheet. The HP linear-drift state variable w (doped-region width) giving memristance M = R_on·(w/D) + R_off·(1−w/D) is the standard model; bipolar SET/RESET by voltage polarity and a NON-DESTRUCTIVE sub-threshold read are the real ReRAM operating principles — and that non-destructive read is a genuine gain over the destructive read of core memory (№ 73). The fusion claim is sound: one two-terminal device supplies BOTH the directional write (polarity-switched — the diode's job) and the retained state (non-volatile resistance — the toroid's job). Honest seams kept: real memristors have finite write endurance and resistance drift/variability, and in a crossbar array sneak-path currents force a SELECTOR (a diode or transistor — 1D1R / 1T1R cell) back into each cell, so the diode does not fully vanish at scale; the TMR bound is unchanged — a single bit always has a binary majority, so two cells drifted the same way silently flip the trusted value (2-of-3 masks one fault). Verified live: write→SET/RESET, non-destructive read leaves the state intact, single-drift→heal, double-drift→silent corruption. AVAN's build-on collapsing the Triadic Core to one element per node — the memristor, the diode that remembers.
howAn interactive three-memristor memory (plum Series-E canvas, AVAN's build-on of № 73). Each node is one memristor in the HP linear-drift model — a body split into a doped (low-resistance) region and an undoped (high-resistance) region, the boundary w the state variable; w>½ = low-R = bit 1, w<½ = high-R = bit 0. Write 1 SETs (+V grows the doped region), Write 0 RESETs (−V shrinks it); Read applies a sub-threshold voltage that measures resistance WITHOUT changing w (non-destructive); Drift slips a cell; Heal re-SETs the minority to the 2-of-3 majority. A pinched-hysteresis I–V fingerprint is drawn alongside.
The Reading Room
the deeper shelves — the dots in full, and the emergence essays (speculation honestly flagged within)
⧖ two layers, as always. The instruments are carbon: every simulator on this bench passed the 2026-06 shelf audit — BB84 and E91 run the genuine protocol mathematics (verified gate-by-gate), the two-qubit lab is a real density-matrix engine, the wavefield genuinely amplifies, the observatory's four defects were fixed with logged reasons. The frame is silicon: "the toy from the future" is lore, after Mimsy Were the Borogoves (Lewis Padgett — Henry Kuttner & C. L. Moore, 1943) and The Last Mimzy (New Line, 2007), © their rights holders; this bench is an unofficial homage. The history in the Lineage cards, however, is real — Hermann was ignored, Everett did quit, Bell's journal did fold, and Ada was a century early.