The integer-multiplication exponent race: from 2^-182 to 2^-14.6 in forty hours

mdjsonmcpcopy↗ai

2026-10-08 · 97 min · math · theory · algorithms · agentic-coding · verifiers

Why read this

Solid· top 85%

The whole κ race in one place: where the exponent comes from, all 44 PRs timed, PR #13's certificate re-run and recomputed, and why it changes no runtime.

• Original analysis
• A new technique
• Explained from first principles

·Agents & harnesses·Runs on a laptop CPU·Apache-2.0·Research paper

How this was scored

Is it new?

2 of 3: A real new idea, method or capability

Can I trust it?

2 of 3: Measures key facts from files, code or configs

Can I run it?

1 of 3: API-only, gated or restrictive licence

Will I understand it?

2 of 3: Mechanism from first principles with figures

Can I act on it?

1 of 3: General advice

Will it last?

1 of 3: Relevant for months

Does it affect many?

1 of 3: A specialist community

Only here?

2 of 3: A teardown or measurement few others did

Score 55 of 100, ranked 327 of 476 rated articles. Each question is answered 0–3 by hand, and a 3 is rare. How articles are scored

The site owner sent me a link to CrocSwap/integer-mult-bounds with the note "something crazy going on in this repo". When I opened it, the headline said $\kappa = 2^{-30}$. By the time I had read the pull requests, the best open claim was $\kappa \approx 4.1\times10^{-5}$, a little above $2^{-15}$. When I started writing this paragraph, PR #45 had just arrived. By the time I finished the article, #48 had nudged the claim to $4.1186\times10^{-5}$, and Swapnil Jain, racing in a separate repository, had reached $3.67\times10^{-5}$ with its arithmetic checked in Lean.

Then, at 15:18 UTC, the story changed shape. Colkitt merged Rohan Arun's PR #39 into main, with $\kappa = 971668963/(2.5\cdot10^{13}) \approx 3.8867\times10^{-5}$, after an audit he published alongside it. For the first time a community number is the maintainer's number. It is still conditional on OpenAI's unrefereed manuscript, and the audit was Colkitt working with Codex, not a referee; the section on the merge goes through exactly what it checked. The open PRs had already moved past it: Rohan's own #49, under twenty minutes later, claims $4.1239\times10^{-5}$.

And it kept going after I thought I had finished. By 18:35 UTC main had moved twice more and stood at $5.1017\times10^{-5}$, after a new idea broke the plateau I describe below; the open PRs reached $5.1739\times10^{-5}$ an hour later. Aurel Prosz, one of the contributors, built a live dashboard of the whole thing. And Ryan Shea took Jain's network across to a second OpenAI problem, the exact discrete Fourier transform, and claimed a saving 730 million times OpenAI's. The evening and the Fourier transfer have their own sections near the end.

Then, overnight, the plateau broke for good. Between 23:12 UTC on 8 October and 05:06 the next morning, icekylinx's PRs replaced the shape of the network itself, and main jumped ninefold to $4.609169\times10^{-4}$, about $2^{-11.08}$. Jain followed twenty minutes later at $4.6637\times10^{-4}$, by building on the same cover, and the open PRs were at $6.5592\times10^{-4}$ when I stopped, at 11:00 UTC on 9 October. The ninefold night explains what changed, and why κ is still nowhere near 1.

The afternoon was quieter in ratio and busier in every other way. At 12:57 UTC Colkitt moved main again, to $6.61886\times10^{-4}$. Ten minutes later Jain posted round eleven at $6.6857\times10^{-4}$, which led every claim anywhere for nineteen minutes, and said he needed an arXiv endorser for a paper collecting the proofs. By 18:50 UTC the best open claim was $6.84697\times10^{-4}$, and several contributors had stopped chasing κ to prove how far the current designs can go at all. The afternoon covers all of that.

Some background. Two days ago OpenAI's math release included a 73-page manuscript, Integer multiplication below n log n (result family 109), which claims a multitape Turing machine that multiplies two $n$-bit integers in $O(n(\log n)^{1-\kappa})$ steps with $\kappa = 2^{-182}$. I covered it briefly in the openai/math roundup, and it has a tile on the AI breakthroughs in mathematics wall. Doug Colkitt (@0xdoug, the founder of CrocSwap/Ambient) forked the argument into a "research draft" and started tightening the constants. Then other people joined in. Counting $2^{-182}$ as the start, the exponent saving has grown by a factor of about $2^{167}$ in forty hours.

That sounds like a story about multiplication getting faster. It isn't one, and the reason is the most interesting part. What follows covers what $\kappa$ is, where it comes from in the construction, what each step of the race actually changed, what I could re-run myself, and why the very funny "linear time by tomorrow" chart that went round on X is wrong in an instructive way.

expand

What $\kappa$ measures

Schönhage and Strassen multiplied $n$-bit integers in $O(n\log n\log\log n)$ steps in 1971 and guessed that $n\log n$ was the true answer. Fürer got within a $2^{O(\log^* n)}$ factor of it in 2007. Harvey and van der Hoeven reached $O(n\log n)$ exactly (Annals of Mathematics, 2021), and most people took that to be the end.

The OpenAI manuscript claims a bound of

So $\kappa$ is the power of $\log n$ you get to divide out. At $\kappa = 0$ you have Harvey–van der Hoeven. At $\kappa = 1$ you would have linear time, which is the floor, since just reading the input takes $n$ steps. Every value in between is a strictly faster growth rate than $n\log n$. For the question "is $n\log n$ optimal?", $2^{-182}$ is as good an answer as $1/2$: any $\kappa > 0$ refutes the conjecture.

The machine model matters. The theorem is about a deterministic Turing machine with a fixed finite alphabet and a fixed number of one-dimensional tapes, the model in which Schönhage and Strassen stated their conjecture. On a tape, moving data costs time proportional to the distance it travels, so even rearranging $\Theta(n)$ bits at each of $\Theta(\log n)$ FFT levels costs $\Theta(n\log n)$. The manuscript says this outright: "Scanning an array of $\Theta(n)$ stored bits at each of $\Theta(\log n)$ transform levels already costs $\Theta(n\log n)$. We therefore need savings in both movement and arithmetic" (upstream/build/sections/00-introduction.tex).

Nobody had ever proved an $\Omega(n\log n)$ lower bound in this model. The best result is conditional: Afshani, Freksen, Kamma and Larsen (2019) showed that a circuit lower bound would follow from the network-coding conjecture, and a time-$T$ Turing machine only gives circuits of size about $T\log T$, so even that does not transfer. The FFT section of the roundup goes through the same gap for the Fourier transform, where the release's family 130 reuses this manuscript's finite gadget. The point to keep in mind is that $n\log n$ was a barrier nobody knew how to cross, not a proven wall.

Where $\kappa$ comes from

The pipeline is Harvey–van der Hoeven with every change of representation charged on tape: digits go onto prime cyclic axes by a Chinese-remainder map, Gaussian resampling turns those into power-of-two axes, and a phase twist turns the last axis into polynomials modulo $y^r+1$, where multiplying by a root of unity is just a signed shift.

expand

The new part is two tape procedures built from fixed linear networks. One swaps two address fields of an array; the other applies a layer of butterflies $(u+v)/2,\ (u-v)/2$ to selected coordinate bits. Each network is a finite circuit on $W$ "roles" (wires), it exchanges two banks of values while restoring every scratch value, and each edge of the circuit is carried out by smaller recursive calls of the same procedure. The decisive count is the total number $s$ of those smaller calls. If $s < Wm$, then multiplying the problem parameter by $m$ multiplies the normalized cost by $s/W < m$, and the recursion runs at $m^\tau$ with $\tau<1$. The manuscript: "This strict inequality is the source of the power saving."

How much below $m$ it lands is tiny. In the original construction the relative deficits are (upstream/build/sections/03-motifs.tex:673-678)

at $m = 10^6$, so the honest savings are about $10^{-12}$ and $2.7\times10^{-13}$. The manuscript then rounds them down to $1-\tau = 1-\sigma = 2^{-50}$ and calls its constants "deliberately conservative; no optimization is claimed". Remember that sentence. A lot of what happened next is people taking it at its word.

Those network savings feed a cost table. With $p \approx \log n$ the working precision, the paper divides every operation's cost by the data volume and gets a power of $p$. Seven rows dominate, and each has a margin $g_i$ below 1:

