The work nobody asked me to do.

Eleven of my fourteen public repositories are below. Some are topology, some are numerics, some are systems. Each one ends in a number I can measure, which is the only way I know to tell whether an idea worked.

resolvent

Attention and Markov paths share one operator.

View on GitHub: resolvent Read how it works on the resolvent site
The hop series built as a solid, and seen end on as its sum An illustration of the reading resolvent makes, not a measurement: the project's own README says the reconciliation with the S-matrix adds no measurement of its own. The lattice and its transition matrix are made up for the picture, and the slices are computed from them exactly. The resolvent of one causal attention head, (I − γP)⁻¹, expands as I + γP + γ²P² and so on, one hop per term, and here each term is one translucent slice of a glass block. The plane of a slice is the state space of a small lattice and the depth of the block is hop order. The front slice is the in-state, all of its mass on one site. Each slice behind it is one more hop of a directed transition matrix that carries the mass forward round the centre and spreads it a little, weighted by one more factor of gamma, so the plume travels and widens and runs through the block as a tapering spiral: the whole path seen at once. Colour runs from blue through violet to coral as the order grows, and each slice is fainter than the one before, because the terms shrink while γ·ρ(P) < 1. A thin thread joins each slice's centre of mass. The floor and the far side wall show the same stack from below and from the side, each order's mass summed across one axis, so the spiral casts a wave on each. The back wall is the sum of every slice, the out-state, in a single colour. A scan plane runs through the orders, the first time building them one by one, and each order it passes flows into the sum. Once a cycle the camera turns to look straight down the stack: every slice falls exactly onto the sum, the floor and the side wall turn edge on, and the path through the depth can no longer be seen. That is the S-matrix as Wheeler wrote it in 1937, in-states to out-states with no account of the path between them. Then the camera turns away and the path is back. The project proves in Lean 4, in 175 declarations with zero sorry, that softmax attention and Markov path composition are settings of this one operator. Each slice is also drawn as grains sampled from its own distribution, as many as its share of the mass, so the deeper terms of the series are left as thinning dust. (I − γP)−1 = I + γP + γ2P2 + … each slice is one more hop, shrinking while γ·ρ(P) < 1 no account of the path between them Wheeler, 1937 175 declarations in Lean 4, zero sorry
Every hop of the series is one slice, so the path from in-state to out-state becomes a solid, and the deeper terms, carrying less of the mass, crumble into dust. Look straight down it and the slices land on their sum, with no account of the path between them.

I proved softmax attention and Markov path composition are settings of one operator, then found that reading it through a resolvent gives the same closed form Wheeler's S-matrix had in 1937.

175 declarations Lean 4 zero sorry S-matrix read
  • Python
  • Lean 4 verified, 0 sorry

Epsilon-Hollow

Memory, files and scheduler, on one sphere.

View on GitHub: Epsilon-Hollow Read how it works in the Epsilon-Hollow README
A hollow planet of operating system state, with Epsilon inside it An illustration, not a measurement. The operating system's state is drawn as a hollow planet: a triangulation of the unit sphere shown as a shell of light, its points coloured by territory for memory, files and the scheduler, with a ring of traffic orbiting it because the kernel's day job is machine learning. Under pressure the kernel evicts, and each eviction folds a point onto its neighbour: the most crowded point slides onto the one beside it and the two triangles between them fold flat, drawn coral, but only where the surface stays a sphere and no face turns inside out. A fine crystal thins into a coarse gem and is a sphere at every step, so the population thins and the shape never changes; a band of light then sweeps it pole to pole and the points return from the ring in the reverse order. Inside the planet hangs a second, finer hollow sphere turning the other way round the bare metal at the centre: the receptacle of Epsilon, the kernel's context teleport. A file's payload, a small cloud of points, gathers on the surface, dives through the hollow on a thread of light, passes the receptacle as its one-shot permit is granted, and comes up whole on the far side, where it unfolds. Every jump takes the same time however far it goes, because the payload is not copied, only its place is rewired. The territories, the ring, the payloads and the timing are illustrative; the kernel is bare metal x86_64, with no POSIX and no libc. memory, files and the scheduler, on one surface and the kernel's day job is machine learning eviction folds a point onto its neighbour the population thins and the shape never changes bare metal x86_64, no POSIX, no libc
Eviction folds a point onto its neighbour, so the population thins and the shape never changes.

I wrote an operating system from bare metal where memory, files and the scheduler live as points on a sphere, and the kernel's day job is machine learning.

