A twenty year old tech lover who likes turning maths and ideas into solid code. Some of those ideas now live inside the codebases of companies like these.
WASD or arrows to slide · Shift to dash · click the snow to go there.Drag anywhere to steer. Tap a building to go there.
Hold W to slide · A D to turn · S back · Shift dash · E open
Pick one and the seal slides there.
Eleven landed contributions. Every number below was measured on a named machine against a control, and every one of them sits in a merged diff or on the default branch it targets.
A twenty year old tech lover who likes turning maths and ideas into solid code. Some of those ideas now live inside the codebases of companies like these.
A twenty year old tech lover who likes turning maths and ideas into solid code. Some of those ideas now live inside the codebases of companies like these.
Eleven landed contributions. Every number below was measured on a named machine against a control, and every one of them sits in a merged diff or on the default branch it targets.
84,033,568 bytes to 65,568 at ntree 4,096. 1,281.6x less.
Island discovery was allocating scratch that grew with the square of the tree count. I rebuilt it to compute the same partition from a disjoint-set forest, so the allocation grows linearly instead.
156.738 us to 101.097 us. Scratch 7,929,856 bytes to 180,224.
I found that the GPU island-discovery kernel carried the same quadratic memory shape onto the device. I replaced it with a linear-memory disjoint-set union.
16 lines added. 15,361x fewer probes at V=40,962. Cold load 134.400 ms to 71.163 ms.
Convex hull graph construction was scanning every pair of points to find a match. I built an inverted point-id table that finds it directly instead.
894,081,141 comparisons to 13,643,737 at one million keys. 65.5x.
I noticed the collision and scan tests were comparing key pairs the slice structure had already ruled out. I pruned by structure so those pairs never reach the compare.
MobileNet V1 peak 23.862980 to 22.331730 MiB. Workspace 144 MiB to 112 MiB.
I found the memory planner never considered the free gap sitting before the first live block. I made it reuse that leading gap, which lowers peak workspace.
Four control edges emitted where the unique transitive reduction is three.
I traced a correctness bug: transitive reduction was documented as full reachability but never back-propagated, so a redundant control edge with a longer alternate path survived the prune. I fixed the back-propagation so the prune removes it.
One unchanging scaffold now keys to one profile instead of one per task. 23 files.
I found the learning key included the first user message, so one unchanging system prompt and tool schema fragmented into a new profile per task and observations never accumulated. I keyed it on the stable scaffold instead, with a fingerprint gate that fails closed.
A topology derived sparse attention kernel. 804 lines added, 17 tests passing.
I built a forward-only Triton kernel that schedules causal attention blocks by a topology-derived salience score, instead of scanning every block in the lower triangle.
Five lines. Same program, two outputs before, one stable output after. XLA compiles for JAX and TensorFlow.
GroupDisjointReductions iterated a hash set to choose which value survived each union-find merge, so the order of grouped_roots depended on hash iteration order and the same XLA program could emit different GPU code between runs. I made the order deterministic in five lines.
145 lines changed across 4 files. pods, nodes and daemonsets access no longer granted cluster wide.
The API server ClusterRole rendered the same Kubernetes RBAC rules regardless of engine and provider, so an install that never reached the Kubernetes API, for example provider test with engine slurm, was still granted pods list, nodes get and list, and daemonsets get, cluster wide. I gated each rule on engine.name and provider.name.
208 two-module SCCs chained in one Rust test. The failure is pinned at the end with should_panic.
An export change can consume the 100 epoch incremental budget, produce another export change during forced invalidation, and reach commit with that change still pending. I generated a chain of 208 two-module strongly connected components inside one Rust test and recorded the resulting Transaction has uncommitted changes failure with should_panic, so the bug is pinned rather than argued about.
Attention and Markov paths share one operator.
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.
Memory, files and scheduler, on one sphere.
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.
Loops stop when their shape stops changing.
I built a language where a loop stops because its shape stopped changing, not because a counter ran out.
Hallucination, measurable with no ground truth.
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.
Can it be undone? Topology answers.
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.
The shape of data, as an ordinary feature.
I wanted the shape of data to be an ordinary feature, usable by anyone already building with sklearn or PyTorch.
The field coupling, found rather than assumed.
I compute the Faraday tensor directly, so the coupling between the electric and magnetic fields is found rather than assumed.
The control that could kill my result.
I built the control that could kill my own result, then published what it said.
Decided by the data, not by rounding.
I certify that a top-k or an argmin was decided by the data, and not by where the kernel happened to round.
Exact, or refused.
shapely.polygonize_full returns 336 wrong answers on the files where planimeter returns none.
It refuses rather than guesses.
I built tangle to never return a wrong answer. It refuses rather than guesses.