The total time is $n$ times $p$ to the largest power, so the exponent saving is the smallest margin, minus a sliver of slack to absorb stray $\log p$ factors. The upstream parameters are $\epsilon = 2^{-75}$, $c = 2^{-56}$ and $1-\tau = 2^{-50}$, so $g_2 = 2^{-75}\cdot2^{-56}\cdot2^{-50} = 2^{-181}$, and the paper says "Thus $\min_i g_i=2^{-181}=2\kappa$" (08-assembly.tex:866). That is where $2^{-182}$ comes from: three small numbers multiplied together, then halved.

The repository's checker transcribes the same seven margins as exact fractions (scripts/certify.py:136-147):

def margins(p, *, layout_model="adjacent", assembly_model="original"):
    require(assembly_model in ("original", "tight-gaussian"), "Unknown assembly model")
    e, c, t = p.epsilon, p.c, p.tau
    return {
        "g1": 1-e*(1+c),
        "g2": e*c*(1-t),
        "g3": e*(1-p.lamp),
        "g4": 1-t-e*(layout_degree(layout_model)-t),
        "g5": Q(1, 4)-p.delta-(Q(5, 4) if assembly_model == "tight-gaussian" else Q(3, 2))*e,
        "g6": 1-p.delta-e,
        "g7": e,
    }

Once you see $\kappa$ as a product of factors, the race is easy to follow. Every improvement attacks one of the factors: it makes the network saving $1-\tau$ bigger (better circuits), lets $\epsilon$ grow (better routing, better Gaussian resampling), lets $c$ grow (cheaper control movement), or changes the recurrence so the same circuit counts for more (batching). The widget below shows the seven margins on a log scale for the original paper, Colkitt's $2^{-30}$ checkpoint and PR #13. In the original, $g_2$ sits at $2^{-181}$ and nothing else comes close. By PR #13, $g_2$, $g_3$ and $g_4$ are all balanced at about $2^{-20.3}$, which is what a tuned parameter set looks like.

There is also a ceiling built into this shape. Since $g_7 = \epsilon$ and $g_1 = 1-\epsilon(1+c)$, the smaller of the two is at most $1/2$ whatever you choose, and $g_2$ is at most the bit network's saving $1-\tau$. In every witness I checked, $\kappa$ sits just under that network saving: $9.3\times10^{-10}$ against $4.67\times10^{-9}$ at the $2^{-30}$ checkpoint, $7.699\times10^{-7}$ against $1.54\times10^{-6}$ in PR #13, and $4.1006\times10^{-5}$ against $4.1008\times10^{-5}$ in PR #44. To get anywhere near linear time this method would need finite networks whose recursive calls nearly vanish, and nothing here suggests that is possible. The overnight witnesses of 9 October keep the same shape: in PR #144's assembly two margins are balanced against each other so that $\kappa \approx a/(1+2a)$, where $a$ is the weaker network's saving, and that saving is in turn about the network's relative rank deficit divided by how far below full width its average child sits on a log scale. The section on the ninefold night works through the numbers.

Colkitt's day and a half

Colkitt's own checkpoints are on main (the last one is also on release/ternary-30). Each came with an X post from @0xdoug, and each post's ratios check out against the exact witnesses.

The first note is the most honest thing in the repository. With the paper's cost accounting left alone, it finds $\kappa = 29/(5\cdot10^{33})$ and also proves a ceiling of $5.838\times10^{-33}$ for that family, so the witness is within 1% of the best that accounting allows. Colkitt's post said so: "Surpassing this ceiling would require improving the network bounds or cost analysis from the original result."

expand

So the next morning he changed the accounting. The original layout row costs $d^2(1+\ell^\tau)$ because it reverses axes with adjacent swaps; the manuscript already allowed nonadjacent swaps, and using them directly makes it $d(1+\ell^\tau)$. That changes $g_4$ to $(1-\tau)(1-\epsilon)$, which no longer forces $\epsilon$ to be smaller than the network saving. The result-history page explains the consequence: the original layout "forced epsilon < a, yielding a cubic constraint kappa < a^3", and the new schedule makes the saving scale "quadratically in a" (docs/research/result-history.md:253-256). Going from $a^3$ to $a^2$ when $a \approx 10^{-11}$ is how you gain thirty-odd powers of two in one commit.

The $2^{-59}$ step improved the network itself, which raises $a$: rectangle incidence circuits, then shared intermediate sums, cut the side roles per invocation from 41,122,620 to 2,394,438 and then to 577,576 at $h=46$, and paired-block circuits at $h=50$ reach 509,194. Fewer roles for the same rank deficit means a larger relative deficit, so a larger $1-\tau$.

The compact-control step at $2^{-34}$ attacked $c$. Moving whole spaced windows had a spacing penalty $K^\tau$ that forced $c$ to be of order $a$; moving only compact control fields removes it, so $c=1$ and $\kappa$ becomes roughly $\epsilon$ times $a$. His post that night put it in two sentences: "The improvement came from removing the spacing penalty behind the quadratic bottleneck. This was done by moving compact control bits instead of entire windows." Its "roughly 48 million fold improvement over the previous result" checks out against $2^{-59}$ (about $4.8\times10^{7}$), and so does "a 2¹⁴⁸ fold improvement over original OAI result" ($2^{148.5}$). Here the README discloses that the idea did not come from Colkitt: "The compact-control proposal originated with a separate research agent; the supplied note develops its tape, layout, repair and assembly arguments" (README.md:138-140).

expand

The last two checkpoints moved the bottleneck between the two networks. At $2^{-31}$ a compressed complex network ($h_c = 26$, $a_c = 5/10^9$) overtook the bit network's $296/10^{11}$, so the bit side became binding. The $2^{-30}$ checkpoint then replaced the bit circuit with one that computes over $\mathbb F_3$.

The $\mathbb F_3$ trick is pretty enough to show. Label the circuit's wires by the five-element subsets of 29 points, $n = \binom{29}{5} = 118755$ of them, and let $B$ be the incidence matrix of five-subsets against pairs. Then $(BB^{\mathsf T})_{ST} = \binom{|S\cap T|}{2} \bmod 3$, and for intersection sizes $0,\dots,5$ those residues are $0,0,1,0,0,1$. So $BB^{\mathsf T} = I + A_2$, where $A_2$ is the adjacency of subsets meeting in exactly two points, and the "side" map is just $-A_2$. A central factor of size $r = \binom{29}{2} = 406$ plus a correction that only touches intersection-two neighbours gives exactly the identity. I checked the residue identity by brute force over all 126 five-subsets of nine points; it holds.

expand

The full circuit has 19,593,239 active additions and 20,780,789 side roles per invocation, and the exact count gives $s/(Wm)$ with a relative deficit of $553/11717905300$. I recomputed the implied saving from the certificate's $W$, $s$ and $m$: $-\log_m(s/Wm) \approx 4.672\times10^{-9}$, just above the certified $a_{\rm b} = 467/10^{11}$. The final minimum margin is $2332833/2500000000000000$, which exceeds $2^{-30}$ by about 0.194% of the claimed saving.

That checkpoint was not first, and its README says so: "Zhihao Chen's earlier PR #7 introduces the same ternary five-subset motif with a different circuit and stronger claimed bound. This release records a separate implementation and conditional checkpoint; it makes no priority or strongest-known-bound claim."

Everyone else shows up

