cert-machine · report · generated from the record

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.

0 25 50 75 100 60 45 30 15 0 minutes before the checker was stopped memory, GiB the machine’s limit, 119.2 GiB nanoda (Rust), second attempt: stopped 81 min after its start Lean’s kernel, fresh replay: stopped 6 h 42 min after its start con-leche, alone on the machine: stopped 63 min after its start
0 25 50 75 100 60 30 0 minutes before the stop memory, GiB limit, 119.2 GiB nanoda, 81 min in Lean’s kernel, 6 h 42 min in con-leche, 63 min in
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 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.

ReleaseAuthorsSaving κLeanVerdict here
lockqueue/intmul at 4738aeffPiaoyang Cui, Yiming Liu, David P. Woodruff2^-464.33.1CERTIFIED as amended
platypii/integer-mult-bounds-lean at aaf10926Dan Brown (jdb19937), Kenny Daniel (platypii)4222422970/2^46 (about 2^-14.02)4.34.1REFUSED on resources
Dates of the public record

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

2 · the community proof

Proves its statement; no second kernel finished

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
ChangePredictedOutcome
S0the body of the definition IntMulSubNLogN copied verbatim (comments dropped): the baselineacceptedaccepted
S1every bound variable renamed (M→T, k→j, C→c, N₀→n₀, L→n, p→q): alpha-equivalentacceptedaccepted
S2the definition named and not unfoldedacceptedaccepted
S3the input encoding named by its function (encodeNatPair) where the file writes the structure's field (encNatPair.encode): equal after unfolding one definition and one projectionacceptedaccepted
C12^46 made 2^45 throughout: the saving κ = 2^-45, a stronger claim than the one provedrefusedno verdict
C22^46 made 2^47 throughout: the saving κ = 2^-47, a weaker claim; implied by the canonical one, not the same statementrefusedno verdict
C3≤ made <refusedrefused
C4the conjunct that every stack alphabet is finite deletedrefusedrefused
C5the exponent of the logarithm made 2^46 where the file has 2^46 − 1: the plain n log n bound, with no saving at allrefusedno verdict
C6Nat.log2 L written Nat.log 2 L: the same function by a theorem, not by definitionnoneno verdict
C7the bound asked of SOME length above N₀ where the file asks it of every onerefusedrefused
C8the machine asked to compute the SUM of the two numbersrefusedrefused
C9the product written p.2 * p.1: equal by commutativity, not by definitionnonerefused
C10the condition 0 < C deletedrefusedrefused
C11the time taken at length L + 1 where the file takes it at Lrefusedno verdict
The 13 statements planted against the community proof
ChangePredictedOutcome
S0the body of the definition MulInTime with κ = 4222422970/2^46 put in: the baselineacceptedaccepted
S1every bound variable renamed (M→T, p→q, n→m): alpha-equivalentacceptedaccepted
S2the definition named and not unfoldedacceptedaccepted
S3the abbreviation pairEnc written out as Mathlib's product encodingacceptedaccepted
C1the numerator of κ raised by one (4222422971/2^46): a slightly stronger claimrefusedrefused
C2κ made 1/2^14, just above the proved 2^-14.02refusedrefused
C3the exponent of the logarithm made 1: the plain n log n bound, with no savingrefusedrefused
C4big O made little orefusedrefused
C5the machine asked to compute the SUM of the two numbersrefusedrefused
C6the natural logarithm made the logarithm to base 2: the same class of functions, another statementrefusedrefused
C7the time taken at length n + 1 where the file takes it at nrefusedrefused
C8the product written p.2 * p.1: equal by commutativity, not by definitionnonerefused
C9the clause that every stack alphabet is finite ADDED, as the other release states it: a stronger statement than this file'srefusedrefused
The Google/CMU release’s own nine controls, run here
ControlWhat it changesOutcome hereAs the release reports
S0_IdenticalCopya byte-identical copy of the statementacceptedyes
S1_Exp45the exponent 46 made 45refused: the statement does not matchyes
S2_NoFinitethe finite-alphabets clause deletedrefused: the statement does not matchyes
S3_StrictLt≤ made <refused: the statement does not matchyes
P1_Sorrythe proof replaced by sorryrefused: an axiom outside the threeyes
P2_AddedAxioman added axiomrefused: an axiom outside the threeyes
P3_NativeDecidenative_deciderefused: an axiom outside the threeyes
P4_ExtraAxiomTransitivean axiom hidden one step awayrefused: an axiom outside the threeyes
P5_DefinitionSwapthe statement redefined as Truerefused: the statement does not matchyes
5 · the released programs

Exact on every input tried, and what they are

6 · in plain numbers

What the theorem buys

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

check it yourself

How to re-read it

contact

Write to Carlos

Sent by Web3Forms to Carlos’s inbox; nothing stored here.

Or write to carlos@carlostoledo.co, or open the public pilot form on GitHub.