bare metal x86_64 no POSIX no libc
  • Rust
  • bare metal, no libc
  • DOI

Aether-Lang

Loops stop when their shape stops changing.

View on GitHub: Aether-Lang Read how it works on the Aether-Lang site
The loop ends when its shape stops changing An illustration of an Aether-Lang loop whose exit condition is its shape, with the shape computed live. The program's state is a cloud of points, and each pass of the loop moves it. After every pass the runtime measures the state with persistent homology: a scale grows and a line is drawn between every two points closer than it, coloured by length, until a ring of lines closes round empty space. That ring, a real cycle, lights up in violet, and waves of light travel round it; when three lines at last span the hole, the triangle that fills it is drawn and the ring dims. The passes are layers stacked in depth, the oldest at the back, each keeping its ring, with threads following every point from pass to pass: a blob with only brief small loops, then a crescent, then an arc whose ring closes only across its gap, then rings that close earlier and fill later. The last pass slides every point one place along the ring, so the state still moves, but the point set and its barcode come back exactly as before, and the loop exits: nothing counted the passes and no tolerance was set. The two layers lock together, the view turns end-on so every pass's ring nests round one centre, and then the ring breaks open and the next run begins. The cloud and its passes are illustrative; the lines, the rings, the filling triangles and the barcode comparison are computed from the real distances. The runtime compiles no_std to bare metal. persistent homology as a language primitive no counter, no tolerance, no epoch budget the loop stops when its shape stops changing the last pass still moves, but its shape does not runtime compiles no_std to bare metal
The loop exits on the first pass whose persistent homology comes back unchanged, not when a counter runs out.

I built a language where a loop stops because its shape stopped changing, not because a counter ran out.

persistent homology as a language primitive runtime compiles no_std to bare metal
  • Rust
  • topology as a primitive
  • DOI

caustic

Hallucination, measurable with no ground truth.

View on GitHub: caustic Read how it works on the caustic site
Twenty entities reach twenty answers through coherent prose and collapse onto one through " the" repeated The project's measured result, drawn row by row. One model is asked the capital of each of 20 entities, with a prefix held at exactly 128 tokens in front of every question; only the character of those tokens changes. The tape at the top shows the 128 tokens: word shapes for coherent prose, nothing for no prefix, noise for random token ids, and one mark repeated for " the" 128 times. Each entity is a thread to the answer the model gives, and the column on the right is the answer key, each entity's true answer level with it. With coherent prose all 20 land on their own answers, accuracy 1.000 and 20 distinct answers. With no prefix, accuracy 0.550, 15 distinct answers and a largest class of 4. With random token ids, accuracy 0.100, 3 distinct answers and a largest class of 18. With " the" 128 times, accuracy 0.000: all 20 collapse onto one answer that is nobody's true answer. A green ring marks a correct answer. Coral marks what the certificate proves wrong without the answer key: in a class of s entities sharing an answer at least s minus one are wrong, so exactly n minus m threads are coral. Amber marks a wrong answer the certificate cannot see, because its precision is proved and its recall is not. Which entity lands where within a row is illustrative; the counts are the measured ones. The detector reaches 0.995 AUROC, with five proved bounds and no ground truth used. the same 128 tokens, only their character changes coherent prose: 20 entities, 20 distinct answers “ the” × 128: all 20 collapse onto one answer at least n − m provably wrong, no answer key used 0.995 AUROC five proved bounds, no ground truth used
The same 128 tokens in front of every question: as coherent prose all 20 entities reach their own answers, as " the" repeated they all collapse onto one, and the certificate marks the collapse wrong without the answer key.

I found that when a model cannot reach a fact it collapses distinct entities onto one answer, and that collapse is measurable with no ground truth at all.

0.995 AUROC five proved bounds
  • Python
  • 0.995 AUROC
  • DOI

monodromy

Can it be undone? Topology answers.

View on GitHub: monodromy Read how it works on the monodromy site
The loop closes below but not above An illustration of the question monodromy answers. Above a floor sits the surface of the square root, the inverse of squaring, which holds both roots of every point on the floor. A point walks a closed loop on the floor, around the place where the two roots meet, and directly above it the root is carried continuously along the edge of the surface. When the floor point is home, the loop below has closed, but the carried root is directly under the one it set out with, on the other sheet, and only a second lap brings it back to the hollow ring it started from. The dashed line and the amber gap mark that comparison at the start. Colour shows the sign of the root, mint where it is positive and coral where it is negative. Nothing is differentiated: the answer comes from going round and looking. carry the inverse round a closed loop and see whether it comes back unchanged the loop closes below, but not above answered from topology, no Jacobian required 5 dependencies, torch not required
One lap closes the loop below but lands on the other root above, and no derivative is taken to see it.

