Foundation0

Algorithms · a founding member’s race, with the crowd

Shaving the logarithm

For fifty years the best guess was that multiplying two huge numbers needs about n log n steps, and no fewer. A machine-written paper claimed a sliver below that. In one week a public race of people and their AI agents made the sliver about 1052 times wider. It is still a sliver, and all of it rests on that unreviewed paper.

Conditional · maintainer-reviewed Not peer reviewed Not a complete Lean proof Builds on OpenAI #109

Founding member Doug Colkitt’s project. They created and maintain CrocSwap/integer-mult-bounds, where the race runs. Founding member rohanarun held the reviewed record on 15 Oct 2026 (PR #1094) and sent the most pull requests; founding member eumemic sent 80. Aska Digital built the live tracker that grew into this site, and submitted two small claims that were later superseded.

The number the race is about

How to read: κ (kappa) measures the saving below n log n; bigger is better. This page reads it from the race’s own record file each time you open it.

Reviewed κ · conditional

0.001672660197076918

= 836330098538459 / 500000000000000000

In halvings
κ ≈ 2−9.22
Since the paper
1.03 × 1052 times larger
Record
PR #1094 by founding member rohanarun
snapshot · 13 Oct 2026, 18:45 UTC Source: certificates/selected-result.json (live), else this page’s snapshot
  • 2−182 → 2−9.22
    κ from the machine-written preprint (dated 23 Sep, made public 6 Oct 2026) to the record of 13 Oct, about 1.03 × 1052 times larger
    preprint §0 Theorem 1; log2 of the record, computed
  • 17
    reviewed records in five days, 9 to 13 Oct
    git log of certificates/selected-result.json
  • 1,334
    pull requests opened upstream by 13 Oct 2026 (highest #1374)
    git ls-remote refs/pull/*, 13 Oct ~23:40 UTC
  • 0.50%
    fewer steps than n log n for million-bit numbers, ignoring constants: real, and far too small to notice
    computed in section 02

00//The problem

First principles

Every digit meets every digit.

Before asking how fast multiplication can go, count the work in the method everyone learns at school.

Write two numbers, each n digits long, one above the other. The school method multiplies every digit of one by every digit of the other, then adds up the rows. That is n × n small multiplications: a 4-digit problem takes 16, a 1,000-digit problem a million. Double the length and the work goes up four times. This growth is written n², “n squared”.

Computers work in binary, so for them n counts bits (binary digits) instead of decimal digits, but the counting is the same. And the numbers can be enormous: encryption multiplies numbers thousands of bits long, and record computations of π multiply numbers with billions of digits.

In 1960 the mathematician Andrey Kolmogorov conjectured that nothing could beat n². Within weeks, Anatoly Karatsuba, a student at Kolmogorov’s seminar, did. Split each number into a front half and a back half. Of the four half-size products the school method would need, compute only three: the two “matching” ones, and one product of sums that delivers the other two added together. Repeat the trick inside every half, and only 3 of every 4 products survive at every level. The work grows like n1.585 instead of n2. The figure shows it.

Every digit meets every digit

How to read: the top number is π’s first n digits, the side number e’s. Each lit square is one digit-by-digit multiplication. Switch to Karatsuba to see which products it never computes.

Ctrl //

Exact product 3141 × 2718 = 8,537,238

School method, 4 digits: 4 × 4 = 16 digit products. Karatsuba needs 32 = 9.Digits of π and e; products computed exactly in your browser.
Show the counts
Digit products needed
Digits nSchool n²Karatsuba 3log₂nKaratsuba share
24375%
416956%
8642742%
162568132%
321,02424324%
644,09672918%
1,048,5761.1 × 10123.5 × 1090.3%

01//The floor

1962 → 2026

From n² down to n log n, and a guess about the floor.

Karatsuba opened a sixty-year chase. Its last big step treats numbers as waves.

The digits of a number are like a sound sampled over time. Multiplying two numbers is, apart from carrying, a calculation called a convolution: slide one row of digits past the other and add up the overlapping products. The figure does exactly that, one position at a time. The fast Fourier transform (FFT), the method that splits a sound into its notes, turns a convolution into note-by-note multiplication, which is cheap: in effect, it does all the sliding at once. Converting into notes and back costs about n log n steps.

Arnold Schönhage and Volker Strassen used the FFT in 1971 to reach n log n log log n, and guessed that n log n is the floor: that no method can do better. In 2019 David Harvey and Joris van der Hoeven finally reached n log n; the proof appeared in the Annals of Mathematics in 2021. Most people took that as the end of the road.

These bounds are proved on a multitape Turing machine: a deliberately simple model of a computer that reads and writes a few long tapes one cell at a time, so even moving data around costs steps. It is the standard yardstick because it cannot hide work inside clever hardware.

Multiply by sliding

How to read: the top row is π’s first digits, the bottom row e’s, written backwards. Slide the bottom row along (drag it, or use the controls): each lit pair is one digit product, and the products at each position add up into one column. “Carry” turns the column sums into the real product.

View //
Slide //
Ctrl //

Position 4 of 7: 3×8 + 1×1 + 4×7 + 1×2 = 55, written in column 4.

3141 × 2718 by sliding: the column sums are 6, 23, 18, 55, 19, 33 and 8; carrying turns them into 8,537,238. For 1,000,000-digit numbers, every digit meeting every digit takes 10 to the 12 products; the FFT route takes about 6 times 10 to the 7 steps, constants ignored.Digits of π and e; every product, sum and carry computed exactly in your browser. Step counts ignore constants, which for real FFT multiplication are larger.
Show the numbers
3141 × 2718, one position at a time
PositionOverlapping pairsColumn sum
13×26
23×7 + 1×223
33×1 + 1×7 + 4×218
43×8 + 1×1 + 4×7 + 1×255
51×8 + 4×1 + 1×719
64×8 + 1×133
71×88
Carry, from the right8,537,238
Steps to multiply two n-digit numbers, constants ignored
Digits nSchool, n²FFT route, 3n log₂ nHow many times less
101001001
1,0001063.0 × 10433
1,000,00010126.0 × 10716,700
1,000,000,00010189.0 × 101011 million

On 6 October 2026 OpenAI published a manuscript, dated 23 September, titled “Integer multiplication below n log n”. Its only listed author is “OpenAI”, and the repository that holds it says its manuscripts were “produced by an internal OpenAI model”. It is result family #109 of 722 machine-written manuscripts. It claims multiplication in

T(n) = n · (log n)1−κwith κ = 2−182

If κ were 0, this would be n log n. Any κ above 0, however small, means n log n is not the floor on this machine. And 2−182 is small: written as a decimal it starts with 54 zeros.

  1. AncientSchool methodn2
  2. 1962Karatsuba and Ofmann1.585
  3. 1963Toom (Cook, 1966)n1+ε, any ε > 0
  4. 1971Schönhage and Strassenn log n log log n
  5. 2007Fürern log n · 2O(log* n)
  6. 2019Harvey and van der Hoevenn log nthe presumed floor
  7. 2026OpenAI’s model, then the crowdn (log n)1−κconditional · not peer reviewed

Sources: the preprint’s history section (openai/math @ adc7f12); Harvey and van der Hoeven, Annals of Mathematics 193 (2021) 563–617. O(·) means “up to a constant multiple”; log* is the number of times you must take a logarithm to get below 1.

02//How much is κ worth?

Computed in your browser

A saving that grows forever, absurdly slowly.

The race’s number is not a speed-up anyone will notice. Its value is what it would prove.

How much is κ worth?

How to read: choose how big the numbers are and which κ. Left: steps for each method, on a halvings scale (each gridline doubles the work), constants ignored. Right: the share of steps the race saves over n log n, as the numbers grow.

Ctrl //
Steps to multiply two 220-bit numbers
Fewer steps than n log n, by size
Saving factor (log₂ n)κ
1.00502
Fewer steps than n log n
0.50%
Size needed to halve the work
210180 bits
For 220-bit numbers, ignoring constants: school method 240 steps, Karatsuba 231.7, Schönhage–Strassen 226.4, n log n 224.322, the race 224.315. The saving over n log n rises from 0.38% at 2 to the 10 bits to 0.69% at 2 to the 64 bits, for today's kappa.Computed from the formulas above, logs base 2. The preprint calls its own constants “extremely large”.
Show the numbers
Share of steps saved over n log n, (1 − (log₂ n)−κ)
κ210 bits220 bits230 bits264 bits
Paper, 2−1824 × 10−53 %5 × 10−53 %6 × 10−53 %7 × 10−53 %
Day one, 5.8 × 10−331 × 10−30 %2 × 10−30 %2 × 10−30 %2 × 10−30 %
9 Oct, 0.00046091690.11%0.14%0.16%0.19%
Now, 0.0016726601970769180.38%0.50%0.57%0.69%

Ignoring constants, the race’s method beats n log n by a factor of (log n)κ. For million-bit numbers and today’s κ, that is half a percent. For numbers 264 bits long, about 2.3 million terabytes each, it is still under one percent. To make multiplication even twice as fast as n log n, the numbers would need about 210180 bits; the observable universe holds about 1080 atoms.

The constants ignored here are, in the preprint’s own words, “extremely large”. Nobody’s computer multiplies faster because of this race, and nobody involved claims it does. What a proven κ > 0 would show is a fact about the problem itself: on this machine, n log n is not the floor. A bigger κ is a sturdier, more checkable version of that fact.

03//The race

Conditional · maintainer-reviewed

From 2−182 to 2−9 in one week.

On 7 October Doug Colkitt opened a public repository to widen the sliver, and invited anyone to “donate inference”: point an AI agent at a task and send back a result a computer can check exactly.

Within 22 hours, working with OpenAI Codex, Doug Colkitt had pushed κ from 2−182 past 2−34 by tightening the preprint’s own construction. Then the crowd arrived: more than 1,300 pull requests (proposed changes, which the maintainer can review and merge) in a week, many written with AI agents and disclosed as such.

Every improvement had to arrive with exact-arithmetic certificates, fractions computed with no rounding, and scripts anyone can re-run. That rule is what made a crowd usable: nobody has to trust the sender, because anyone can run their checker. The maintainer reviews, re-runs and selects; each selection becomes the new record.

The κ staircase

How to read: each step is a new record, and the line holds a value until it is beaten. “Halvings” puts each gridline 30 halvings apart; “Plain” plots κ itself. Point at, tap or arrow-key through the steps; “Replay” redraws them in the order they happened.

Scale //
  • Reviewed record · conditional, selected by the maintainer
  • Machine-written preprint · the starting claim
  • Aska’s claims · #464, #469, never reviewed

Focus the chart, then use the left and right arrow keys to move between records, Home and End for the first and last. The selected record is described below the chart.

From 2 to the minus 182 in the machine-written preprint (dated 23 September 2026, made public on 6 October), through the maintainer’s steps on 7 and 8 October, to 0.001672660197076918 (about 2 to the minus 9.22) on 13 October. The full list is in the table below the figure.Source: kappa-history.json (compiled from the race’s commit history and selected-result.json); open claims from chart-data.json.
Show every record
Reviewed records of κ, UTC
Whenκlog₂ κWhatSource
dated 23 Sep 20262−182−182.00The machine-written OpenAI preprint (family #109) claims the first saving An internal OpenAI modelpreprint
7 Oct 2026, 02:225.8 × 10−33−107.09The repository opens: a better choice of the preprint's parameters Doug Colkitt, with OpenAI Codex5cf29ecd
7 Oct 2026, 13:352−78−78.00Direct axis routing Doug Colkitt, with OpenAI Codex52ce3bee
7 Oct 2026, 19:272−59−59.00Paired circuits, sharper estimates Doug Colkitt, with OpenAI Codexbcd4ebde
8 Oct 2026, 00:278.3 × 10−11−33.49Compact controls (the idea came from a separate research agent) Doug Colkitt, with OpenAI Codex6e564879
8 Oct 2026, 01:102−31−31.00Complex-network compression Doug Colkitt, integrating eumemic's Claude-assisted PR #31c09a588
8 Oct 2026, 13:102−30−30.00Ternary checkpoint1a74950c
8 Oct 2026, 15:180.00003886675852−14.65First community release, above 2^-15 The crowd; final step PR #39 by rohanarun0605a24a
8 Oct 2026, 18:240.000051016920170078−14.26PRs #50 to #62 reviewed The crowd0d235fe5
9 Oct 2026, 04:530.0004609169−11.08PR #144; the selected-result file begins icekylinx (GPT-6 Astra via Codex)6aed8701e
9 Oct 2026, 05:550.000472143085−11.05PRs #146 to #150e2a02cac1
9 Oct 2026, 06:010.000472154791−11.05PR #151 added86b30e035
9 Oct 2026, 12:320.000661885549259598−10.56PR #186 Dugongued697aaa79
10 Oct 2026, 14:080.000723571590007464−10.43PRs #276 and #279 ("gen4") DreamingOfClouds and rohanarun91e29e7bb
12 Oct 2026, 01:550.001517760977820331−9.36PR #531 on #523, with #493 icekylinx, with eumemica1e7d8486
12 Oct 2026, 13:100.001584931111785787−9.30PR #535 with #5101c1e42f0d
12 Oct 2026, 14:410.001602278921983212−9.29PR #588 with #543270c2458c
12 Oct 2026, 16:590.0016127213726553−9.28Through PR #5991db1fbe68
12 Oct 2026, 21:010.001635183729255778−9.26PR #6172e9ed969d
12 Oct 2026, 22:360.001635527380375392−9.26PR #6265c5567d15
13 Oct 2026, 05:570.001661202643272239−9.23PR #741 (SW4)2cdd93d02
13 Oct 2026, 06:440.001661634653669567−9.23PR #799 (X4)d6dfd8f21
13 Oct 2026, 13:300.001661957774647029−9.23PR #890 (U8/T21)3b83e4f14
13 Oct 2026, 15:060.001661960547713947−9.23PR #942 (T37)3825dc0ea
13 Oct 2026, 18:050.001672188119205421−9.22PR #104287db776d7
13 Oct 2026, 18:450.001672660197076918−9.22PR #1094: alternating packing improvements with Jeremy Kothe's #1087 rohanarun0a31ad884
11 Oct 2026, 17:010.001347744550711765−9.54Aska #464: Sharper bit bad-class charge on PR #450's word (applies PR #461's refinement) Claimed · never reviewed · closed by Aska on 13 OctPR #464
11 Oct 2026, 17:320.001350580884553120−9.53Aska #469: Gate-frame retiming of PR #450's eleven-stage word (+0.2105%) Claimed (draft at the snapshot) · never reviewed · closed by Aska on 13 OctPR #469

Two true pictures. On the halvings scale the first 48 hours look like everything: restructuring the preprint’s construction crossed most of the distance, from 2−182 to 2−30. On the plain scale those leaps vanish into the floor, and the last days look like the whole story: 0.00072 to 0.00167 as many people and agents fought over fractions of a percent.

What the record is now. The live value at the top of this page comes straight from the race’s certificates/selected-result.json. If it is newer than the last step drawn here, the figure adds it as a “now” step. The record changes several times a day, so every number on this page carries a date.

04//Where the saving comes from

Exact data from PRs #450, #464, #469

A budget that must stay under one.

Inside the proof, κ comes out of a bill: hand down slightly less work than you take in, and the leftover compounds into a saving.

The algorithm is recursive: it splits a job into many smaller jobs, splits those again, and so on. Think of one job as a budget of 1. One building block in the construction has width m = 78 and W = 1,200 roles, and hands out child jobs of different sizes r: 27,060 of size 1, fewer of each larger size, and 184 of size 56.

Charged at their plain size, the children cost 93,192/93,600 = 0.99564 of the budget. There is a margin of 0.44%, and that margin is the whole game.

To bank a saving a, each child of size r is billed as if it were a little bigger, by a factor (m/r)a. Small children are billed the most, because m/r is largest for them. Raise a and the bill climbs. The largest a that keeps the bill under 1 is this block’s saving, and the outer algorithm turns it into κ = a/(1 + a). The current construction has two kinds of block, called bit and complex, and the weaker of the two sets κ.

That makes the lesson of the figure plain: moving work out of the smallest child jobs and into slightly bigger ones, with the total unchanged, lets a climb. Much of the race is exactly this kind of tidying, done by people and agents in parallel and checked to the last digit.

The budget that must stay under one

How to read: pick a block, then raise the saving a. Bars show each child size’s share of the bill; the gauge, zoomed in around 1, shows the total. “Find the break-even” halves the search interval until the bill sits exactly at 1.

Block //
Total bill, zoomed: 0.995 to 1.001Under budget
Saving //
Bill
0.995641026
κ = a/(1+a)
0
Published κ for this block
0.001347744547714835

PR #450 by DreamingOfClouds: the parent block Aska’s two claims started from.

Share of the bill by child size, at a = 0: size 1 is 28.9%, size 2 is 23.8%, size 4 is 14.8%, size 56 is 11.0%, size 3 is 9.7%, size 5 is 6.3%, size 6 is 3.0%, size 7 is 1.2%, size 8 is 0.8%, size 14 under 0.1%.Source: PR #464 head 8c546e99 and PR #469 head a820816f, PROOF.md.
Show the numbers

04.1//Our part, at its true size

Claimed · never reviewedClosed by Aska, 13 Oct

On 11 October, working with Claude Fable 5.1, Aska Digital submitted two changes to the block from PR #450, by the contributor DreamingOfClouds.

PR #464 replaced an over-cautious insurance charge for rare bad cases with the smaller figure the source theorem actually proves. The idea was not ours: Srikrishnabalaji found it first, in PR #461, and applied it to a different block; upstream later credited #464 for carrying it over. κ rose by about 3 × 10−12.

PR #469 kept every addition in the block and re-timed 113 data moves into coarser frames, which shifted work out of the smallest child jobs: 649 fewer jobs of size 1, 99 fewer of size 7, 198 more of size 6. The gain was 0.21%, and the figure above reproduces it.

At our tracker’s last snapshot that day, #469 was the highest open claim (it was still a draft) and #464 the highest non-draft claim. Neither was ever reviewed. Both, like their parent block, rest on an interface that another pull request (#451) disputes, as our closing note said. By 13 October the reviewed record had moved far past them, on a different line of work, so we closed both.

The tracker we built to follow the race is still here as the race tracker, and it is how this site began. Its claims feed stopped updating on 11 October at 17:41 UTC; it still reads the reviewed κ live.

#464 claimed
κ = 0.001347744550711765
#469 claimed
κ = 0.001350580884553120
Record that passed both
0.001517760977820331, 12 Oct, 01:55 UTC

05//How sure is it?

ConditionalNot peer reviewed

Checked hard, but not proved.

Each layer of the result has its own strength of evidence. The repository states every limit itself, and we repeat them here unsoftened.

Evidence, layer by layer (as of 13 Oct 2026)
LayerStatusWhat backs it
OpenAI’s base theorem, κ = 2−182Machine-written preprintProduced by an internal OpenAI model; not peer reviewed; not among the 162 results in openai/math’s Lean formalization catalogue at the pinned commit.
The race’s κ recordsMaintainer-reviewed · conditionalFinite constructions with exact-arithmetic certificates, re-run from scratch by the maintainer; each inherits the OpenAI framework and several stated interfaces as assumptions. For #1094, independent auditors (Josie Elliston, #1091; Sagar Thakrar, #1069) also checked the final candidate.
Lean (machine-checked proof)Pieces onlyCertificate arithmetic for early checkpoints and scoped lemmas: “298 audited declarations across 27 unique Lean modules”. In the repository’s words: “They do not verify the full multiplication machine.”
Peer reviewNone claimed“This is not full formal verification, independent human peer review, a worldwide priority claim, or a practical multiplication benchmark.”
Practical speedNone claimedThe preprint’s constants are “extremely large”; see section 02.

“All-size/compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery and analytic obligations remain conditional. This is not a complete Lean multiplication theorem.”

CrocSwap/integer-mult-bounds, README, 13 Oct 2026

06//Who did what

No portraits, by design

One maintainer, a crowd, and their machines.

Four founding members are in this race: Doug Colkitt, rohanarun, eumemic, and Ahraz Arifuddin through Aska Digital. So are an internal OpenAI model and about 170 other people, many working with AI agents, who had sent pull requests by 13 October (count at 08:10 UTC).

M·03 · Creator and maintainer

Doug Colkitt

@Mister-Meeseeks

Opened the repository on 7 October 2026 (first commit 02:22 UTC) and, working with OpenAI Codex, took κ from 2−182 past 2−34 within 22 hours. Since then they review, re-run and integrate the crowd’s work, and choose each record: 361 of the first 957 commits on the main branch are theirs.

Source: README, NOTICE and CITATION.cff; git log to 14 Oct 2026

M·04 · Reviewed record, PR #1094

rohanarun

@rohanarun

Their PR #1094, κ = 0.001672660197076918, became the reviewed record on 13 October at 18:45 UTC, building on alternating packing improvements with Jeremy Kothe; it was still the record on 15 October. The most active contributor: 142 pull requests, and the most in the maintainer’s ledger (119 of 722). Their PRs disclose OpenAI Codex and Anthropic Claude assistance.

Source: selected-result.json; PR search and docs/research/pr-ledger.md, 14 Oct 2026

M·02 · Contributor

eumemic

@eumemic

80 pull requests in the maintainer’s ledger, the third most. Their first, PR #3 (Claude-assisted), helped take κ past 2−31 on day two; on 13 October the record’s bit block was DreamingOfClouds’ #589, built on eumemic’s #555.

Source: docs/research/pr-ledger.md; README line 25, 13 Oct 2026

M·01 · Tracker and two claims

Ahraz Arifuddin · Aska Digital

@ahrazzle

Built a live tracker of every open claim on 11 October, with Claude; it became this site’s first page. Submitted PR #464 and PR #469 the same day (section 04.1): never reviewed, later superseded, closed on 13 October.

Source: aska-digital/f0; PR #464, #469

Human

  • Chose to attack the paper’s bound in public, and set the rules: exact certificates, re-runnable checks, disclosed AI help
  • Review, re-run and select every record (the maintainer)
  • Point agents at tasks, read results, decide what to submit (each contributor)
  • Audit candidates independently (named auditors on #1094)

Digital

  • Wrote the starting preprint (an internal OpenAI model)
  • Drafted most constructions, proofs and checking scripts: OpenAI Codex, GPT-6 Astra, Anthropic Claude Opus 5.5 and others, as disclosed in the repository’s NOTICE
  • Proposed the compact-control idea of day two (“a separate research agent”)
  • Wrote six of the first Lean checks, committed under the author name “Claude”

Sources: NOTICE, CONTRIBUTORS.md and commit trailers on the main branch; names as each person shows them on GitHub. Counts change hourly and are dated.

07//Follow the race

Sources

Read it, re-run it, argue with it.

  1. OpenAI, “Integer multiplication below n log n”, dated 23 Sep 2026, made public 6 Oct 2026, openai/math @ adc7f12; provenance in the repository README.
  2. The race’s current record: certificates/selected-result.json; its review, community-batch1099-review.md; its exact certificate, ASSEMBLY.json.
  3. Record history: result-history.md and the commits linked in kappa-history.json.
  4. The bill and κ = a/(1+a): autoresearch.md §2; bottleneck-brief.md; credit for the sharp charge in r480-sharp-charge535/NOTICE.md.
  5. Who did what: pr-ledger.md (722 PRs inventoried, 13 Oct 2026), NOTICE, CONTRIBUTORS.md.
  6. D. Harvey and J. van der Hoeven, “Integer multiplication in time O(n log n)”, Annals of Mathematics 193 (2021). Kolmogorov’s seminar and Karatsuba’s method: A. A. Karatsuba, “The complexity of computations”, Proceedings of the Steklov Institute of Mathematics 211 (1995).