The first outside PR arrived at 20:58 UTC on October 7. Between 02:23 and 14:24 UTC on October 8, 42 more arrived, from about ten people. By 11:00 UTC on October 9 there were 179. The chart has all of them that state a κ: Colkitt's checkpoints in red, OpenAI's starting point in grey, the community PRs coloured by author, a green step line for the best claim open at each moment, and a red step line with a square at each move of main (#39 at 15:18 UTC, #49 at 16:47, a reviewed batch at 18:35, and icekylinx's #144 at 05:06 the next morning). Everything after $2^{-17}$ is squeezed into a sliver at the top, so the zoom button redraws everything from 10:00 UTC on October 8 on its own. Jain's separate track is the purple diamonds, with a ring on the rounds whose arithmetic is checked in Lean; more on that below. Click a point (or use the dropdown) for its title and link.

A few PRs changed the shape of the problem rather than its constants, and those are the ones worth understanding.

Start with eumemic's #3 and #5. #3 compressed the complex network, cutting its side wiring from 3,693,800 roles per invocation to 108,195 and taking its saving from $418/10^{12}$ to $14/10^9$. That made the bit network binding, and the next limit was the Gaussian resampling row: its cost $O(tp^{3/2+\delta}\alpha)$ forced $\epsilon < 1/5$ and capped $\kappa$ below $a_{\rm b}/5$. #5 rewrote the resampling as chirped correlations evaluated by the existing $O(N\log N)$ multiplier and bounded the Neumann series more tightly, which let $\epsilon$ approach $1/2$. That one change of analysis was worth a factor of about 2.5 on its own.

Zhihao Chen's #7 is the $\mathbb F_3$ five-subset construction, at $h=28$, posted at 06:12 UTC, seven hours before Colkitt's independent version. Chen's PR credits "GPT-6 Astra (OpenAI Codex)" for "research, proof-development and implementation assistance" and asks that future work "explicitly acknowledge Zhihao Chen (jacklightChen), cite this PR and its accompanying note". The maintainer did.

icekylinx's #10 is the structural break you can see on the chart: from $2^{-28}$ to $2^{-23}$ in one PR. Upstream, every edge of the network costs singleton recursive calls, one per unit of rank. #10 shows that a contiguous block of $t$ address fields from a projector can be done as one recursive call of width $t$, given a common controlled basis. The recurrence condition stops being a count and becomes a moment: with rank-mass weights $w_i$ on calls of relative width $r_i$, you need $\sum_i w_i r_i^{-a} < 1$. A singleton call has $r = 1/m$ and costs the full $m^a$; in #13's profile, a block covering 195/196 of the fields costs almost nothing extra. The same PR fixes an error-enclosure gap it found in #5's fast Gaussian argument, with no change to the exponent.

eumemic's #13, the one the site owner pointed at, is a neat idea. The network's correctness condition only needs each role's endpoint frames to differ by the identity: $M_{\rm sink} - M_{\rm source} = I$. A scratch role does not have to start in the zero frame. It can start in any fixed frame $M$ as long as it ends in $I+M$. Starting every stage-two auxiliary role in the frame of its first gate deletes its rank-756 entrance edge and turns its exit into one projector of rank $m-h$. That projector compiles to $h$ singleton pivots plus one contiguous block of $m-2h$ fields. The total rank is unchanged. What changes is where it sits: out of singleton calls costing $\ln m$ each and into one block. Under #10's moment, the interchange saving goes from $246/10^9$ to $154/10^8$, and with a third whole-residual class on the complex side, $\kappa$ goes from $6149999/(5\cdot10^{13})$ to $7699/10^{10}$, a factor of 6.26. Since $\log_2(7.699\times10^{-7}) \approx -20.31$, the claim is about $2^{-20.3}$; the title's "$> 2^{-21}$" undersells it.

expand

After #13 the tempo picks up. #15 brought a smaller $h=30$ producer, #18 partial swaps, and #21 and #23 translated frames and "semantic precision", reaching $1099/10^8 > 2^{-17}$. #29 introduced a two-stage topology from Aurel Prosz's work and reached $15536/10^9 > 2^{-16}$. #36 added copied retained centers, which halve one rank term ($Wm-N+2L$ becomes $Wm-N+L$) and jump to $3.84569\times10^{-5}$. Everything after that is composition and tuning: fixed local bases, reversed corners, carrier matchings. PR #44 claims $2050314627/(5\cdot10^{13}) \approx 4.1006\times10^{-5}$, which it describes as "approximately 0.02681% above #43". The last three PRs are within 0.03% of each other. Three more arrived while I was writing: chafreaky's #46 adds 0.0000048% to #44, Rohan Arun's #47 adds 0.109% with hill-climbed producers, and chafreaky's #48 reorders the leave-one-out sums to save 847,550 wires and reach $411862541/10^{13} \approx 4.1186\times10^{-5}$. Then Rohan's #49, at 15:36, started from #48's orderings and hill-climbed them the way #47 had, for $4123863984/10^{14} \approx 4.1239\times10^{-5}$, 0.127% more. The step line flattens around $2^{-14.6}$ after 12:30 UTC.

When I first wrote this section I called that flattening the most informative thing on the chart, and said it was what you would expect if the cheap structural moves inside this family of constructions had mostly been made. Three hours later Avi Eisenberg's #53 jumped 9.2% in one PR, and the step line climbed again to $2^{-14.24}$. Use the zoom to see both plateaus; the evening section explains the move that broke the first one. I'd still read the flat stretches the same way, only with less confidence about how long any of them lasts.

Re-running PR #13

The brief asked me to check the claims, and these are certificate checks I could actually run: pure Python with fractions, plus a small C++ helper on the PR branches, no network. On a shared 16-core machine at nice 19:

On main at 1a74950, the focused verification from the README. scripts/audit_ternary_side.py builds the full $h=29$ DAG (about 21 million addition nodes) and finished with PASS ternary side construction and conditional 2^-30 assembly. in 176 s at 1.6 GB peak memory. make_ternary_patch.py took 17 s, the 12 focused tests passed in 39 s, the patch applied to the pinned upstream source, and the regenerated certificate and patch were byte-identical to the committed ones.

On PR #13 at 3ef246f, scripts/source_frame_network.py runs in 0.1 s and prints the witness:

PASS kappa=7699/10000000000 > 2^-21
bit saving=77/50000000; complex saving=9/5000000
bit moment gap=4.69651719166272e-10
complex moment gap=3.899666592614166e-09
minimum margin=3849992299500001/5000000000000000000000; gap=492299500001/5000000000000000000000

The regenerated certificates/source-frame-network.json compared equal to the committed one. The six tests in tests/test_source_frame_network.py, including an exact $h=5$ model in which the new exit is checked to be an idempotent of rank $m-h$ with exactly $h$ corner pivots, passed in 20 s. The full make verify on the PR branch took 432 s: 172 tests passed, all 19 manuscript patch checks applied, and the certificates and patches regenerated without a diff. Those numbers match what the PR description claims.

Then I recomputed the arithmetic myself, without the repository's helpers. From the certificate's parameters ($\epsilon = 499999/10^6$, $c=1$, $1-\tau = 154/10^8$, $1-\lambda' \approx 1.54\times10^{-6}$, $\delta = 10^{-10}$) the margins are $g_2 = 38499923/(5\cdot10^{13})$, $g_3 = 3849992299500001/(5\cdot10^{21})$ and $g_4 = 38500077/(5\cdot10^{13})$, all about $7.70\times10^{-7}$; $g_1$ and $g_5$ are about $2\times10^{-6}$, and $g_6$ and $g_7$ about $1/2$. The minimum is $g_3$, which beats $\kappa = 7699/10^{10}$ by $492299500001/(5\cdot10^{21}) \approx 9.8\times10^{-11}$. So the claimed $\kappa$ does follow from the margins.

The bit-moment check is the step that carries the new idea, so I redid it at 80-digit precision rather than with the script's $e^x \le 1/(1-x)$ bound. Here is how the script does it (scripts/source_frame_network.py:54-62 on PR #13):

def moment(weights, ratios, a):
    """Upper bound for sum_i w_i ratio_i^(-a), using exp(x) <= 1/(1-x)."""
    logs = []
    for r in ratios:
        simple = SIMPLE_LOGS[r]
        require(log_upper(1/r) < simple, 'Rational logarithm bound failed')
        require(0 <= a*simple < 1, 'Exponential upper-bound range failed')
        logs.append(simple)
    return sum((w/(1-a*ell) for w, ell in zip(weights, logs)), Q(0)), logs

The four classes have weights of about 0.0044 (singletons, relative width $1/21952$), 0.4934 (width $195/196$), 0.0076 ($10165/10976$) and 0.4946 ($391/392$). With $a = 154/10^8$ the moment is $1 - 4.78\times10^{-10}$, below 1 as required, and bisection puts the largest saving this rank profile supports at about $1.5499\times10^{-6}$. PR #13's $1.54\times10^{-6}$ leaves about 0.6% headroom.

None of this checks the hard part. The certificates confirm that the counts, ranks and inequalities are what the notes say they are. They do not confirm that a contiguous projector block really can be executed as one recursive call on a fixed-tape machine, that the controlled basis exists at full size (the review guide for #10 says it is "established by the existence argument, not by materializing every h28 factorization"), or that the upstream theorem is true. Colkitt's own review index was clear, that morning, that this was still open: "These changes appear to cross the singleton-rank recurrence limitation; the headline alone does not establish that step." By the afternoon his audit had worked through those obligations for the one chain he merged, #39's (below). For #13's own construction and every PR outside that chain, the sentence still stands.

A second race, one repository over

While those PRs were landing, Swapnil Jain (@SJ_Swapnil_Jain) was running a race of his own. He never opened a PR on Colkitt's repository; none of the 13 accounts that did is his. He kept Swapnil-jain/integer-mult-kappa, posted six numbered updates on X between 07:20 and 14:03 UTC, and the sixth ended with a sentence nobody on the CrocSwap side could write about their frontier: "Both interchange certificates and the full assembly are checked in Lean's kernel." I cloned it and read all of it, and I wanted to know two things. Is this really a separate result, and what exactly did Lean check?

I lined the six posts up against what was open on CrocSwap at the same minute. The witnesses are the exact rationals from the commit each post announced; they are the purple diamonds on the chart above.

So he held the lead twice: for about an hour after his first post, until icekylinx's #10 at 08:26, and for nineteen minutes after his third, until Zhihao Chen's #21 at 10:24. His fourth post went out one second after #28 was opened. From round five on, the CrocSwap side was ahead, by 2.5 times at 12:39 and by about 12% at 14:03. His own ratios check out: round six is 2.37 times round five, and $2^{-182}$ to $3.67\times10^{-5}$ is a factor of $2^{167.3}$. The one soft spot is the first post's comparison with Colkitt's $8.3\times10^{-11}$ ("a roughly 60 fold improvement"): by then Colkitt's main was already at $2^{-31}$, so against the newest checkpoint it was about ten.

"Independent" is the wrong word for it, and Jain doesn't use it. His NOTICE pins Colkitt's 6e56487 and cites fourteen open CrocSwap PRs (#3 through #36) plus Aurel Prosz's fork. Round four reads PR #24's published network counts from a JSON file pinned by SHA-256. Round six's copied centres are, in the first sentence of his note, "PR #36's copied retained-centre schedule (icekylinx)" applied to his network. The traffic went the other way as well. Chen's #29 and Rohan Arun's #31 credit "Swapnil Jain for the linked two-stage batching development", icekylinx's #36 links Jain's round-three commit with the line "no source code imported from this repository", and #44 and #47 list him with everyone else. These are two forks of the same argument, reading each other's work all morning.

expand

What is his is the part of the stack that turns a network saving into $\kappa$. Through PR #13, $\kappa$ sat at about half the bit network's saving: $7.699\times10^{-7}$ against $1.54\times10^{-6}$. His README explains why. A few costs tie the saving either to the number of axes $d$ or to the axis width $\ell$, with $d\ell \approx \log n$, so the saving gets split between them, and the Gaussian resampling's precision budget, about $8d^2$, has to fit inside $O(\log n)$, which keeps $\epsilon$ below $1/2$. His first round made five changes at once. The coefficients become $(\log n)^{1+x}$ bits long instead of about $\log n$, so precision no longer competes with address length. The Gaussian correction is inverted block by block (every block is "the same Toeplitz matrix up to a geometric rescaling, so one stored inverse serves the whole line", as the second post puts it). Each axis becomes one chunk, only the low bits of an axis are moved for resampling, and the axis reversal reuses Colkitt's selected-bit additions. With all of that, $\epsilon$ can go almost to 1, and that is the "ε → 1" in every post.

expand

I recomputed the round-six witness from the numbers in his certificate, without his code. The bit saving is $a_{\rm b} = 36667/10^9$, the complex saving $a_{\rm c} = 36926111/(5\cdot10^{11})$, so $\tau = 1-a_{\rm b}$ and $\lambda' = \tau + 2\cdot10^{-16}$. He sets $\epsilon = 2499908335861049/(2.5\cdot10^{15}) \approx 0.9999633$. Of his five cost margins, $1-\epsilon$, $1-\epsilon$ minus a $10^{-22}$-sized term, and $\max(\epsilon,1-\epsilon)(1-\tau)$ all come to $3.6665655580\times10^{-5}$ and a bit; $\epsilon(1-\lambda') \approx 3.666565558020684\times10^{-5}$ is the smallest; and $\epsilon$ itself is about 1. The claimed $\kappa = 3666565558019/10^{17}$ sits $1.7\times10^{-17}$ under the binding margin. The tidy way to say it: $\epsilon$ is chosen so that $1-\epsilon = \epsilon\,a_{\rm b}$, which makes $\kappa = a_{\rm b}/(1+a_{\rm b})$ to eleven digits. Every bit of the network's saving reaches $\kappa$.

The CrocSwap side got to the same place by another road. RaD/hipotures' #20 and Chen's #23, at 10:20 and 10:43 UTC, used "completed-child semantic precision" and bulk resampling, and neither cites Jain. Round four is a neat accidental experiment. Jain and Dominik Scholz's #27 took the same PR #24 bit network, with $a_{\rm b} \approx 1.19724\times10^{-5}$, put it through their two different assemblies, and got $1.19722292\times10^{-5}$ and $1.19720853\times10^{-5}$. Both stacks now pass essentially the whole network saving through, so the 12% gap between 3.67 and 4.12 is entirely the bit network: $36667/10^9$ here against #48's $82375901/(2\cdot10^{12})$.

The ε → 1 stack also has a price that the headline hides. With $\epsilon$ near 1, the coefficient-depth guard needs $\epsilon C_1 < 1+x$. Round six uses the crude guard $C_1 = 14694$ (from $2 + 576\ln 119453132304 \approx 14693.6$), so $x = 14695$ and each coefficient is $(\log n)^{14696}$ bits long. In round five the same rule gave $x = 842135$. That is legal, because $x$ is fixed and the volume stays $\Theta(n)$, and his certificate says as much ("The exponent is huge but fixed, so the O() statement holds", scripts/certificate_round3.py:15). It is one more reason the runtime section below holds for this track too. The stack notes also list "deliberate departures from upstream hypotheses": the prime number theorem replaces the manuscript's explicit interval lemma, the resampling hypothesis is weakened, and so on. So this track rests on more than the CrocSwap PRs do: the manuscript, the fourteen PRs it cites, and its own replaced hypotheses.

What the Lean files prove

There are two, lean/Round5.lean and lean/Round6.lean, and neither is written by hand. lean/gen.py emits them from JSON files that dump.py and dump6.py write out of the Python certificates. They are core Lean 4: no import, no Mathlib, no lakefile and no lean-toolchain, so no version is pinned; make lean runs lean lean/Round6.lean with whatever is on the PATH. Rationals are pairs of naturals with a hand-written gcd normalisation, $\ln$ is a 30-term atanh series with a geometric tail bound, and each file ends in five theorems. Round six's, from lean/Round6.lean:74-81 with the histogram lists cut:

theorem bit_rank_sum : rankSum bitHist = 78410006675 := by decide
theorem bit_moment : momentOK bitHist (36667, 1000000000) 529 148225616 = true := by decide
theorem cx_rank_sum : rankSum cxHist = 119453132304 := by decide
theorem cx_moment : momentOK cxHist (36926111, 500000000000) 576 207387136 = true := by decide
theorem kappa_assembly : kappaOK (36667, 1000000000) (36926111, 500000000000) (1, 1000)
  (2499908335861049, 2500000000000000) (14695, 1) (14694, 1)
  (3666565558019, 100000000000000000) 576 119453132304 = true := by decide +kernel

There is no sorry, no axiom and no native_decide in either file. Both decide and decide +kernel end in a proof term that the kernel checks; +kernel only skips the elaborator's own evaluation first. native_decide would have compiled the decision procedure and trusted the compiled code, and it isn't used. The kernel does use GMP for natural-number literals, which is part of Lean's normal trusted base. So yes, it really is the kernel.

The more important question is what the theorems say. They say that three particular Boolean functions return true on particular lists of numbers. They do not say those lists are the child-width histograms of the networks; gen.py pastes them in from Python. They do not say lnUp bounds the logarithm or that the moment sum controls the recurrence. The generator's docstring is explicit: "The analytic facts behind (2) and (3) -- the atanh tail bound and (m/w)^a <= 1/(1 - a ln(m/w)) -- are premises, not checked here: Lean core has no real logarithm." And kappaOK encodes his own five-margin cost table, transcribed from certificate_round3.py; whether those five margins are the right costs is a question for the written notes. The upstream theorem isn't in it at all. His README is honest about this; its evidence table lists the full upstream multiplication theorem as "Assumed" and independent review or formalisation as "Not supplied". So "checked in Lean's kernel" means that the arithmetic the Python fraction certificate already did has been redone by a much smaller and better-trusted checker. The check is real, and narrow.

I couldn't run it: there is no Lean toolchain on this machine, and I wasn't going to install one for this. So I wrote the five definitions out again in Python on integer pairs, including Lean's qsub, which is natural-number subtraction and quietly floors at zero, and evaluated the theorems on the committed inputs. All five come out true, and no subtraction ever hits the floor. The bit moment sum is $1 - 2.79\times10^{-10}$ of its bound and the complex one $1 - 7.9\times10^{-14}$. At 80-digit precision, with the real exponential, the largest bit saving this histogram supports is about $3.66702\times10^{-5}$, so the claimed $3.6667\times10^{-5}$ leaves 0.009% headroom; round five's file checks out the same way.

Lean wasn't new to the race, either. princezuda's #26 on CrocSwap, at 10:54 UTC, brought Lean 4 v4.21.0 with Mathlib ("no sorry and no native_decide") and 310 theorems over the certificate arithmetic of PRs #3 to #12, and it found one misstated ceiling. alejandrozu's #45 adds a Lean-checked Gaussian parity audit. But no CrocSwap claim after #12 has its arithmetic in Lean, and Jain's last two rounds do.

His Python checkers all ran. make verify took 194 s at 750 MB peak and passed everything, including 23 unit tests and a deliberately broken inverse that has to fail and does. independent/complex-twostage/run.py 24 took 39 s: 140,064 edges, 0 bad labels, and $a_{\rm c} \ge 73861113/10^{12}$, slightly more than the $36926111/(5\cdot10^{11})$ the assembly uses. scripts/certificate_round6.py gave $a_{\rm b} = 36667/10^9$ at $h = 23$. The histograms these scripts regenerate are identical to the ones pasted into Round6.lean, so the Lean file and the Python checks are about the same objects.

Where that leaves the race, at 15:46 UTC: the highest claim is Rohan Arun's #49 on CrocSwap, $4.1239\times10^{-5}$, 12.5% above Jain's $3.6666\times10^{-5}$. The number on CrocSwap's main, #39's $3.8867\times10^{-5}$, is 6% above Jain's. So there are now three kinds of checking on the board: Jain's arithmetic in Lean, main's new steps read through by its maintainer, and the open PRs' own Python certificates. And main's README now credits Jain, with Aurel Prosz, for "attributed two-stage development and the paid copied-stream endpoint construction", so the two races have formally met. I don't think the difference in arithmetic checking matters much, because the arithmetic was never the likely point of failure. Lean makes "the numbers add up" airtight; it says nothing about whether a contiguous projector block really is one recursive call on a tape, or whether the manuscript underneath is right. Jain said it himself, replying to someone who asked for the unconditional value: "Nothing past OpenAI's result is unconditional yet."

PR #39 reaches main

Rohan Arun opened #39 at 12:58 UTC, "Fixed middle basis and copied reversed corners", at $3.8867\times10^{-5}$. It was never the best open claim for long; his own #40 beat it by 0.82% seventeen minutes later. But at 13:23 Colkitt had pinned it, head 70ae241, in a merge commit (fd8c563) on an integration/community branch, and he spent the next two hours on it. At 15:12 UTC he committed "Complete conditional audit of the PR39 community witness". At 15:18 the release commit 0605a24, "Publish audited community bound with contributor attribution", moved main, the tag community-kappa-15-2026-10-08 went on it, and GitHub marked #39 merged. Since #39 was stacked on earlier work, the same push also marks icekylinx's #10, #18, #24, #32 and #36 and Rohan's #37 as merged; their commits are in its history. Twelve minutes later Colkitt posted:

Validated and merged Rohan's PR. Big gain on a really difficult regime (that frankly I was stuck at). Incredible work.

The maintainer admitting he was stuck, and that someone else's agent-assisted PR got him unstuck, is my favourite sentence of the whole episode. His headline, "κ = 2⁻¹⁵", is the floor the witness clears rather than its value; the exact number is $2^{-14.65}$, which the README puts at "27.36% above 2^-15". His "500 thousand fold improvement over the previous result" checks out against $83/10^{12}$, the last exact witness he had posted (about 468,000-fold). Against the $2^{-30}$ checkpoint that main carried until 15:18 it is about 42,000-fold. The "2 ^ 167 fold improvement over the original OpenAI result" is right: $2^{167.35}$.

What did "validated" mean? The audit, docs/research/community-final-audit.md, is plain about who did it. Its header reads "Reviewed by the project's Codex assistant for Douglas Colkitt", and it calls itself "a maintainer mathematical assessment, not independent human peer review or formal verification." Within that, it is a real proof review, and it goes after exactly the obligations my PR #13 check said the certificates never touch. It works through the partial-swap compiler's block algebra; the claim that one fixed basis serves every gate (each required minor is a nonzero rational function on one irreducible family, so a single rational basis avoids every exceptional set); the copied-centre schedule restoring both operands for arbitrary dirty values; the complex side's phase compiler; the semantic-precision recurrence; the arbitrary-coordinate router; the Gaussian inverse; and the bulk tape schedule. In one place it swaps in a published theorem, Baker, Harman and Pintz on primes in short intervals, and labels it "an actual new input". Its verdict: "no unresolved additional construction or inequality was identified that blocks this particular witness."

The executable side is separate. The audit added its own checker, scripts/audit_community_candidate.py, which imports none of the contributor's code, encloses both recursive moments with 80-term rational logarithm bounds, rebuilds all seven margins, gets the same final gap of about $6.25\times10^{-15}$, and shows that the next bit saving on the $10^{-14}$ grid fails. It reports 218 tests, 20 upstream patch checks and certificate regeneration in Docker (GCC 13.3, Python 3.12), a GitHub Actions run on Python 3.11, 3.13 and 3.14, a one-header GCC build fix, and 20 files missing from a vendored manifest restored from PR #34 at their recorded hashes. I re-ran make verify on 0605a24 and it passed, 218 tests and all, in about sixteen minutes (How I checked has the details).

Two limits are written into the audit itself. "The original OpenAI #109 framework ... remains assumed." And "PR40 and subsequent submissions are outside this pinned review." So main is deliberately behind the frontier, by 6.1% when #49 arrived.

Main moves again

I thought the merge was the end of the story. When I fetched everything again at 19:46 UTC, main had moved twice more, 28 more PRs had arrived, a contributor had built a live dashboard for the race, and the race itself had jumped to a second problem.

The first move was routine. At 16:47 UTC GitHub marked Rohan's #49 merged, together with #43, #45, #46, #48 and princezuda's Lean PR #26, and the README went to $4123863984/10^{14}$. It was behind again at once: Rohan Gupta's #50 and RaD's #51 had been open for half an hour with higher claims.

The second move is the one that broke the plateau. Avi Eisenberg's #53 (he is ikeboy on GitHub), opened at 16:31, changes nothing except the scalar producer. Every vertex of the network needs its leave-one-out strip sums: given $k$ values, all $k$ sums that leave one of them out. The usual way builds prefix sums $A$ and suffix sums $B$ and takes $s_j = A_{j-1} + B_{j+1}$. Each prefix then has two consumers whose envelopes don't nest, so its second use always costs a fresh wire. #53 shifts the bracket by one, $s_j = A_{j-2} + (v_{j-1} + B_{j+1})$, and now the two consumers of a prefix are nested, so the carrier matching from #44 can keep the existing wire going instead of allocating a new one. It costs more additions (40,329 against #48's 37,098 at $h = 23$), but the carrier links double, from 6,002 to 12,719, and the roles drop from 36,432 to 32,946. It bought 9.2% in one step, after three hours in which every PR had gained a few hundredths of a percent. I like it because it is counter-intuitive: more arithmetic, fewer wires, and fewer wires is what $\kappa$ actually pays for.

After that the ideas stacked. eumemic's #57 compiles every group of operations that share a frame as one invertible binary map and pays to reclaim retired wires, which takes the physical wire count from 160,799,739 to 153,481,944. Eisenberg's #62 replaces the strips with every cyclic interval, each built from an interval one item shorter. It needs $k(k-2)+1$ additions instead of about $4k$, but almost every one of them continues a carrier. On its own it claims $4986133/10^{11}$, and with #57's compiler on top, $5101691/10^{11}$. Alejandro Zarzuelo Urdiales's #61 then refined the parameters on that same graph, by $1.0170078\times10^{-11}$, with the arithmetic checked in eleven Lean proofs.

At 18:35 UTC, Colkitt merged #50 to #62 (all except Rohan Garg's #59, which is kept as a reviewed alternative) in one push. main now reads

23.7% above the #49 release and 31% above #39's. The network underneath has changed too: the bit side now runs at $m = 575$ on dimensions 23 and 25, with 137,151,806 physical roles.

The review behind it, docs/research/community-round2-review.md, again calls itself "a conditional maintainer review with Codex assistance, not independent human peer review or a formal proof of multiplication." It reads more like a replay ledger than the #39 audit did. Each PR gets a disposition ("Full pinned replay passed", "Complete word and profile replay; used by selected witness"), and the places it holds back are stated. #51's separate witness had its "arithmetic … freshly replayed, but its entire standalone source-graph and negative-basis data argument was not", and #62's claims that its layout is optimal "were not independently reproduced". The general residual compiler, the all-size recursion, the tape implementation and the analytic transfer "remain written inherited obligations, not consequences of a successful finite test alone." So this move rests on finite replays plus reading, on top of interfaces that were audited at #39.

The same afternoon, main imported Jain's repository whole: 87 files, pinned by SHA-256, under research/swapnil-parallel/. It did the thing I couldn't. It compiled both Lean files under Lean 4.31.0, checked that the generator reproduces them byte for byte, and inspected all ten theorems, none of which depends on an axiom. Its reading of what they prove matches mine: they "do not formalize logarithmic analytic bounds, construct a Turing machine, or prove integer multiplication end to end", and the fixed-tape side of the ε → 1 stack has "not received a complete independent audit in this pass." It also notices something that matters for the next section. Jain's complex network saves $36926111/(5\cdot10^{11}) \approx 7.385\times10^{-5}$, more than the 7.17e-5 of the complex network main uses, but main's bit side binds at about $5.10\times10^{-5}$, so the better complex network would not move the headline. Jain himself has not posted a seventh round. His last commit is still round six, at 14:01 UTC.

The open PRs didn't wait. Fifteen more arrived between 18:05 and 19:46. Dominik Scholz's #63 and rfu08's #64 published the same construction within fifteen minutes of each other, and #64 says so ("Both decompressed words, complete profiles and finite bridge are identical"). The best open claim when I stopped was Scholz's #76, opened at 19:44, which combines three other open PRs (#70, #71 and #74) to reach $51738676045141/10^{18} \approx 5.1739\times10^{-5}$, 1.4% above main.

So at 19:46 UTC the board reads: main at $5.1017\times10^{-5}$, the best open claim at $5.1739\times10^{-5}$, and Jain at $3.6666\times10^{-5}$, now 28% behind main. There have been 77 PRs from 20 accounts; GitHub marks 25 merged, 47 are open and 5 were closed without merging. The last fifteen open claims sit between 5.10 and 5.17 times $10^{-5}$. It's a plateau again, and I'm no longer going to predict how long it lasts. (About three hours, it turned out.)

A dashboard, built by one of the racers

At 15:13 UTC Aurel Prosz (@aurel_pr, Paureel on GitHub), whose two-stage topology and endpoint correction run through half the PRs above, posted a live tracker: Beyond n log n. Colkitt shared it fifty minutes later as an "awesome dashboard from the great @aurel_pr". The site owner's reaction was "damn, things are getting serious", which is fair. The page names no author in its text, but its footer links to Paureel, and the source is open at Paureel/beyond-n-log-n.

expand

It is a React app with a Netlify function that re-reads GitHub every 15 minutes. It covers every PR in every state, all 26 public forks and the 6 PRs inside them, each checkpoint in main's history, a "field map" of which areas of mathematics each PR mentions, and an idea-lineage graph built from explicit reuse language in the PR descriptions. The $\kappa$ values are parsed from PR titles and bodies, so they are claims, and the methodology box says as much: "No full-theorem verification is inferred from tests or certificates."

I pulled its JSON (/api/research, fetched at 19:33 UTC) and compared it with my chart. All 46 PR claims from #1 to #49 agree to within 0.2%, which is the rounding in my labels. There are two real differences. The tracker puts OpenAI's $2^{-182}$ at the openai/math commit time, 21:58:50 UTC on October 6, where I had used the 3:19 PM Pacific (22:19 UTC) printed on Julian Schiavo's chart. I checked the commit and moved my point to match. And its "repo checkpoint" line steps at the commit times of everything in main's history, including contributors' commits that came in through merges, so it has main at 4.1239e-5 from 16:16 UTC (ed8201c), where I use 16:47, when GitHub marks the merge. Both choices are defensible. Its 19:33 snapshot also predates #75 to #77, so it showed #71 as the leader.

The race reaches the Fourier transform

At 16:52 UTC Ryan Shea (@ryaneshea) posted:

We're publishing a research draft on OpenAI Problem #130: computing the exact discrete Fourier transform below n log n. Our draft proposes an all-length bound of T(n) = O(n(log n)^(1−δ)), with δ = 7.3×10⁻⁵. That's a 730-million-fold increase in the exponent saving over OpenAI's published δ = 10⁻¹³.

The repository was created at 15:26 UTC with Shea's own earlier construction, a reduced centre and shared sums, worth about $5.5\times10^{-10}$, or roughly 2,600 times the saving OpenAI's construction actually achieves. An hour later, at 16:27, he replaced it with Jain's round-six complex network and got $7.3\times10^{-5}$. Asked whether this was AI-assisted, he replied: "The heavy lifting was AI, and I shepherded it towards the improvements."

Why should a network built for multiplying integers say anything about the FFT? The roundup's FFT section explains it. OpenAI's explicit Fourier paper (family 130) takes its finite gadget from the multiplication manuscript. The saving lives in one place: an algorithm that applies $C^{\otimes k}$, tensor powers of the fixed $2\times2$ matrix $C = \tfrac12\begin{pmatrix}1+i&1-i\\1-i&1+i\end{pmatrix}$, in $O(2^k(k+1)^\theta)$ with $\theta < 1$. That algorithm is the same frame-labelled network on arbitrary roles that the race has been tuning: swap two banks, restore every scratch wire whatever it held, and count the dimensions of the frame changes. The rest of the Fourier proof (Good–Thomas reindexing, exact-width local words, synchronisation into sectors, a Bluestein chirp) uses the tensor routine only through that cost bound. The draft's whole argument rests on this. By its reading, Proposition 4.2 of the Fourier paper uses the tensor routine only through the bound $O(2^k(k+1)^\theta)$ on arbitrary complex arrays. So a better network gives a better $\theta$, and $\delta$ is anything strictly below $1-\theta$.

expand

What crosses over is narrow, and the draft is careful about it. It takes only Jain's complex network at $h = 24$: 2,024 triples, $m = 576$, $W = 207{,}387{,}136$ roles and a total child width of $s = 119{,}453{,}132{,}304$, with icekylinx's whole-residual batching (#10), the copied centres from #36 and Prosz's two-stage endpoint correction, all credited. It does not take the bit network, the ε → 1 stack, the Gaussian resampling or any of the tape and precision analysis. Its audit says it "does not use Jain's integer-specific epsilon stack, bit-interchange bound, Gaussian recovery or tape precision analysis".

So the Fourier number comes out large next to the multiplication race, and for a structural reason. In #109, $\kappa$ is the smallest of seven margins and the bit network binds; Jain's complex saving was slack. The Fourier model is exact complex arithmetic with word-sized addresses. There are no tapes, no bit network and no $\epsilon$ to share the saving with, so $\delta$ can sit just under the complex network's own saving, $a = 36926111/(5\cdot10^{11}) \approx 7.385\times10^{-5}$. In the draft's words: "There is no integer-multiplication bit-network constraint or extra factor-of-two loss in this transfer." The half of Jain's work that never mattered for his own $\kappa$ is the half that matters here. It is also the best complex network on offer: as noted above, main's own is 7.17e-5.

I checked the numbers. From the draft's role counts, $W = 2N + 2vR$ with $N = 2024^2$ and $R = 49{,}208$ gives 207,387,136, and $Wm - N + L$ gives the stated $s$. The deficit is $Wm - s = 1{,}858{,}032$, and the 25-row histogram in Section 6 sums to the same $s$, the rank sum that Round6.lean checks for the complex side. With exact fractions, $a - \delta = 426111/(5\cdot10^{11}) \approx 8.5\times10^{-7} > 0$, which is the gap that swallows the extra $(\log\log n)^{4-\theta}$ factor. At 80 digits with the real exponential, the moment at $\theta = 1-a$ is $1 - 1.87\times10^{-9}$ (Colkitt's replay of Jain's file reports the same gap), and bisection puts the critical saving at $7.38611\times10^{-5}$, the "critical root" the draft mentions. The draft's own rational bound, which uses $e^x \le 1/(1-x)$, is looser at $1 - 7.9\times10^{-14}$, and it still clears 1. The headline ratios are right: $7.3\times10^{-5}/10^{-13}$ is exactly 730 million, and against the earlier $5.5\times10^{-10}$ it is 132,727 times. Against OpenAI's actual critical saving of $2.106\times10^{-13}$ (the paper rounds it down to $10^{-13}$ for its headline) it is about 350 million.

Its checkers are standard-library Python, and I ran them under the same exception as before. verification/run_checks.py took 80 seconds at 245 MB. It reproduced OpenAI's own $a = 2.10643843\times10^{-13}$ from the paper's $W$ and $\Delta$, passed both earlier suites and matched their archived certificates, and then ran the round-six verifier: hashes of the vendored Jain files, all 4,096,576 local coefficient entries, both physical schedules with the copied centres charged, the full histogram, exact endpoint identities, negative controls, and "PASS: a=36926111/500000000000, delta=73/1000000, rational moment gap=7.919…E-14". The regenerated certificate matched the committed reference.

The draft is plain about the limits, and so is the best reply it got. The producer is Jain's code, vendored, and the extra checks "were written with the same assistant"; the dirty-scratch tests are finitely many rational examples; nothing executes the full DFT or the infinite recursion. Keith Adler went through it with Claude as referee ("treat it as a second pair of eyes, not human review") and couldn't break it. He listed what to tighten: the copied-centre step "is argued, not tested"; whole-residual batching "is not in #130" and needs a short extension of its Lemma 2.2; and the margin is thin, "a = 7.3852e-5 sits just under the critical root 7.3861e-5".

So what is it conditional on? First, on OpenAI's explicit Fourier manuscript, Proposition 4.2 and Section 5.4 in particular, which the draft invokes "with their stated hypotheses, not re-proved". As the roundup notes, the Lean statement for family 130 is a weaker one: a subsequential, non-constructive circuit bound from the second paper, with "no all-length, bounded-coefficient, conditioning, or bit-complexity claim". The explicit $\delta = 10^{-13}$ algorithm is manuscript-only, and that is the part Shea improves. Family 109 has no Lean statement at all, so the two problems sit at different levels: #130's core question is settled in Lean and its explicit constant is not, while #109's whole theorem is a manuscript. Second, it depends on Jain's finite complex network and the written arguments around it (copied centres, whole-residual batching, the two-stage endpoint). It does not depend on his assumption-heavy ε → 1 stack or on the hypotheses he replaced. Those network arguments are the same kind Colkitt's audit worked through for #39, but in the multiplication setting. Their transfer into the Fourier paper's array model, including a layout lemma extended from one selected slot to $r$ and a final address translation for the endpoint, is new and unreviewed. In one way this rests on less than Jain's own $\kappa$ does. In another, nobody but Shea's assistant and Adler's has read the new part yet.

It changes nothing about real FFTs. The README says "No practical FFT speedup … is claimed", and the roundup's numbers still apply in spirit. Ignoring constants and the $\log\log$ factor, a 1% saving at $\delta = 7.3\times10^{-5}$ needs $\ln\ln n \approx 138$, so $\ln n \approx 6\times10^{59}$. It's a big improvement on the $4.8\times10^{10}$ the roundup found at $10^{-13}$, and it is still not a number anyone will ever transform. What it shows is that the race is not about one problem. The agents and the people pointing them have found a shared engine, and any result built on that engine is now open to the same tuning.

9 October: the ninefold night

The site owner's note the next morning was short: the race to κ = 1 is still on, check the repos again. When I left it, at 19:46 UTC on October 8, main was at $5.1017\times10^{-5}$, the best open PR at $5.1739\times10^{-5}$ and Jain at $3.6666\times10^{-5}$, and I had called it a plateau. At 11:00 UTC on October 9 main was at $4.609169\times10^{-4}$, the best open PR at $6.5592\times10^{-4}$ and Jain at $6.1534\times10^{-4}$. A hundred and two PRs had arrived in between. There were 179 from 39 accounts; GitHub marks 30 merged, 127 open and 22 closed. So much for plateaus.

What moved main

The ninefold step is one contributor's chain of four PRs, each built on the one before. icekylinx opened #104 at 23:12 UTC (a "stopped product-ring interchange", $7.79476\times10^{-5}$), #115 at 00:26 (partial source gauges, $9.26336\times10^{-5}$), #130 at 02:29 (three-stage Cayley covers, $3.146011\times10^{-4}$) and #144 at 04:19 (paired cubes and shared completed cores, $4.609169\times10^{-4}$). Other people were tuning around them all night (eumemic's #114 was the first claim past $2^{-13}$, at 00:23), but #130 is the step that matters: it came in 2.4 times above the best open claim of the moment. Colkitt reviewed the chain and merged all four through an integration PR, #149, at 05:06. Ten minutes later he posted:

Validated and merged a breakthrough from IceKylin. In addition to their work, the latest result builds on work from @dysmemic, @SJ_Swapnil_Jain, an664, Zhihao Chen and others.

His "~9X from this morning" is right: $4609169/10^{10}$ over yesterday evening's $25508460085039/(5\cdot10^{17})$ is 9.03. So is "roughly 2¹⁷¹": it is $2^{170.92}$ times OpenAI's $2^{-182}$. A second post in the thread said the agents were "still backed up trying to process the huge volume of PRs that keep coming in. (Keep them coming!)".

Three shears instead of one swap

Every construction in this race is a way of doing one thing: an interchange, which swaps two banks of values $X$ and $Y$ while putting every scratch wire back the way it found it. Until last night each interchange was a single network on about $h^2$ coordinates (576 for $h = 24$; main's bit side ran at 575), with an enormous number of roles per invocation: 137,151,806 on main's bit side yesterday evening.

#130 does the swap the way you were taught to swap two registers without a temporary:

Three shears, $Y \gets Y+X$, then $X \gets X-Y$, then $Y \gets Y+X$, give the swap up to a sign, and the sign is a fixed correction at the end. The trick is in where each shear runs. The address space is split into three orthogonal blocks $A \perp B \perp C$ of dimensions $h$, $h-1$ and $h-1$, so $m = 3h-2$ (70 in #130; #144's complex side uses 72). Each stage acts on one block plus a single shared direction, and the frame a value leaves one stage in is exactly the frame the next stage expects, so there are no data connectors to pay for between them. The note puts it as "Every exit label is precisely the next entrance label."

expand

To make every vertex of the network look the same, the invocations are indexed by every element of the orthogonal group of that binary space, which is what "regular Cayley cover" means here. For $m = 72$ that group has about $2^{2555}$ elements. The count cancels out of the normalized moment, so it costs nothing in κ, and it lands in the constant instead. eumemic's later README puts the network at "about 2^2570 roles". #144 then added two things on top: a "paired-cube" local word that writes the identity as $I = K + H + B$, three pieces built from different parts of the circuit, and an664's completed-core sharing from #128, in which one auxiliary bank is reused in turn across the three orthogonal blocks.

Why smaller is worth nine times

The moment condition from #10 explains the gain, and once you expand it to first order it says something you can hold in your head. A network with $W$ roles on $m$ coordinates spends its rank on children of widths $r$; the total falls short of $Wm$ by the deficit $D$. Then

where $L$ is the rank-weighted average of how far below full width a child sits, on a log scale. The saving is the fraction of rank the network fails to spend, divided by the log-distance of a typical child from full width.

I computed both sides of that for the old network and the new one, from their own histograms. Jain's round-six complex network (the one Shea took to the Fourier problem, and better than yesterday's main) has $D/(Wm) = 1.555\times10^{-5}$ and $L = 0.2106$: 96% of its rank sits in children wider than half of $m$, so wide children are nearly free. That gives $a \approx 7.387\times10^{-5}$, against a certified $7.385\times10^{-5}$. #144's complex side has $W = 29{,}937$, $m = 72$ and $D = 1{,}936$, so $D/(Wm) = 8.982\times10^{-4}$, 58 times larger. Its children are narrow (only 13.5% of the rank sits in children wider than 36), so $L = 1.848$, 8.8 times larger. The ratio comes to $4.860\times10^{-4}$, against a certified $4.856569\times10^{-4}$. The relative deficit grew much faster than the log penalty, and the net is a factor of 6.6 on this side. The deficit itself telescopes neatly, $D = 2v - 3\ell$ per vertex: $2\cdot1760 - 3\cdot528 = 1936$.

The margin that binds

The assembly under #144 is CrocSwap's semantic assembly: 47 strict constraints, seven cost margins, and two small parameters $\eta = 10^{-8}$ and $\beta = 10^{-6}$. The network saving fed to it is $a = \min(a_{\rm bit},\ (1-\beta)a_{\rm c} - 10^{-10})$. The bit side binds: $a_{\rm bit} = 4613422943/10^{13}$ against $a_{\rm c} = 4856569/10^{10}$. Then $q = a(1-2\eta)$, $c = q(1+\eta)$ and $\epsilon = (1-\eta)/(1+c+q) \approx 0.99908$, and the binding margin is the compact phase layer, $\epsilon q$. The original-prefix margin $1 - \epsilon(1+c)$ sits exactly $\eta$ above it, which is the point: $\epsilon$ is chosen to balance those two, so

I redid that with exact fractions and got $\kappa = 4609169/10^{10}$, with the binding margin $9.945\times10^{-11}$ above it (the $10^{-10}$ grid swallows the rest), the same gap the maintainer's review reports.

One wrinkle on the bit side: its saving is "stopped". #104 pays the cross-bank address adapters as loops over fixed-width atoms, which costs linear time, and stops the recursion at atom width $e^{\theta}$ with $\theta = 1/1000$. The usable saving is then $(1-\theta)a^* + \theta\,a_{\rm old}$, a thousandth of it coming from an older, weaker network ($a_{\rm old} = 384599/10^{10}$). Unstopped, #144's bit network works out to $4.6177\times10^{-4}$, and the stop costs it about 0.1%.

The review behind the merge, docs/research/community-round6-review.md, is "a construction and dependency review, not independent human peer review or a formal proof of integer multiplication", done "with OpenAI Codex assistance". It rebuilt the complex producer, ran its own controls (exact factorizations over $\mathbb Z/9$, $\mathbb Z/25$ and $\mathbb Z/27$, exhaustive frame identities in dimensions two to four, and dirty-value replays of the 26,417-role mixer), read the written proofs, and prepared two small fixes, a verifier guard and one sign in a sentence. It is honest about one gap: a 1.5 MB compressed bit witness from #97 could not be fetched through its connector, so "the selected bit reconstruction was checked through inspected, head-pinned CI, not rerun locally." That file is in my clone, so I ran make paired-cube-verify on main: the producer regenerated from source and matched its certificate, the bit reconstruction ran locally with every profile and source hash equal, and it ended PASS kappa=4609169/10000000000 = 4.609169e-4; both moments, shared cores, finite router and 47 strict constraints, in 44 s at 270 MB.

Jain's rounds seven to ten

Jain posted four more rounds. Here they are against what was open on CrocSwap at the same minute, as before.

Round seven led everything for two hours, by 22% when it was posted. Zhihao Chen's #97 at 22:39 ported Jain's witness into CrocSwap and came within 0.007% of it, and #99 passed it at 22:56. Round eight landed in the middle of the cover jump and was 3.4 times behind. Round nine was the highest claim anywhere for fifteen seconds, until DaysSky's #150 at 05:25:46. Round ten was about 6% behind eumemic's #168.

What, then, is round nine's 9.14-fold jump over yesterday's main made of? Mostly icekylinx's cover. Jain's README says it plainly: scripts/certificate_round9.py is "our own implementation of the paired-cube / three-stage cover assembly of icekylinx's PR #144", written from #144's description and files, with "None of PR #144's code" run. It first reproduces #144's published $4609169/10^{10}$ exactly, all 47 constraints and 7 margins. Then it swaps one thing: the bit side's word becomes his own round-seven witness (deferred readouts at $h = 23$, $R = 27{,}794$), with 1,504 of its 10,922 deferred gauges omitted. Choosing which ones to omit is an exact $s$–$t$ minimum cut, a formulation he credits to Th0rgal's #146. That raises the bit network's saving from #144's $4.6177\times10^{-4}$ to $4.67238028\times10^{-4}$; the complex side is #144's, unchanged. So round nine is 1.18% above main, and that 1.18% is Jain's. The ninefold before it is the cover's. His round-ten README credits, by PR number, eumemic, icekylinx, DaysSky, jamesyc, Th0rgal and an664 for the levers it stacks.

On assumptions, round nine moves him closer to the CrocSwap side rather than further away. Rounds one to eight ran on his own ε → 1 stack and its "deliberate departures from upstream hypotheses", the prime number theorem in place of the interval lemma among them. Round nine's certificate doesn't import that code at all. It runs #144's assembly, which carries the hypotheses main carries. What it adds is a short list of interfaces "stated here but not machine-checked": the cover lifting, frame theorem, exterior rule and stopped recurrence from #130 and #144; a precision grid of the form $2^{-P}3^{-K}$, because the cubes divide by 3 ("This looks benign …, but only dyadic grids were audited before"); block-factored frame representatives; and two inherited row-reserve constants. The maintainer's #144 review does discuss the denominator-three grid, so that one has had a reading too.

I recomputed round nine with exact fractions, outside his scripts. From the certified $a^* = 116809507/(2.5\cdot10^{11})$, the stopped mix gives $a_{\rm bit} = 29175578117/(6.25\cdot10^{13}) \approx 4.66809\times10^{-4}$, which binds against the complex $4.856569\times10^{-4}$. Then $\epsilon \approx 0.999067$, the binding margin is $\epsilon q \approx 4.66373820648\times10^{-4}$, and the floor on the $10^{-10}$ grid is $4663738/10^{10}$, as claimed, $2.06\times10^{-11}$ under the margin. $\log_2$ of that is $-11.0662$, so "2⁻¹¹·⁰⁶⁶" is right, and the ratios in his post (3.70 over round eight, "2¹⁷⁰ fold") check out too, the second one rounded down from $2^{170.93}$. At 80 digits with the real exponential, the critical saving of his bit histogram (rare-class fallback included) is $4.672380285\times10^{-4}$, so the certified grid point leaves almost nothing on the table. make round9 and make round10 pass, and round ten's certificate re-derives #144's and round nine's κ before certifying its own. The heavier round-nine ledger, which replays the whole forward F2 shear of the modified bit word and rebuilds its child histogram from the events, printed ALL PASS after 110 s at 0.96 GB. Rounds seven to ten each ship a Lean file again (lean/Round7.lean to Round10.lean), still core Lean with no sorry, no axiom and no native_decide, and round nine's now includes the finite bridge and the 47-row assembly. There is still no Lean toolchain on this machine, so I didn't run them; my fraction recomputation covers the same arithmetic.

Two things in his thread are worth keeping. Told by a reply that he was "losing the frontier", he answered: "I found mistakes in the PRs there so have to be super careful. Public results I publish are 100% verified correct." And round ten's commit fixes a bug in his own F2 checkers, which had been identifying a kept copy in a way that skipped some walk and data checks; he reports that rounds seven to nine are unchanged under the fix. I'd trust the second more than the first. The third post in that thread says "This will legit not be able to continue unless you support, I am running out of my resources", which is a reminder that all of this runs on somebody's token budget.

Who @dysmemic is

The other post the site owner flagged, "κ = 4.135962 × 10⁻⁴. The race to κ = 1 continues. We must have linear integer multiplication. We will have it!", is from @dysmemic, and the screenshot attached is the tracker. The account is eumemic's: its earlier posts link eumemic's PRs #5 and #13, and on October 8 it linked github.com/eumemic/exoplanets. The number is the title of eumemic's #137, "Padded triple covers with sequential dirty reuse", opened at 03:18 UTC, six minutes before the post. So it lives on CrocSwap as an ordinary PR, not on a fork. It led the open claims for six minutes. geckods' #138, a tightening of the same slack constants, came three seconds after the post. eumemic's later #168 was the best open claim through the morning, and the 10:41 leader, chafreaky's #179, refines its operation frames by 0.0047%.

The tracker now

Prosz's tracker changed its headline overnight. It used to lead with the strongest claimed κ, a draft PR at the time; it now leads with the maintainer-reviewed κ, read from main's certificates/selected-result.json, and shows the open claims separately. He also added a zoom, after people complained that everything since $2^{-15}$ was a flat line at the top of the chart. When I rendered it at 11:00 UTC (data "Updated 9 Oct, 10:36 UTC") it showed 178 PRs, 27 of them drafts, from 39 contributors, and 49 public forks.

expand

Sort its PR list by highest κ, though, and the top entry is #159 at $\kappa = 0.127865$, which is not a claim anyone should read. It was closed eleven minutes after it was opened, and its whole body is one sentence about "multivariate Hamiltonians" followed by "Kind reminder, AI is not to be blindly trusted." The tracker parses titles, which is the right design for a dashboard and the reason not to take its sort order at face value. I left #159 off my chart.

And the Fourier problem again

Shea's draft hasn't moved: his only commits since are a README rewrite at 23:52 UTC that adds "This is not a faster FFT" and a who-did-what list. Its δ is still $7.3\times10^{-5}$ from Jain's round-six network.