Integer multiplication below n log n: two Lean proofs, replayed by a second party
Two groups have published Lean proofs that two n-bit integers can be multiplied in fewer than n log n steps on a Turing machine, a result OpenAI announced in a manuscript: Piaoyang Cui, Yiming Liu and David Woodruff (Google and CMU), and Dan Brown and Kenny Daniel (jdb19937 and platypii on GitHub, a community project). The mathematics and the proofs are theirs. With Claude (Anthropic’s AI model), I rebuilt both from source on a rented machine, under questions written down before the run. The Google/CMU proof is accepted by three independent checkers. The community proof builds and proves its own statement, but no second checker finished on it: each ran out of memory. I also proved, in Lean, that the community proof gives the Google/CMU statement.
What stopped the second check of the community proof. Three checkers written independently of each other were given the proof to re-check from nothing. Each ran quietly, then its memory climbed past 100 GiB within minutes and it was stopped just under the machine’s limit. Lean’s kernel had been quiet for more than six hours before the hour shown. One reading a minute; a measurement, drawn dashed because nothing here is an exact decision. Nothing rejected the proof.Records: certs/intmul-audit.json · sha256 cdb168dbcf80; corpus/intmul/pod/extra/guard3.txt · sha256 ee22afdb5f3fThe build refuses this figure if a curve does not start under 12 GiB an hour before its stop, or does not end between 100 GiB and the machine’s limit.
checkers that accept the Google/CMU proof
3
Lean’s kernel, nanoda and con-leche, each on the whole proof
second checkers that finished on the community proof
0
nanoda, a fresh Lean replay and con-leche all stopped; nothing rejected it
planted wrong proofs caught
6 of 6
three in each proof: sorry, an added axiom, native_decide
products of the released programs
291 of 291
exact against Python’s integers
This page checks two releases; it is not new mathematics and it does not rank them. The result is OpenAI’s claim; the proofs are their authors’. The checks are mine, run with Claude (Anthropic’s AI model), which wrote the programs and the Lean files under my direction.
read this first
What is still open
The community proof has no second kernel. nanoda was stopped on memory twice (114,017 MiB of 122,070 the first time, 114.8 GiB the second). Lean’s own kernel, replaying the whole closure afresh, was stopped at 115.2 GiB after 6 h 42 min. A third checker, con-leche, alone on the machine, stayed under 10 GiB for 54 minutes, then grew by more than 10 GiB a minute and was stopped at 100.7 GiB. Nothing rejected the proof. On a second machine con-leche’s heartbeat names the theorem it was on when the growth began, stage_source_trace, and Lean’s own kernel runs out of memory replaying that theorem’s module alone, which the ordinary build compiled in 98 seconds. Why a replay costs what the build did not is not known.
Some planted statements got no verdict. 5 of the 15 statements planted against the Google/CMU proof got no verdict from the intake: its check ran into the elaborator’s recursion limit under the 2^46 power. Every one that changes the saving is among them. The sentence written before the run is met only as amended afterwards. What those statements were meant to show comes from two checks added after the run.
The theorem joining the two statements is partial. It goes one way, was accepted by one kernel, and rebuilds the community machine instead of opening the one inside their theorem.
The statements were read, not decided. Neither formal statement is its paper’s theorem as written: both are about Mathlib’s multi-stack machine, and the step to a multitape machine is a classical argument that neither release formalizes. That the statements say what the papers say is a reading, made twice.
A third proof was not audited. A third Lean development of the same result exists (Prove2Me, prove2me/formalpedia). It was not audited here, and who was first is not decided here.
Nothing here is about practical speed. The saving reaches a factor of 2 only at sizes no computer will hold, the constants are not given, and the fast algorithm itself is not executable at any feasible size.
The comparator runs are not the planned ones. They used the release’s own statement and configuration for Google/CMU and a challenge module written here for the community proof, not a statement typed from the paper as the plan said. Comparator’s sandbox ran in best-effort mode on this machine.
The source is not judged. OpenAI’s manuscript, which both proofs point to, is not judged here.
the claim
Below n log n, by a factor that grows very slowly
Since 2021 the fastest known way to multiply two n-bit integers on a Turing machine has taken about n log n steps (Harvey and van der Hoeven), and many expected that to be the end. The new claim is a bound of n·(log n)^(1 − κ) for a fixed κ > 0: n log n divided by (log n)^κ. The three public numbers for κ are OpenAI’s 2^-182, Google/CMU’s 2^-46, and the community’s 4222422970/2^46 (about 2^-14.02). A larger κ is a stronger theorem.
Both proofs audited here state the result on Mathlib’s multi-stack Turing machine. A third Lean development, on Prove2Me, uses a model of its own and was not audited.
Read from the sources named, by public record only. Private dates are unknown and no priority is decided here.
23 September 2026. OpenAI: The date on the manuscript “Integer multiplication below n log n” (κ = 2^-182). It became public on 2026-10-06, with the first commit of openai/math. Source: openai/math, preprints/Integer-multiplication-below-n-log-n-September-23-2026/paper.pdf; the repository’s first commit adc7f124 (2026-10-06 21:58:50).
15 October 2026. Dan Brown (jdb19937), Kenny Daniel (platypii): The community repository merges a complete Lean proof on Mathlib’s multi-stack machine, at κ = 296/(10^11·2^131), with its own check of the three axioms. Source: platypii/integer-mult-bounds-lean, pull request #3, merged 06:26:49 as 9a7e575f.
15 October 2026. Kenny Daniel (platypii): Asks the upstream community for “Independent review of the linked theorem statement and machine/time model”. Still open when read. Source: CrocSwap/integer-mult-bounds, pull request #2411.
15 October 2026. ywz65: A note on the community statement: Mathlib’s machine makes only the input alphabet finite, and a kernel-checked lemma on definitions extracted from Mathlib shows that the alphabet a machine can reach is finite anyway. Source: CrocSwap/integer-mult-bounds, research/fintm2-reachable-alphabet, commit 9f397bb6.
17 October 2026. Prove2Me: A third Lean development, in a k-tape model of its own, at OpenAI’s κ = 2^-182; later at 3666565558019/10^17 (2026-10-21). Not audited here. Source: prove2me/formalpedia, envs/0df444a/Solutions/Sol_NLogN_KFTop_kappa_bound.lean; the platform’s campaign page.
22 October 2026. Kenny Daniel (platypii): The community theorem reaches κ = 4222422970/2^46, the saving it has at the commit audited here. Source: platypii/integer-mult-bounds-lean, commit 4b9ea4b6, IntegerMultBounds/MathlibTM2/Theorem.lean.
26 October 2026. Piaoyang Cui, Yiming Liu, David P. Woodruff: First public push of the Google/CMU repository; the paper carries the date 2026-10-25 and κ = 2^-46. The commit audited here is of 2026-11-10. Source: lockqueue/intmul, the repository’s events; IntMul_main_paper.pdf, title page; commit 4738aeff.
13 November 2026. Google Research: The post “Advancing science & engineering with Antigravity’s /teamwork feature” links the Google/CMU repository. Source: research.google/blog, the post of 2026-11-13.
1 · the Google/CMU proof
Accepted by three independent checkers
Built from source. The release at its pinned commit, with its own Lean 4.33.1: 10,447 build steps, no error. The headline theorem SubNLogN.Assembly.intMul_challenge has the type SubNLogN.Challenge.IntMulSubNLogN, the proposition of the release’s 80-line statement file, and rests on propext, Quot.sound, Classical.choice and nothing else.
Lean’s kernel. It checked every module of the release as it was built. Afterwards a fresh replay of the whole proof, Mathlib included, also passed (1 h 24 min).
nanoda. An independent kernel written in Rust: it accepts all 124,416 declarations of the exported proof.
con-leche. A third checker, run in its default mode on the same export: accepted. Its count of declarations (120,324) is not nanoda’s; the two tools count differently and I did not reconcile them.
The authors’ own check, repeated. The release ships a configuration for Comparator, the tool that checks a proof against a separately written statement. Run here on another machine, it accepts under both of its kernels. This repeats the authors’ check; it is not a different kind of evidence. Comparator’s first attempt here ended in a stack overflow inside nanoda, with the nanoda build I had made for the intake; the run that counts used the nanoda commit the release names.
One checker gave no verdict. lean4lean, a kernel written in Lean, stopped at its own recursion limit after 30 min on the fresh replay. That is its limit, not a rejection.
The word.CERTIFIED with one amendment, stated under “planted errors” below: five of my planted statements got no verdict, so the sentence I wrote before the run is met only in an amended reading.
2 · the community proof
Proves its statement; no second kernel finished
What holds. The release at its pinned commit builds from source with its own Lean 4.34.1: 14,288 build steps, no error, so Lean’s kernel accepted every module. The theorem IntegerMultBounds.MathlibTM2.mulInTime proves IntegerMultBounds.MathlibTM2.MulInTime (4222422970 / 2 ^ 46) on the three standard axioms. All 13 of my planted statements came out as predicted, and the three planted wrong proofs were caught.
What did not finish: nanoda. The second kernel I had named before the run was stopped on memory twice. The first time the run’s own watchdog stopped it, 76 minutes in, while a tool build of mine shared the machine: how much of that memory was mine cannot be separated from the log. I ran the same step again by hand, from the same binary, configuration and export. It stayed small for about 70 minutes, then passed 100 GiB within ten, and was stopped at 114.8 GiB.
What did not finish: Lean’s own kernel, afresh. A fresh replay of the whole proof by Lean’s kernel stayed under 12 GiB for hours, then grew to 115.2 GiB in under half an hour; I stopped it after 6 h 42 min. The machine’s limit was 119 GiB.
What did not finish: con-leche. A third checker, run on the same export as the last optional step, this time alone on the machine. It stayed under 10 GiB for 54 minutes, then grew by more than 10 GiB a minute, and my guard stopped it at 100.7 GiB. It printed nothing.
Comparator. The release ships no statement file for Comparator, so I wrote one. With the saving raised by one unit in its numerator, Comparator refuses: the statements do not match. On the true statement it gave no verdict: it was still running after five hours when my memory guard stopped it, and I did not run it again.
The same pattern in three checkers. Memory grew without bound after a long quiet stretch in every run whose input contains this proof: nanoda on the proof, nanoda on the joined theorem below, Lean’s kernel on the fresh replay, and con-leche. The three checkers are written independently of each other. During the ordinary build, Lean’s kernel checked the same modules within the same memory. A scan of the export for very large number literals found nothing.
Where it happens, named. On a second machine I built the proof again; its export is the same file, byte for byte. con-leche’s heartbeat names the check it was on when the growth began: the theorem DesignB.stage_source_trace, in M8/Global/DataTraceB.lean. Ten seconds before it began, con-leche’s memory read 2.9 GiB. It was stopped at 100.4 GiB with that one theorem unfinished after 589 seconds, while the other workers completed 7,762 checks.
Lean’s own kernel on that one module. Replaying only that module on top of its imports, Lean’s checker ended with “out of memory” after 9 min 09 s at 84.9 GiB, under a limit of 90 that I set. The ordinary build compiles the same module in 98 seconds. Why a replay costs what the build did not, I do not know. I have also not shown that nanoda and the fresh replay were on this theorem: neither says where it is.
The word.REFUSED on resources: a check did not give its positive answer, and the reason is memory. Nothing rejected the proof. A machine with more memory, or the cause found, would settle it; I did not rent a larger one.
3 · the two statements
Read twice, then joined by a theorem
Two readings. Before the runs, each statement file was read against its paper twice, by readers who did not see each other’s notes (Claude sessions, under my direction). They agree. This is a reading, kept apart from the verdicts.
What the readings found. Neither proposition is its paper’s theorem as written. Both are about Mathlib’s multi-stack machine (FinTM2), on least-significant-bit-first words, with time measured in the total encoded length. The papers speak of a multitape machine. The step between the two is a classical simulation, argued in prose in both releases and formalized in neither; the Google/CMU paper says so.
The differences between the two. The input is written differently (a separator symbol against tagged halves), the bound is written differently (an inequality in whole numbers against big-O over the reals), the Google/CMU statement asks every stack alphabet to be finite and the community statement does not, and the savings differ.
The encodings, on small pairs. Each release’s encoder was evaluated in Lean against an encoder of mine on 328 pairs of numbers: all agree.
The joining theorem.IntMulBridge.community_proves_challenge : SubNLogN.Challenge.IntMulSubNLogN. The community proof gives the Google/CMU statement, as the Google/CMU statement file words it: compiled in the community release’s environment (Lean 4.34.1), importing the community’s theorem and a byte-identical copy of the Google/CMU statement file. It rests on the three standard axioms and was accepted by one kernel, Lean’s; nanoda on its export was stopped on memory, like the proof it imports. Under the words fixed before the run that is not CERTIFIED, which asks for two kernels.
Finite alphabets. To supply the clause the community statement lacks, one module rebuilds the community machine along the community’s own lemmas and carries the finiteness through. That an unreachable part of an alphabet cannot matter was already shown for this statement by ywz65 on 15 October 2026, with a kernel-checked lemma on definitions extracted from Mathlib; the module here is inside a real Mathlib import and specific to this machine.
What the joining theorem does not say
One direction only. That the Google/CMU proof gives the community statement at κ = 2^-46 is a written argument (second reading, section 3); it is not built. It cannot give the community theorem itself, whose saving is larger.
The finite-alphabets module rebuilds the community machine through the community’s own lemmas. It is not proved equal to the machine hidden inside their existential theorem, which cannot be taken out and asked.
The two releases pin different Lean and Mathlib versions. The statement proved here is the Google/CMU statement file compiled under the community’s versions: the same bytes, and four Mathlib files diffed at both pins (no definition differs); the definitions underneath (asymptotics, real powers, logarithms) were not diffed.
One kernel. Lean’s kernel accepted the five modules; nanoda on the export was stopped on memory. The theorem imports the community proof, so it inherits that proof’s missing second kernel.
Its four parts
IntMulBridge.natForm_iff_bigOForm: for one time function, the Google/CMU inequality in ℕ and the community’s =O form at κ = 2^-46 are equivalent.
IntMulBridge.community_to_natForm: the community’s bound at its κ gives the Google/CMU inequality.
IntMulEnc.reencode: a machine for the tagged input encoding, with finite alphabets, gives one for the separator encoding, with finite alphabets, at a linear extra cost.
IntMulBridge.mulInTimeFinite: the community machine rebuilt along the community’s own chain, carrying that every stack alphabet is finite.
4 · planted errors
What would have caught a wrong result
Planted statements. For each proof I wrote variants of its statement before the run, some reworded and some changed, each with a prediction: the proof must still prove a rewording and must fail to prove a change.
Google/CMU: 10 of 15 got a verdict. All 10 came out as predicted or, where I had made no prediction, were refused. The other 5 got no verdict: my check tried to unfold the 2^46 power and ran into Lean’s recursion limit. They include every variant that changes the saving, so as run, this check did not show that it tells κ = 2^-46 from κ = 2^-45.
The amendment. Before the run I wrote that every prediction would be met among the statements that reached the check. Those 5 reached it and got no verdict, so that sentence is not met as written. I now read it as “among the statements that got a verdict”, and I say so here and in the record.
Two checks added afterwards. First, every planted statement of both proofs was compared with its statement as an expression, with nothing unfolded: all 20 changed statements differ. Second, Comparator on the release’s own nine controls: its exponent-45 control is refused because the statement does not match.
Community: 13 of 13 got a verdict. All as predicted, the variants of the saving included.
Planted wrong proofs. In each release’s theorem file: the proof replaced by sorry, the theorem proved by an added axiom, and one step decided by native_decide. All 6 are caught by the list of axioms. One of them, the added axiom, was also exported and shown to nanoda, which fails on it.
The 15 statements planted against the Google/CMU proof
Change
Predicted
Outcome
S0
the body of the definition IntMulSubNLogN copied verbatim (comments dropped): the baseline
the input encoding named by its function (encodeNatPair) where the file writes the structure's field (encNatPair.encode): equal after unfolding one definition and one projection
accepted
accepted
C1
2^46 made 2^45 throughout: the saving κ = 2^-45, a stronger claim than the one proved
refused
no verdict
C2
2^46 made 2^47 throughout: the saving κ = 2^-47, a weaker claim; implied by the canonical one, not the same statement
refused
no verdict
C3
≤ made <
refused
refused
C4
the conjunct that every stack alphabet is finite deleted
refused
refused
C5
the exponent of the logarithm made 2^46 where the file has 2^46 − 1: the plain n log n bound, with no saving at all
refused
no verdict
C6
Nat.log2 L written Nat.log 2 L: the same function by a theorem, not by definition
none
no verdict
C7
the bound asked of SOME length above N₀ where the file asks it of every one
refused
refused
C8
the machine asked to compute the SUM of the two numbers
refused
refused
C9
the product written p.2 * p.1: equal by commutativity, not by definition
none
refused
C10
the condition 0 < C deleted
refused
refused
C11
the time taken at length L + 1 where the file takes it at L
refused
no verdict
The 13 statements planted against the community proof
Change
Predicted
Outcome
S0
the body of the definition MulInTime with κ = 4222422970/2^46 put in: the baseline
accepted
accepted
S1
every bound variable renamed (M→T, p→q, n→m): alpha-equivalent
accepted
accepted
S2
the definition named and not unfolded
accepted
accepted
S3
the abbreviation pairEnc written out as Mathlib's product encoding
accepted
accepted
C1
the numerator of κ raised by one (4222422971/2^46): a slightly stronger claim
refused
refused
C2
κ made 1/2^14, just above the proved 2^-14.02
refused
refused
C3
the exponent of the logarithm made 1: the plain n log n bound, with no saving
refused
refused
C4
big O made little o
refused
refused
C5
the machine asked to compute the SUM of the two numbers
refused
refused
C6
the natural logarithm made the logarithm to base 2: the same class of functions, another statement
refused
refused
C7
the time taken at length n + 1 where the file takes it at n
refused
refused
C8
the product written p.2 * p.1: equal by commutativity, not by definition
none
refused
C9
the clause that every stack alphabet is finite ADDED, as the other release states it: a stronger statement than this file's
refused
refused
The Google/CMU release’s own nine controls, run here
Control
What it changes
Outcome here
As the release reports
S0_IdenticalCopy
a byte-identical copy of the statement
accepted
yes
S1_Exp45
the exponent 46 made 45
refused: the statement does not match
yes
S2_NoFinite
the finite-alphabets clause deleted
refused: the statement does not match
yes
S3_StrictLt
≤ made <
refused: the statement does not match
yes
P1_Sorry
the proof replaced by sorry
refused: an axiom outside the three
yes
P2_AddedAxiom
an added axiom
refused: an axiom outside the three
yes
P3_NativeDecide
native_decide
refused: an axiom outside the three
yes
P4_ExtraAxiomTransitive
an axiom hidden one step away
refused: an axiom outside the three
yes
P5_DefinitionSwap
the statement redefined as True
refused: the statement does not match
yes
5 · the released programs
Exact on every input tried, and what they are
The C program. 55 products, from 4,096 to 100,000,000 bits, in both of its modes, zero and one included: every one equals the product computed by Python’s integers. The C program implements the companion O(n log n) multiplier, not the algorithm below n log n, by its own README. “Exact” is a fact about that program; its arithmetic is GMP’s.
The Python reference. 236 products, each equal to Python’s own, with the library’s counters recorded for each row to show which path ran: 82 ran the new transform on test parameters, 70 fell back to the two-dimensional transform, and 48 returned Python’s own product through the small-input shortcut.
What neither shows. Algorithm 1 at the theorem’s parameters is not executable at any feasible size, by the release’s own statement. Nothing here measures speed, and no timing is quoted: the rows ran while the machine was building.
6 · in plain numbers
What the theorem buys
Google/CMU. The bound is n·(log2 n)^(1 − 2^-46): n log n divided by (log2 n)^(2^-46). That divisor equals 2 exactly when log2 n = 2^(2^46), that is for inputs of 2^(2^(2^46)) bits, and is below 2 for every shorter input.
Community. The bound is O(n·(ln n)^(1 − κ)): n ln n divided by (ln n)^κ. That divisor equals 2 exactly when ln n = 2^(1/κ), with 1/κ a little over 16,665. The saving is 2^-14.02, rounded.
The constants. In both statements the constant in front and the length from which the bound holds are asserted to exist and are not given.
So. This is a theorem about the shape of a bound at sizes far beyond any computer. Its interest is that n log n is not optimal, not that anything multiplies faster today.
departures
What changed after the questions were written
The questions, the verdict words and the stop rules were committed before the rented machine existed; their digest reached a public place only after the first result (see A11). Everything that departed from them is listed in corpus/intmul/amendments.json, 17 entries. The pre-registration itself was not edited.
The 17 amendments
A1 · Q1, Q4 · the sentence about the planted statements (Google/CMU). Not met as written. Five of the fifteen statements planted against the Google/CMU proof (C1 and C2, the exponent 45 and 47; C5, plain n log n; C11, the time at L + 1; C6, another spelling of the logarithm) were elaborated, reached the check, and got no verdict: the check ran into the elaborator’s recursion limit while unfolding the 2^46 power. Four of the five carried a prediction (refused). The record’s note that they “never reached the identity check” is false for these five; the string is the tool’s and is not changed here, because changing it re-derives seven older records. The sentence is read from now on as “among the planted statements that got a verdict”: ten got one, each as predicted. Every statement that changes the saving is among the five, so as run the intake’s check did not show that it tells κ = 2^-46 from κ = 2^-45. Two checks were added after the run to show it: (a) a structural comparison of every planted statement of both specs with its statement, as expressions and with nothing unfolded (corpus/intmul/checks/first, results in corpus/intmul/pod/extra/struct): every changed statement differs; (b) comparator on the release’s own nine controls, where the exponent-45 control is refused because the statement does not match. The word for the Google/CMU proof stays CERTIFIED with this amendment named beside it.
A2 · Q1 · what the Google/CMU intake record says about kernels, identity and hypotheses. “kernels: ACCEPT (3 run)” counts three entries; they are two kernels, and the second entry (leanchecker without --fresh) replayed a module of two declarations. In the registered run Lean’s kernel checked the release’s modules as they were built from source (Mathlib’s compiled files came from its cache), and nanoda checked the whole closure, Mathlib included (124,416 declarations). A fresh replay of the whole closure by Lean’s kernel (leanchecker --fresh on the headline module) was run afterwards and exits 0. In this spec the statement is given as a named definition, so F1’s “equal as expressions” compares that name with itself and could not come out false; the evidence that the name is the text of the pinned file is the planted statement S0 (the body typed out, accepted) and the file’s sha256. F3’s CERTIFIED cannot fail in this mode and reports nothing; the statement was read by hand to be a bare existence claim with no hypothesis. The controls summary line “3 refused, 0 accepted, of 3 (kernel decides)” misdescribes this spec. The record’s hazards scan covers the 25-line theorem file only, and its two hits are comments; a scan of every Lean file of both releases is in corpus/intmul/checks/first/hazards.json (a flag, never a verdict).
A3 · Q4 · a count in the pre-registration. Three do: C6 and C9 of the Google/CMU spec, C8 of the community spec.
A4 · Q1 · the community proof’s second kernel, and how the registered run ended. The registered run did not end by itself. 76 minutes into its nanoda step (03:35:38) the run’s own memory watchdog stopped it at 114,017 MiB of the container’s 122,070 (it counts file cache); the run’s exit is 143. At that moment the pod was shared: nanoda on the joined theorem’s export had been running since 02:25, and a tool for the optional checks (con-leche) was being built from 03:12:53 to 03:36:04, by us. The container’s memory rose from about 69,000 MiB to 114,017 MiB over exactly that interval. How much of the rise was nanoda’s own and how much was ours cannot be separated from the log. The step was run again by hand from the same binary, configuration and export (sha256 of each in _resumed.json), started 03:40:07. It held under 9 GiB for about 70 minutes, then grew past 100 GiB in the next ten, and our guard stopped it at 05:01:01 with nanoda alone at 114.8 GiB (exit 137, 4,868.8 s). The record’s word for that kernel, “REJECTS OR STOPPED”, is the tool’s; it was stopped both times and never printed a rejection. The verdict for the community proof is REFUSED on resources. No larger machine was rented: the plan says to ask first.
A5 · Q1, Q3 · the same growth in four runs and three checkers, cause not found. Memory grew past 100 GiB after a long flat stretch in four runs whose input contains the community proof: nanoda on the registered export (A4); nanoda on the joined theorem’s export (started 02:25; the first reading of it alone is 48.4 GiB at 04:09:51 and the last 103.5 GiB at 04:14:11; stopped by our guard at 04:14:26); and Lean’s own kernel replaying the whole closure afresh (leanchecker --fresh on the theorem’s module: started 03:36; under 12 GiB in every reading from 04:09 to 09:54, then to 115.2 GiB in under half an hour, stopped by hand at 10:18:25 after 24,104 s, no output); and con-leche on the registered export (A8), the one run of the four made on an otherwise empty pod. Three checkers written independently show it. During the normal build Lean’s kernel accepted every module of the same proof inside the same memory. The cause was not found. One guess was tested and not supported: a scan of both exports for very large number literals (corpus/intmul/checks/diag/big_literals.py) found none near the size of an exponent; the largest are certificate data of up to 52,939 bits. Nothing was sent to the authors of either tool.
A6 · plan P3, P4 · comparator. Run after the registered runs, and not against a statement typed from the paper. Google/CMU: the release’s own challenge module and configurations (one positive, nine controls), in a copy of the checkout with the release’s own lakefile addition appended and replay/Replay copied to ./Replay; comparator v4.33.0 (3927ad38) built on Lean 4.33.1 with lean4export 15f6055e. The first attempt ended in a stack overflow inside nanoda, with the intake’s nanoda build 8de7e0c4 (comparator writes nanoda’s configuration with no stack size); the run that counts used the nanoda commit the release names (37cb87b7). It accepts under both kernels, and the nine controls come out as the release’s replay record says. So this is a second party repeating the authors’ own check on another machine, not a new kind of check. Community: the release ships no challenge module; one was written here (corpus/intmul/checks/xreplay) and installed in the registered checkout after the registered run was over, with comparator v4.34.0 (d03acab1) on Lean 4.34.1, lean4export 076e8e57, nanoda switched off because of A4. The control (the saving’s numerator raised by one) is refused: the statement does not match. The run on the true statement gave no verdict: our guard stopped it after 5 h 14 min when the fresh replay beside it passed 100 GiB; it held 7.4 GiB and had printed nothing after its build. It was not run again. The sandbox: landrun v0.1.18 (ec104f6e) through comparator’s own --best-effort on a kernel whose Landlock ABI is 4; the pod has no systemd, so the README’s RestrictAddressFamilies property was not applied and the stack limit was set with ulimit.
A7 · plan P3 · lean4lean. One try each, as optional checks. No lean4lean commit names Lean 4.33.1 or 4.34.1; its master (67f63b0c, on 4.33.0-rc2) was built with each toolchain forced. On 4.33.1 it builds: the headline module alone exits 0 (“checked 1 declarations”, which is one declaration and says little); the fresh replay of the closure stopped after 30 min 45 s at “(kernel) deep recursion detected” in SubNLogN.Machine.C5.NetAux.pm_hdMinus. That is lean4lean reaching its own limit, not a rejection, and it gives no verdict. On 4.34.1 it does not build (Batteries.Data.List.Basic fails), so it was not run on the community proof.
A8 · plan P3 · con-leche. con-leche master (cd2eceab, its own toolchain Lean 4.36.0) was run on each registered export in its default mode (--verified), with 8 threads, as the last optional check. Google/CMU: “accepted 120324 declarations”, exit 0, 2 min 33 s. Its count is not nanoda’s 124,416 on the same file; the two tools count differently and the difference was not reconciled. Community: no verdict. From 10:22, when the other con-leche run ended, it was alone on the pod: every reading for 53 minutes was under 10 GiB, and all but the first under 5; then it grew by about 17 GiB a minute, and our guard stopped it at 11:22:17 at 100.7 GiB, 62 min 48 s after its start; no output. con-leche is a third checker, not the pre-registered second kernel; its acceptance of the Google/CMU proof is stated beside that verdict and does not change the word.
A9 · Q3, plan P5 · the theorem joining the two statements. Both closed, and more was built than planned: one theorem, IntMulBridge.community_proves_challenge, whose type is the Google/CMU statement, compiled in the community release’s environment with the community theorem imported and the Google/CMU statement file copied byte for byte. To get the finite-alphabets clause, which the community statement does not have, IntMulBridge/Finite.lean rebuilds the community machine along the community’s own chain of lemmas; it is not proved equal to the machine inside their existential theorem. The other direction is not built. Lean’s kernel only: nanoda on the export was stopped on memory (A5). corpus/intmul/bridge/assembly/check.log was written on a text of Encodings.lean that differs from the final one in one comment line (corpus/intmul/pod/extra/bridge-encodings-comment.diff); all five modules were compiled again from the final texts before the export, and their sha256 on the pod equal the files kept here. The exporter for the joined theorem was lean4export at cacf989 (the bump to v4.34.0-rc2), and nanoda was configured to treat an unpermitted axiom as a hard error.
A10 · stop rule · “If the google-cmu run does not reproduce what its authors report, the community run is stopped until the difference is read.”. The authors report their exponent-45 control refused by comparator. Our intake’s exponent controls got no verdict, by another method (A1). The rule was read as not triggered, because no check contradicted the authors and the record came out as expected, and the community run started at 00:15 without a stop. A stricter reading would have stopped it. The comparator run made later reproduces all nine of their controls.
A11 · the pre-registration’s clock. The pre-registration and the two specs were committed at 2026-11-17 23:15:04, 47 seconds before the pod was created (23:15:51), on a local branch that was not pushed. Their digest reached a public place only at 2026-11-18 01:09:48 (the seal registry of this repository, commit 14b9f72a): after the first result (the Google/CMU record, 00:04) and before the second. The public clock therefore proves the pre-registration existed before the community result and before every optional check, not before the Google/CMU result.
A12 · tool versions the records do not name. For Lean 4.33.1 the intake tool picked lean4export by sorting tags and took 9fb131b (“bump toolchain to v4.33.0-rc2”), then set its toolchain to 4.33.1. The export it wrote was accepted by nanoda and by con-leche. The nanoda configuration of the registered Google/CMU run was written to the work folder, not to the facts; a copy is in corpus/intmul/pod/extra/gcmu-nanoda.json. No planted defect reaches the second kernel in the registered runs (they are caught by the list of axioms in a Lean build); afterwards one, the added axiom, was exported and shown to nanoda, which fails on it in both of its modes (corpus/intmul/pod/extra/red-R2-*).
A13 · Q2 · “the encodings evaluated on small pairs against an encoder of our own”. Done after the first result, not before: 328 pairs for each release, produced by an encoder written here and evaluated in Lean against each release’s encoder; every one holds. The two readings were made before the runs, by readers who did not see each other’s notes, and both worked their examples by hand.
A14 · Q5, plan P6 · the programs. The Python reference’s own test suite was not run. The first pass of the Python rows (216, all exact) carried labels that said more than ran and recorded no counter; a second pass (236 rows, all exact) records the library’s own counters for each row and replaces the first for every statement about which path ran. Zero and one, and 10^8 bits in the program’s other mode, were added to the C rows in the second pass. The first C script would read an empty product file as zero; no row depends on it. Sizes above 10^8 bits were not run.
A15 · timings. Every time in these files was taken on a pod that was doing something else at the same moment. None is a speed, and none is quoted as one.
A16 · said during the run and corrected. Three statements made while the pod was running were wrong and were corrected the same day: that three kernels had accepted the Google/CMU proof (at the time one of the three had replayed a two-declaration module; the fresh replay came later); that the Python reference had run “under schedules that force the new route” (the counters show what ran); and that the first stop of the community run was caused by our tool build alone (A4: it cannot be separated).
A17 · Q1 · the declaration named, on a second machine (added 2026-11-18, after the page was first published). A second pod (the same shape, cap US$ 8, no registered run on it) built the community proof again through the intake’s stages and exported it by the tool’s own recipe. The export’s sha256 equals the registered run’s (114e7e51...), so the checkers there read the same file. con-leche, the same binary as on the first pod, ran alone with its heartbeat every 10 seconds; each heartbeat line names the oldest check in flight. Its memory read 2.9 GiB at 15:29:10 UTC. At 15:29:18, by the heartbeat, it began the theorem IntegerMultBounds.MathlibTM2.M8.Global.DesignB.stage_source_trace (file IntegerMultBounds/MathlibTM2/M8/Global/DataTraceB.lean). From then it grew about 10 GiB a minute while the other workers completed 7,762 checks, and the sampler stopped it at 100.4 GiB with that one theorem 589 seconds in flight. One earlier theorem of the same design, centreBlock_gate_good, took 114 seconds and about 10 GiB, and finished. Then Lean’s own kernel was run on that one module alone, replayed on top of its imports as built (leanchecker without --fresh, a 15-minute limit and a 90 GiB address-space limit): it ended with INTERNAL PANIC: out of memory after 9 min 10 s at 84.9 GiB. The ordinary build had compiled the same module in 98 seconds. NOT SHOWN: that nanoda and the fresh replay on the first pod were on this declaration (neither says where it is); why a replay costs what the build did not. One guess was not tested: that under Lean’s module system the build’s kernel sees less of the imported definitions than a replay does. DEPARTURES on this pod: the sampler inside pod-locate-run.sh read the memory of the timing wrapper and not of con-leche, so memory.txt holds zeros and its stop could not have fired; a corrected sampler (guard-locate.sh, memory2.txt) ran from 15:14, 37 minutes into the run, so con-leche’s memory before that was not recorded here. The con-leche build was paused while the proof built, because the intake’s watchdog counts everything on the pod. Cost: US$ 2.97 (corpus/intmul/pod2/cost.json).
who did what
Each step is a separate job
The claim. OpenAI’s manuscript “Integer multiplication below n log n”. It is not judged here.
The proofs. Piaoyang Cui, Yiming Liu, David P. Woodruff (Google and CMU); Dan Brown (jdb19937) and Kenny Daniel (platypii), the community repository. The n log n algorithm all of this improves on is Harvey and van der Hoeven’s.
The note on finite alphabets. ywz65, in the upstream community repository.
The checkers. Lean, Mathlib, Comparator, nanoda, con-leche, lean4lean and lean4export: their authors.
The checks on this page. Carlos Toledo, with Claude (Anthropic), which wrote the programs, the planted statements and the Lean files of the joining theorem under my direction. The runs were made on 17 November 2026 and 18 November 2026 on one rented machine (16 processors, 128 GB), for US$ 10.89, and a second one of the same size to name the theorem, for US$ 2.97.
check it yourself
How to re-read it
The record.node tools/record-intmul.js --check re-derives certs/intmul-audit.json from the kept logs and refuses on any difference. It needs no Lean.
The joining theorem.corpus/intmul/bridge/assembly: five Lean files. They compile inside the community release at its pinned commit.
To run it again. The scripts that ran on the machine are in corpus/intmul/checks/pod-scripts and tools/runpod-lean-intake.sh. The community proof needs more than 119 GiB for a second kernel; that is the open item. The shortest way to see it: build the community release at its pinned commit, then run lake env leanchecker IntegerMultBounds.MathlibTM2.M8.Global.DataTraceB, which here ran out of memory in nine minutes.