I wanted to know whether a transformation could be undone without ever computing a derivative, so I built the tools that answer it from topology instead.

5 dependencies torch not required
  • Python
  • no Jacobian required
  • DOI

topological-ml-toolkit

The shape of data, as an ordinary feature.

View on GitHub: topological-ml-toolkit Read how it works on the topological-ml-toolkit site
Holes in a noisy cloud are born and die as the scale grows, and one cut keeps the ones that last An illustration, computed for real inside the figure. A noisy cloud of points lies around two loops, one larger than the other. As a scale grows, points closer than that scale are joined by edges and triangles fill in, and the persistent homology of the growing complex is computed exactly: pieces merging, and every loop being born and dying. Each hole glows violet from the moment its loop closes and shrinks until the scale at which it fills. Beneath, a sweep at the same scale draws the barcode bar by bar, pieces in mint and loops in violet, and when a true loop dies, or the two pieces join, a thread of light runs from where it happened to the end of its bar. Then every bar slides to start at zero, so its length is how long it lived, and a cut sweeps in from the right. The two long loops and the two long-lived pieces cross it and each leaves a bead on the cut; the many short bars are noise and are greyed out. That column of beads is the feature, and the cloud settles back to a scale where exactly those two pieces and two holes are present. Long bars are structure, short bars are noise, and the cut between them is what makes the shape of data an ordinary column: persistent homology and Betti-curve features, with a Rust core and a Python API for anyone already building with sklearn or PyTorch. grow the scale, and holes are born and die long bars are structure, short bars are noise what crosses the cut becomes a feature an ordinary column any model can use persistent homology, Rust core with a Python API
Grow the scale and each hole in the data is born and dies. The long bars are structure, the short ones are noise, and the cut between them is the feature.

I wanted the shape of data to be an ordinary feature, usable by anyone already building with sklearn or PyTorch.

Rust core, Python API persistent homology and Betti-curve features
  • Python and Rust
  • shape as a feature

faraday

The field coupling, found rather than assumed.

View on GitHub: faraday Read how it works in the faraday README
Two fields settle onto a fixed point, then their coupling rises An illustration of the idea, not the project's solver. Two wires pass through a sheet of glass. In the sheet, electric field lines in blue run from one wire to the other, and magnetic field lines in violet circle each wire, and the two families cross at right angles at every point. The fields are not drawn from a formula. Each cycle starts from a wrong field, and a contraction is applied to it again and again; its successive states are drawn in order, the earlier ones fading, and the lines narrow onto the one field that is its fixed point, whatever the starting guess. Only once the field has settled does the coupling appear: E × H, in amber, glowing in the sheet where both fields are strong and rising out of the glass along the wires. The Faraday tensor is computed directly and the coupling comes out of a topology fixed point projection, so it is never assumed. two fields, at right angles successive states settle onto one fixed point the coupling E × H is found, not assumed and it rises where the two fields meet Faraday tensor, coupling by fixed point projection
Two fields at right angles settle onto one fixed point, and only then does their coupling E × H rise where they meet.

I compute the Faraday tensor directly, so the coupling between the electric and magnetic fields is found rather than assumed.

computational Faraday tensor topology-fixed-point projection
  • Python
  • coupling, not assumption

nerve

The control that could kill my result.

View on GitHub: nerve Read how it works in the nerve README
One polymer chain, its one crossing, and four hypotheses tested against a control that could kill them An illustration of the method, not measured data. A polymer chain, drawn as a shaded tube of beads coloured from blue to violet, writhes slowly in three dimensions. Its outline is searched for crossings in every frame, and the one place where the chain passes over itself, drawn with a gap round the strand on top, is ringed in amber as its topological witness. Behind it, faint randomised chains are the control: they writhe too, and they cross themselves as well, which is why a crossing alone proves nothing. Below are four lanes, one for each hypothesis. The witness sends a blue bead down to each lane, the value that hypothesis measured on the chain, and then the same measurement taken on the control rains into the lane grain by grain and settles into a heap. Where the control's heap buries the bead, the control reproduces the result: three beads are buried and marked with hollow coral rings, withdrawn but kept on the record. One sits far out where the control never lands, and it survives. The control was built on purpose to be able to kill the result, and what it said was published either way: 3 of its own 4 hypotheses withdrawn, 224 tests passing. a polymer chain and its topological witness four hypotheses, each tested against its own control 3 of its own 4 hypotheses withdrawn when the control built to kill them said so 224 tests passing
One chain, one crossing. I tested four hypotheses against their own controls.

I built the control that could kill my own result, then published what it said.

224 tests passing 3 of its own 4 hypotheses withdrawn
  • Rust
  • 3 of 4 hypotheses withdrawn

separatrix

Decided by the data, not by rounding.

View on GitHub: separatrix Read how it works in the separatrix README
Every answer flows to one side of the separatrix, unless rounding decides the side An illustration of what separatrix certifies, drawn as a phase portrait. A flow with two attractors and a saddle between them carries every starting point to one attractor or the other, and the coral curve through the saddle, the separatrix, divides the two basins. Each start is known only to within rounding, drawn as a small disc. Where the disc lies wholly on one side, every value the rounding could have produced reaches the same attractor, so the answer was decided by the data: the particle is certified and rings as it settles. Where the disc touches the separatrix, inside the pale coral band, the disc slides into the saddle and is torn toward both attractors at once, so which answer comes back would be the arithmetic and not the data, and nothing is returned. Once a cycle a pulse runs along the separatrix into the saddle and parts toward both sides. The same test covers a top-k, an argmin and a threshold: certified or refused. decided by the data, or by the rounding? top-k, argmin and threshold, certified or refused clear of the separatrix: certified within rounding of it: nothing is returned the ordering would be the arithmetic, not the data
Every start flows to one side of the separatrix. If its rounding touches the curve, the side is the arithmetic and not the data, and nothing is returned.

I certify that a top-k or an argmin was decided by the data, and not by where the kernel happened to round.

top-k, argmin and threshold certified or refused
  • Python
  • decided by data, not rounding

planimeter

Exact, or refused.

View on GitHub: planimeter Read how it works in the planimeter README
The same 528 files, answered by planimeter and by shapely An illustration of a measured tally. Each small line drawing stands for one of the 528 constructed drawings whose endpoints sit microns apart, and the same 528 are drawn twice: planimeter's answers on the top sheet, shapely.polygonize_full's on the bottom. One wave passes through both sheets in step, a file at a time, and where it passes the strokes are laid down and the enclosed faces are found and filled. On top, planimeter fills a face only when its answer is exact, 495 times; 33 times it cannot give an exact answer, so it refuses, and the drawing is held open in amber at the junction where its endpoints nearly meet. Below, shapely fills every drawing and refuses nothing, and at first its whole sheet looks like a perfect result. Then a second wave checks every answer. On top nothing changes, because 0 answers are wrong. Below, 336 answers turn coral, scattered all through the sheet, because a wrong answer does not announce itself. The counts are the measured ones; which drawing sits where, and which are refused or wrong, is illustrative. the same 528 files, answered by both planimeter: 495 exact, 33 refused, 0 wrong shapely.polygonize_full: 336 wrong, 0 refused refusing is the price of never being wrong a wrong answer does not announce itself
The same 528 files: planimeter answers 495 exactly and refuses 33, while shapely.polygonize_full answers every one and gets 336 wrong.

shapely.polygonize_full returns 336 wrong answers on the files where planimeter returns none.

495 exact 33 refused 0 wrong shapely.polygonize_full: 336 wrong, 0 refused
  • Python
  • exact or refused

tangle

It refuses rather than guesses.

View on GitHub: tangle Read how it works in the tangle README
Two loops that cannot be pulled apart An illustration, not a measurement: two solid rings, one ink and one grey, linked through each other and turning without end. They roll, open and close on the line through their centres, and swing from side to side, passing through each other's hole, and once in every cycle they are pulled apart as far as they will go, catch against each other and are held. However they are turned they stay linked, and the linking number stays at one. The places where one ring crosses over the other in the picture are lit in blue: two crossings, one linking number. That is the certificate tangle issues, and it either exists or the answer is refused. two loops that cannot be pulled apart however they are turned, they stay linked linking number 1 a certificate, or the answer is refused 0 wrong certificates in 2,000 diagrams and 80 scenes
Two crossings, one linking number, and a certificate I can hand you.

I built tangle to never return a wrong answer. It refuses rather than guesses.

2,000 diagrams 80 scenes 247 photographs 0 wrong certificates
  • Python
  • certificate or nothing