Carlos Toledo · cert-machine · audit

Two claimed refutations of the Exponential Time Hypothesis: what was decided, and what was only read

OpenAI and Anthropic each published a Lean proof meant to show that ETH is false. Here both proofs were replayed from their pinned bytes, and two kernels accepted each one against its own statement. A kernel cannot say what a statement means. Whether each statement says “ETH is false” was read by two independent readers, and the page keeps the two kinds of check apart.

Disclosure. This repository’s tools are written with Claude, Anthropic’s model, and one of the two claims is Anthropic’s. Here independence means who decides, not who typed: nothing on this page was decided by Claude or by either lab’s code. The deciders are Comparator, Lean’s kernel and nanoda; the readings are ours, and say so.

“ETH is false”
not decided here
read against the textbook ETH (§2), bridged in each lab’s own machine model (§5); the step to a standard machine decided in Lean (§5b), both proofs rebuilt in that Lean
proofs decided
2 of 2
CERTIFIED, each against its own statement
kernels that accept each
2
Lean’s, inside Comparator, and nanoda
Comparator, OpenAI
3,076 s
peak 80 GiB in the container
Comparator, Anthropic
388 s
peak 24 GiB in the container
bridge theorems, ours
51
proved in Lean; each passes Lean’s kernel twice and nanoda; §5
decided
exact arithmetic backs it
computed
float, or a number someone printed; nothing decided it
§1 · decided

Both proofs check against their own statements

claimtoolchaintheoremsverdictaxiomsnanoda
openai/math @ 7ef5c0ccLean v4.34.1exact_count_and_satCERTIFIEDthe three standardoff as shipped; switched on here
anthropics/formal-math @ 16a5ce41Lean v4.33.1ethIsFalse
mainTheorem
CERTIFIEDthe three standardon, as shipped

What CERTIFIED means here. Comparator exit 0 with "Your solution is okay!", Lean's kernel and nanoda both accept, and #print axioms (our file) names only propext, Classical.choice, Quot.sound for every main theorem. It does not mean that a Lean statement is its paper’s theorem, nor that ETH is false. No machine checks that, and both claimants say so.

What was changed, and declared before the run.

  • enable_nanoda: true on each claim's own Comparator config (OpenAI ships false; Anthropic ships true); nothing else in either config changes
  • GLIBC_TUNABLES=glibc.malloc.mmap_max=0:glibc.malloc.arena_max=1 for every Lean step of both claims (each row's env says so): the workaround OpenAI's own lean/README.md prescribes when vm.max_map_count is too low (the pod's is 65,530), which lane K needed on RunPod (amendments 15 and 16). A malloc setting: it changes how Lean allocates memory, never what it checks
  • nanoda as lane K builds it: the ammkrn/nanoda_lib#44 patch (src/tc.rs) and the worker stack raised to 1 GiB (src/lib.rs); the diff is kept with the run (_nanoda.patch)
  • for Anthropic (Lean v4.33.1): Comparator v4.34.0 built with v4.34.1, so Comparator's Lean kernel is v4.34.1 replaying a v4.33.1 export (the v4.33.0 tag lacks the quotient post-check and the issue-68 fix, which v4.34.0 has); the export is made by lean4export v4.33.0 built with the claim's own v4.33.1, whose format differs from v4.34.0's only in omitting partial definitions (neither tree has one: census.json); leanchecker --fresh replays with the claim's own v4.33.1 kernel. Anthropic's own CI uses Comparator 57567492 and robsimmons/nanoda_lib 68d5ca9d; neither is used here
  • leanchecker --fresh ran on a later pod in fresh-only mode (runpod-69d9t7dxjffo6n, runpod-ijw7890hq4ed9x; tools/runpod-eth.sh FRESH_ONLY=1) for openai and anthropic: cloned again and checked against the same pins, prepared as before (OpenAI: lake update, the resolved revisions against the pinned manifest; lake exe cache get), built with the claimant's own build command outside any sandbox, then replayed. No Comparator, export or nanoda ran on that pod: the row's Comparator, kernel and axiom facts are its decided run's (run, at), and its leanchecker facts are that pod's (leanchecker.run, leanchecker.at)

The third replay. OpenAI’s proof replayed by leanchecker --fresh into an empty environment (exit 0, 2,896 s); Anthropic’s proof replayed by leanchecker --fresh into an empty environment (exit 0, 3,011 s). leanchecker re-checks every constant the solution module imports or declares, starting from an empty environment, with the claim’s own Lean (certs/eth-kernel.json, corpus/eth-refutation/POD.txt).

§2 · what it rests on

From “the proofs check” to “ETH is false”

The proofs are decided by two kernels, and the step from each statement to “ETH is false in that lab’s own model” is proved in Lean here (§5). What still stands between them and the sentence “ETH is false” is a premise, listed in the order the claim travels through it, each with where its checking stopped:

  1. assumed
    Our Lean ETH says what Impagliazzo and Paturi say How much it should worry you: this is the one that carries content. read: s_k is the infimum of the δ for which k-SAT has an O(2^{δn}) algorithm, and ETH is s_k > 0 for every k ≥ 3, transcribed from CCC 1999, p. 1. A model fixes the machine, the formulas and the input word; the four definitions then read the same in every model (ETHBridge/Generic.lean, byte-identical in both projects).
  2. assumed
    A machine step costs O(1) in the textbook’s model How much it should worry you: low. no longer needed as a premise for Anthropic’s statement, and through Hawkley’s chain for OpenAI’s: C2 (§5b) proves in Lean that a FinTM2 decider within ⌊c·2^(δn)⌋ steps gives a cslib multitape decider within c·2^(δn)·(L+1)^e + c steps, the simulation’s overhead included. What stays read is that Lean version seams between the steps change nothing.
  3. assumed
    A textbook 3-CNF becomes each input word in polynomial time How much it should worry you: low. proved in Lean for Anthropic’s word by C2 (§5b): relabel the variables densely, remove duplicate clauses and write encClauses 3, in polynomial time, preserving satisfiability, from the binary encCNF of any formula.
  4. assumed
    What the decision itself trusts How much it should worry you: low; a fault would have to fool two independent kernels the same way. the two kernels (Lean's, inside Comparator; nanoda), leanchecker, lean4export, Comparator's comparison code, landrun's Landlock sandbox (Comparator calls it with --best-effort; the pod's LSM list is in each row's env), the Mathlib cache fetched by lake exe cache get, the claimants' lakefiles (OpenAI's applies dependency patches at lake update; none touches Mathlib, census.json), and RunPod's machine. The sandbox ran best-effort: Landlock was unreadable inside the container.

Every premise is graded assumed, the grammar’s word for “no machine here checked it”, but they are not the same kind of risk. Only the first carries content: a formal definition of a definition is always a reading, and no proof can close it. The model and encoding steps put a polynomial factor in front of 2^{o(n)}, which changes nothing; the trust base was checked by two kernels. So this page decides that both proofs check, proves that each statement refutes ETH in its own lab’s model, and reads, without deciding, that ETH is false in the textbook’s model-free sense.

§3 · read

What each Lean statement says, in plain mathematics

OpenAI (exact_count_and_sat). For every k ≥ 2 there is one machine of the file’s own design (a standard multitape Turing machine with a three-letter alphabet) and constants C, A, d, such that on every set F of clauses of width at most k over n variables, written in the file’s canonical unary encoding of length L, it halts after T ≤ C·(L+1)^d·2^{A·n(ln ln(n+16))²/√ln(n+16)} steps with the exact number of satisfying assignments on one tape and the answer “satisfiable” as its halting state, in polynomial space. Because clauses are sets, L is polynomial in n, so for k = 3 the time is 2^{o(n)}. It does not appear: OAI-C defines no ETH, no s₃ and no reduction. Our bridge supplies it (§5). The exponent is the paper’s Proposition 6.4, weaker by a factor log log n than its headline Theorem 1.1, as OpenAI’s scope note says.

Anthropic (ETHIsFalse, MainTheorem). ETH is 0 < s₃, where s₃ is the infimum of the δ for which some finite machine of Mathlib’s FinTM2 kind and some c ∈ ℕ decide every duplicate-free 3-CNF list within ⌊c·2^{δn}⌋ steps, for every n and any number of clauses. ETHIsFalse is its negation. The Main Theorem gives one machine and one constant C counting the satisfying assignments within ⌊2^{C·min(km/√lg m, k²n lg lg n/√lg n)}⌋ steps, for k ≥ 1, m ≥ 2, n ≥ 4 with every variable occurring.

Both readers, separately: each statement, if proved, implies the textbook ETH (Impagliazzo–Paturi) is false, under the two textbook steps of §2 and nothing else. Neither found a loophole: no padding (the input length is polynomial in n in both), no hidden power in either machine (finite control, finite alphabets, one bounded step at a time), exact halting times, and promises that only restrict where a bound is claimed.

§4 · compared

The two statements side by side

OpenAIAnthropic
Lean boundC(L+1)^d·2^{A·n(ln ln(n+16))²/√ln(n+16)}, constants per k⌊2^{C·min(km/√lg m, k²n lg lg n/√lg n)}⌋, one absolute C
Lean bound against the paper’sweaker: Proposition 6.4, not Theorem 1.1the same, with ranges
ETH in Leanabsent from OpenAI’s files (ours: §5)defined, and its negation proved
Machine in Leanits own multitape machine on Mathlib’s tapesMathlib’s FinTM2 (multi-stack)
Input in Leana set of sets of literals, canonical sorted unary worda duplicate-free list, fixed-width binary slots
Uniform in kno: for each k a machineyes: one machine for every k
Spaceproved polynomialnot stated
nanoda in the shipped configoffon

Both papers reach the same shapes, n log log n/√log n for any formula and n/√log n for linearly many clauses, and both get their sharpest bound by recursively contracting Boolean tensor networks (OpenAI’s Appendix D, Anthropic’s §2). The two Lean developments formalize different routes: OpenAI’s the interpolation route of its §6.4, Anthropic’s the eight-square recursion.

One computed check. Anthropic’s key identity, eq. (12), the eight-square identity of Degen (1818) and Graves (1843), re-run at this build from the printed formula in exact integer arithmetic: it holds at all 4,096 settings (0 failures). The control, the same formula with i < j in place of i ≤ j, fails at 256, so the check can fail. This decides one printed line of the paper. It decides nothing about the proof.

§5 · the bridge

One textbook ETH in Lean, and each statement against it

OpenAI’s environmentLean v4.34.1 · Mathlib d13f23b7Anthropic’s environmentLean v4.33.1 · Mathlib 0df444a3the version seam, measured DIFFERENT — a statement read across it is read, not decidedC Comparator · K Lean’s kernel · N nanoda · L leanchecker --fresh — a tick only where the record says it acceptedOpenAI’s proofopenai/math @ 7ef5c0ccexact_count_and_satOpenAI’s statementCERTIFIEDCKNLAnthropic’s proofformal-math @ 16a5ce41ETHIsFalseAnthropic’s statementCERTIFIEDCKNL¬ ETHOpenAI’s modelPROVEDCKN¬ ETHAnthropic’s modelPROVEDCKN¬ #ETHOpenAI’s modelPROVEDCKN¬ #ETHAnthropic’s modelPROVEDCKN¬PositiveRateETHParityLifts, negatedCERTIFIEDKNLETHIsFalsevendored byte for byteCERTIFIEDCKNthe same bytesread, not decidedClaimOpenAI’s text, re-readthe same bytes · read, not decidedCERTIFIEDCKN
The map of the proofs. Boxes are statements and proofs; every solid edge is a Lean implication decided by the checks ticked under its word, read from that edge’s record: C Comparator, K Lean’s kernel, N nanoda, L leanchecker --fresh. Our bridge (certs/eth-bridge.json) refutes the textbook ETH and #ETH from each statement in that lab’s own model; Hawkley’s two links (certs/eth-hawkley-bridge.json, certs/eth-hawkley-heavy.json) live in OpenAI’s Lean, the heavy one proved from original_sat_main, OpenAI’s own theorem rebuilt on the same run, the light one ending at Anthropic’s statement file vendored byte for byte; TSavo’s join (certs/eth-tsavo-bridge.json) lives in Anthropic’s Lean and starts from OpenAI’s statement text re-read there. A hollow box is such a copy, and the dashed link to its original is a reading: the bytes are the same, but no single kernel has checked both ends across the version seam (certs/eth-seam.json, measured DIFFERENT).Records: certs/eth-kernel.json · sha256 09302f11bbae; certs/eth-bridge.json · sha256 8c2d0d15b4ad; certs/eth-tsavo-bridge.json · sha256 9349d0dfa43c; certs/eth-hawkley-bridge.json · sha256 8d00cca0cdc5; certs/eth-hawkley-heavy.json · sha256 7c88e9465fd4; certs/eth-seam.json · sha256 850db068fd46The build refuses this figure if an edge’s word is not CERTIFIED or PROVED in its record, a tick is drawn for a check its record does not say accepted, a third party’s join is drawn in an environment other than the one its record builds on, or a copied statement’s bytes are not the pinned original’s.

The textbook definition is written once, in Generic.lean (sha256 3965f8db48d3…, byte-identical in both projects). A model fixes four things: what a machine is, which formulas are k-SAT instances, the input word a formula is written as, and what “halts within t steps with answer b” means. Then s_k, the infimum of the δ for which k-SAT is decided within ⌊c·2^{δn}⌋ steps for every n, and ETH, s_k > 0 for every k ≥ 3, read the same in every model. Each lab’s statement is then proved to refute ETH in that lab’s own model:

  • OpenAI. its PrimitiveMachine, sets of clauses of width ≤ k, encodeCNF: theorem not_eth_of_claim (h : SqrtLogSpace.OpenAIClaim) : ¬ ETHBridge.ETH model — the three standard axioms; Lean v4.34.1, built in 19 s.
  • Anthropic. Mathlib’s FinTM2, duplicate-free clause lists, encClauses: theorem not_eth_of_ethIsFalse (h : MainResults.ETHIsFalse) : ¬ ETHBridge.ETH model — the three standard axioms; Lean v4.33.1, built in 15 s.

OpenAI. If OpenAI's challenge statement exact_count_and_sat holds, then ETH (s_k > 0 for every k ≥ 3) is false for PrimitiveMachines on encodeCNF; indeed s_k = 0 for every k ≥ 2 (s_eq_zero_of_claim). The three steps both readers did by hand are Lean lemmas now: the input word is polynomial in n, bitLength_succ_le {n k : ℕ} (F : SAT.CNF (Fin n)) (hF : SAT.WidthAtMost k F) : Encoding.formulaBitLength F + 1 ≤ (3 + (k + 1) * 2 ^ k * (4 + 8 * k)) * (n + 1) ^ (k + 1); the halting answer decides satisfiability, count_pos_iff {n : ℕ} (F : SAT.CNF (Fin n)) : 0 < SAT.count F ↔ IsSatisfiable F; and the running-time bound is at most c·2^{δn} for every n, bound_le (B A : ℝ) (p : ℕ) {δ : ℝ} (hδ : 0 < δ) : ∃ c : ℕ, ∀ n : ℕ, B * ((n : ℝ) + 1) ^ p * (2 : ℝ) ^ (A * SqrtLog.Statement.runtimeScale n) ≤ c * (2 : ℝ) ^ (δ * n).

Anthropic. Anthropic's ETHIsFalse implies that ETH (s_k > 0 for every k ≥ 3) is false for FinTM2 machines on encClauses; the generic DecidesKSat, InTime and s ARE Anthropic's, by definition (decidesKSat_iff, inTime_iff, s_eq). In Lean: s_eq (k : ℕ) : ETHBridge.s model k = MainResults.s k.

How the statements were copied. OpenAI’s challenge file is carried with one declared change: its open theorem exact_count_and_sat becomes the proposition OpenAIClaim, and undoing that change gives back the pinned sha256 4183b2057cff…. Anthropic’s MainResults.lean is carried unchanged (47f78a9550d9…). §1 decided that OpenAI’s proof proves exactly that statement, so the two together give ¬ETH in OpenAI’s model. The join is the identity of the statement’s bytes, not one Lean term: the bridge does not import OpenAI’s proof.

#ETH, the counting hypothesis, too. Both statements count the satisfying assignments, not only decide them, so the counting form of ETH (Dell, Husfeldt, Marx, Taslaman, Wahlén) falls as well. It is written once in the same file, def SharpETH : Prop := ∀ k : ℕ, 3 ≤ k → 0 < sharpS Co k, with s#_k the infimum of the δ for which some admissible machine writes the number of satisfying assignments of every k-CNF within ⌊c·2^{δn}⌋ steps, and proved false in each lab’s own counting model:

  • OpenAI. theorem not_sharpEth_of_claim (h : SqrtLogSpace.OpenAIClaim) : ¬ ETHBridge.SharpETH countModel — the count on the count tape, binary, lowest digit first, as exact_count_and_sat writes it.
  • Anthropic. theorem not_sharpEth_of_mainTheorem (h : MainResults.MainTheorem) : ¬ ETHBridge.SharpETH countModel — the count in binary n, n + 1 bits, lowest first. Anthropic's #ETH is #ETH on the formulas MainTheorem speaks of (IsKCNF k φ, at least two clauses, at least four variables, every variable occurring): MainResults.lean says nothing about any other input word. The other k-CNFs reduce to that class by standard steps (a finite table for fewer than four variables and k fixed; a closed form for fewer than two clauses; a variable that occurs nowhere doubles the count) that are NOT formalized. OpenAI's #ETH has no such restriction: its statement covers every formula of width at most k.

ETH and #ETH are proved separately here; neither refutation is derived from the other.

Checked three times. Every one of the 51 bridge theorems passes Lean’s kernel inside lake build, Lean’s kernel again inside Comparator on a fresh runner that never built the bridge, and nanoda, a kernel written independently of Lean’s (run 40947192141). Comparator’s statement check here compares our own text against itself; the labs’ statements enter through their pinned copies. No sorry, no axiom declared, no native_decide (certs/eth-bridge.json, the README).

Not proved, and said so:

  • The cross-model bridges stay prose for both claimants and here: that a PrimitiveMachine (OpenAI) or a FinTM2 machine (Anthropic) is simulated by a word RAM or a multitape Turing machine with polynomial overhead (first.md B1, B1′), and that a textbook 3-CNF is rewritten into encodeCNF / encClauses in time polynomial in its length (B2, B2′). ETH is proved false here in each claimant's own model, not in a model-free sense. The same holds for #ETH (and for encInput).
  • MainResults.ETH → ETHBridge.ETH (the converse of eth_of_eth) is not proved: it needs s_3 ≤ s_k for k ≥ 3, and Anthropic's encoding depends on k (k slots per clause), so a machine for 3-SAT does not run on a k-SAT word without a re-encoding machine. It is not needed for the bridge.
  • Anthropic's #ETH is #ETH on the formulas MainTheorem speaks of (IsKCNF k φ, at least two clauses, at least four variables, every variable occurring): MainResults.lean says nothing about any other input word. The other k-CNFs reduce to that class by standard steps (a finite table for fewer than four variables and k fixed; a closed form for fewer than two clauses; a variable that occurs nowhere doubles the count) that are NOT formalized. OpenAI's #ETH has no such restriction: its statement covers every formula of width at most k.
  • ETH and #ETH are separate consequences here: ETH → #ETH (counting is at least as hard as deciding) is not proved in either model, and neither refutation is derived from the other.
  • The Comparator challenge is generated from our own bridge files (every proof replaced by sorry), so its statement match checks our text against itself; the claimants' statements enter only through the pinned copies, as in lake build. leanchecker was not run on the bridge (the eth-kernel lane ran it on both claims' own proofs; the eth-tsavo lane did not run it).
  • Nothing here re-checks either claimant's proof: certs/eth-kernel.json is that lane.

The step between the two models, joined by someone else, and replayed here: CERTIFIED. TSavo/eth-bridge @ 34f9ca20 (TSavo; written with Claude, per its README) proves Bridge.ethIsFalse_of_claim : OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.Claim → MainResults.ETHIsFalse: OpenAI’s machine compiled into Anthropic’s, and OpenAI’s input word produced from Anthropic’s, so OpenAI’s statement refutes ETH in Anthropic’s FinTM2 model too. Replayed on GitHub’s runners (run 40789891989): the statement checks pass on the run's bytes; Comparator exit 0 with "Your solution is okay!" on TSavo's config (with the declared lakefile amendment); Lean's kernel and nanoda both accept; lake build Bridge exit 0; both theorems' axioms are among propext, Classical.choice, Quot.sound (certs/eth-tsavo-bridge.json).

Its gaps, first:

  • TSavo's README build does not run Comparator on TSavo's own config: on the README's lakefile (Anthropic's, plus [[lean_lib]] Bridge, srcDir "bridge", globs ["Bridge.+"]) Comparator stops at "Building BridgeChallenge" because Lake reports unknown target BridgeChallenge (exit 1): the glob Bridge.+ names Bridge and its submodules, and BridgeChallenge is neither. The replay declares ONE amendment, a [[lean_lib]] named BridgeChallenge with srcDir "bridge" appended to the lakefile (no Lean byte and no config byte changes), and decides on the run with it. TSavo's README says Anthropic's CI script accepted the bridge on 2026-10-27; the lakefile that run used must have made BridgeChallenge resolvable, and the README does not show how.
  • The seam between the two lanes is the Lean and Mathlib version: the bridge's Claim is OpenAI's challenge text re-elaborated on Lean v4.33.1 and Anthropic's Mathlib 0df444a3, while OpenAI's proof (certs/eth-kernel.json) is of exact_count_and_sat on Lean v4.34.1 and Mathlib d13f23b7. The source text is the same byte for byte (the statement check); that the two elaborate to the same term is not checked here, so OpenAI's theorem and TSavo's implication compose by reading, not by one kernel.
  • Comparator decides Bridge.ethIsFalse_of_claim only (the config's one theorem). Bridge.two_proofs_one_statement = ⟨MainResults.ethIsFalse, ethIsFalse_of_claim⟩ is checked by one kernel (Lean's, in lake build) and by its axiom print.
  • A stale comment: bridge/Bridge/Main.lean's header still says "Each sorry below is one of the four lemmas named in the plan"; no sorry remains outside comments (the census).
  • leanchecker --fresh was not run on this join (the eth-kernel lane replayed both claims' own proofs with it, not the join); the rule stands on Lean's kernel and nanoda inside Comparator.
The two definitional closures, constant by constant2,689 constants in either closure2,277 the same kernel term on both sides308 differ55 only in OpenAI’s (hollow)49 only in Anthropic’s (hollow)The 151 constants the statement names directly143 the same8 differthe 8 that differ, listed:natural power (Monoid.toNPow) · + (Real.instAdd)inverse (Real.instDivInvMonoid) · ≤ (Real.instLE)< (Real.instLT) · × (Real.instMul)1 (Real.instOne) · 0 (Real.instZero)
The seam as a grid. Every constant either statement reaches, exported from both environments as a kernel term and compared: of 2,585 in both closures, 2,277 are the same term and 308 differ; 55 exist only in OpenAI’s and 49 only in Anthropic’s (hollow). Of the 151 constants the statement names directly, 8 differ, listed beside the strip: the real numbers’ instances and the monoid power. Width is count; every block is decided.Record: certs/eth-seam.json · sha256 850db068fd46The build refuses this figure if a count in the seam record is not a whole number, more common constants differ than there are, a side’s closure is not the common part plus what is only on that side, or more named constants differ than the statement names.

The version seam, measured: DIFFERENT. The join reads OpenAI’s statement on Anthropic’s Lean and Mathlib, while OpenAI’s proof lives on its own. Both statements, and every definition they reach, were exported from both environments as kernel terms and compared (run 40947568989, certs/eth-seam.json). The statement itself is the same kernel term on both sides, apart from one binder’s name, and all 74 of OpenAI’s own definitions are identical. Underneath, the two Mathlibs build the real numbers differently: of 2,585 constants in both closures, 308 differ and 104 exist on one side only, mostly from a reworked monoid hierarchy and from files that moved. Of the 151 constants the statement names directly, 8 differ: natural power, +, inverse, ≤, <, ×, 1, 0 on ℝ. Lean’s kernel cannot match those terms across the two environments, so no single kernel has checked that the two statements are one proposition. It is almost certainly the same mathematics; the record says only that the terms differ, and where.

A second join, the other way round, and replayed here: CERTIFIED. thinkthoughts/math @ d6b79b7d (Daniel Hawkley, formalize.now; a fork of OpenAI’s release) proves OAI.Bridges.AnthropicETH.not_positiveRateETH_implies_ethIsFalse : ¬ OAI.ParityWL.Complexity.PositiveRateETH → MainResults.ETHIsFalse: OpenAI’s ParityLifts machines simulated on Anthropic’s FinTM2 and Anthropic’s input word converted to OpenAI’s, inside OpenAI’s own Lean and Mathlib, with Anthropic’s statement file vendored byte for byte. Replayed on GitHub’s runners (run 41634655114): git's facts hold (HEAD at the pin, a clean tree, the diff against openai/math@7ef5c0cc naming exactly the pinned delta); the statement checks pass on the run's bytes; lake update moved no pinned dependency; Comparator exit 0 with "Your solution is okay!" on the claimant's config with nanoda on; Lean's kernel and nanoda both accept; lake build exit 0; the theorem's axioms are among propext, Classical.choice, Quot.sound (certs/eth-hawkley-bridge.json). The link from OpenAI’s checked theorem to that predicate — his OAI.Bridges.ETH.not_positiveRateETH, proved from original_sat_main on top of OpenAI’s whole family-378 proof — was replayed on a rented machine (certs/eth-hawkley-heavy.json): CERTIFIED, the clone at the pin, OpenAI’s 3985 pinned files unchanged but the lakefile (his six-line block), his 36 files at their pins, lake update moving no dependency; lake build exit 0 (2357 s); #print axioms (our file) names only propext, Classical.choice, Quot.sound for his theorem and for OpenAI’s original_sat_main; nanoda accepts the theorem’s closure exported by lean4export (348 s) and rejects the negative control; leanchecker --fresh replayed the module into an empty environment (exit 0, 2612 s).

Its gaps, first:

  • The hypothesis is ParityLifts' predicate, not OpenAI's checked statement. ¬ OAI.ParityWL.Complexity.PositiveRateETH is a definition of OpenAI's combinatorics library (lean/OAI/Combinatorics/ParityLifts/SATChoice.lean, lines 24–35, sliced into the challenge), while what OpenAI's release checks with Comparator is OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.exact_count_and_sat (certs/eth-kernel.json). The link from OpenAI's theorem to ¬ PositiveRateETH is the claimant's SEPARATE theorem OAI.Bridges.ETH.not_positiveRateETH (lean/OAI/Bridges/ETH/FinalImplication.lean, his components A–C of 2026-11-01, commit 81ec97cd2 whose message says "NOT built in this environment"; his page says a later VPS build passed), which imports OpenAI's whole family-378 proof and is NOT replayed here (the hosted runner cannot hold that build: certs/openai-math-kernel-7ef5c0cc.json; a pod run is the operator's word). So this record, if CERTIFIED, decides ¬ PositiveRateETH → ETHIsFalse and nothing about ETH itself.
  • nanoda is off in the claimant's shipped config (enable_nanoda: false, like every challenge of openai/math); this replay turns it on, its one declared change, so both kernels decide here. The claimant reports nanoda aborting inside Comparator on a 32 MB thread stack in his harness and a standalone nanoda acceptance with a 1 GiB stack; here nanoda runs inside Comparator with the eth-kernel lane's 1 GiB-stack build.
  • The claimant states three qualifications of his own harness run (Landlock ABI v7 with an older landrun 3ee150a, no systemd-run wrapper, nanoda's stack); none applies here (landrun 811cfff5 as the eth-kernel lane pins it, the runner's LSM list in machine.txt), and his VPS run is his own report, not read here.
  • Independence of the proof from both labs' results is the claimant's claim, checked by his Audit.lean at constant level; here it is checked at the import level only (tools/eth-hawkley-gates.js closure: the solution reaches OAI.Combinatorics.ParityLifts.SATChoice and Mathlib, nothing under OAI.Algorithms or OAI.Bridges.ETH) and by Comparator's own statement comparison; his Audit module is not built here.
  • Anthropic's MainResults.lean is vendored into OpenAI's project and re-elaborated on Lean v4.34.1 with Mathlib d13f23b7, while Anthropic proved ETHIsFalse on Lean v4.33.1 with Mathlib 0df444a3 (certs/eth-kernel.json): the bytes are the same (the gates), the elaborated terms are not compared here — the same seam certs/eth-seam.json measured for the TSavo bridge, in the other direction.
  • leanchecker --fresh was not run on this theorem; the rule stands on Lean's kernel and nanoda inside Comparator.
  • Mentions of forbidden words inside comments (facts, not holes): lean/ComparatorChallenges/AnthropicETHCrossFormalization.lean (sorry ×1).
why these numbers stand as they do
  • decided — counted by comparing the exported kernel terms of the two closures (certs/eth-seam.json)
  • decided — the common constants minus the ones whose kernel terms differ
  • decided — the length of the record’s list of named constants whose terms differ
§5b · toward the standard machine

From the labs’ machines to a textbook one

The machine and the encoding, the two steps §2 read, are the gap every reader names. Since 4 November this lane works on them: proofs written by claimbox and its AI agents, decided here from pinned bytes. claimbox and this page have the same author, so a decision here separates roles; it is not a second party.

Who did what. The algorithms and the two statements are the labs’. The chain from OpenAI’s statement to Anthropic’s is Daniel Hawkley’s. D1 is complexitylib’s own proof, written by its AI agents. The statements of C1 and C2 were written by hand and pinned here before any proof was decided; their proofs, and the ports of both labs’ proofs to complexitylib’s Lean, were written by Claude agents in claimbox, the claimant. Every solid edge was decided here. C1 and the reusable part of C2 are offered upstream: complexitylib pull requests #2509 and #2510 (5 November 2026, on the maintainer’s invitation in #739), approved by the library’s reviewer agent, which is not human approval; merge pending. The focused report: Two AI labs’ ETH proofs, carried to a standard Turing machine in one Lean.

OpenAI’s environmentLean v4.34.1 · Mathlib d13f23b7exact_count_and_satOpenAI’s statementHawkleyCERTIFIEDKNETHIsFalsevendored, same bytesseam 1: readAnthropic’s environmentLean v4.33.1 · Mathlib 0df444a3complexitylib’s environmentLean v4.36.0-rc2 · cslib, Mathlib through its pinsboth seams crossed by proof: the ports and C1, C2 are claimbox’s claims (the claimant); every solid edge was decided hereC Lean’s judge (6; 4 named on the OpenAI chain) · K Lean’s kernel · N nanoda · L leanchecker --freshETHIsFalseAnthropic’s statementETHIsFalsesame bytes, proved hereOpenAI + Hawkleyclaimbox port · 20/3,210OpenAI chainCERTIFIEDCKNLAnthropic’s proofclaimbox port · 47/809Anthropic chainCERTIFIEDCKNLcomplexitylib’s proofnative, @ 1b7d62a8¬ ETHcslib multitape TM, encCNF¬ ETHword RAM, O(log L) wordsCERTIFIEDKNLD1CERTIFIEDCKNLC1CERTIFIEDCKNLC2ETH is falsethe textbook statementa reading of a definition, and always one
The chain toward a standard machine. Solid edges are Lean implications decided here, ticked by the checks their records say accepted; a hollow box is a copy read across a version seam; the top edge is Daniel Hawkley’s chain from OpenAI’s statement, inside OpenAI’s Lean (certs/eth-hawkley-heavy.json, certs/eth-hawkley-bridge.json); the dashed links to the textbook statement are readings. D1 is complexitylib’s own proof (certs/eth-cslib-d1.json); C1 is claimbox’s, with its three planted wrong variants refused (certs/eth-c1.json); C2 is claimbox’s, from Anthropic’s statement, with its three planted wrong variants refused (certs/eth-c2.json); the Anthropic chain is Anthropic’s proof ported into complexitylib’s Lean, so its statement is proved where C2 runs (certs/eth-chain.json); the OpenAI chain is OpenAI’s proof with Hawkley’s two links ported the same way, its C tick from Lean’s judge with four named checkers after the judge’s bundled checkers stopped at their limits, said in the record (certs/eth-openai-chain.json); C is Lean’s own judge, lake comparator --paranoid, run without its sandbox (certs/eth-comparator.json).Records: certs/eth-hawkley-bridge.json · sha256 8d00cca0cdc5; certs/eth-hawkley-heavy.json · sha256 7c88e9465fd4; certs/eth-cslib-d1.json · sha256 73f02f389c22; certs/eth-c1.json · sha256 5252012570a3; certs/eth-c2.json · sha256 71031dd48fae; certs/eth-chain.json · sha256 a6291d9300aa; certs/eth-openai-chain.json · sha256 8fdc50bc1a14; certs/eth-comparator.json · sha256 be2d801372c4The build refuses this figure if an edge’s word is not CERTIFIED or PROVED in its record, a tick is drawn for a check its record does not say accepted, C1, C2 or a chain is drawn solid while a planted variant was not refused, a C tick is drawn where Lean’s judge did not accept (all six checkers; on the OpenAI chain the four named checkers of the amendment of 2026-11-05), or D1 does not build on complexitylib’s Lean.
  • A native re-proof on a standard machine. CERTIFIED cslib-community/complexitylib (built by AI agents, reviewed by an AI reviewer) re-proves OpenAI’s Proposition 6.4 route from scratch, with ETH stated on cslib’s deterministic multitape Turing machine and the binary encoding encCNF, as close to the textbook model as a Lean statement has come. Decided here at 1b7d62a8: the build from source, the three standard axioms from our own file, nanoda accepting all 49,025 declarations beneath not_eth, leanchecker --fresh. It is a re-proof, not a bridge from either lab’s statement. certs/eth-cslib-d1.json.
  • ETH on a word RAM. CERTIFIED For every δ > 0 one fixed word-RAM program over the additive basis, reading the bits of encCNF φ one per word, decides 3-SAT within c·⌈2^(δ·n)⌉·(L+1)^e + c instructions at every word size of at least k·(⌊log₂ L⌋+1) bits: ETH is false on the word RAM with O(log L)-bit words. Decided: the statement byte-equal to the pin, the three standard axioms, nanoda accepting all 49,735 declarations beneath it, leanchecker --fresh, and the three planted variants refused. certs/eth-c1.json.
  • The labs’ own statements on the standard machine. CERTIFIED If Anthropic's ETHIsFalse holds (for every δ > 0 a deterministic Mathlib FinTM2 machine decides 3-SAT on duplicate-free formulas written as encClauses 3 within ⌊c·2^(δ·n)⌋ steps), then complexitylib's ETH is false: for every δ > 0 a deterministic cslib multitape Turing machine decides 3-SAT on every formula, written as the binary encCNF, within c·2^(δ·n)·(L+1)^e + c steps. Decided: the statement byte-equal to the pin, MainResults.lean byte-equal to Anthropic's, the three standard axioms, nanoda accepting all 23,430 declarations beneath it, leanchecker --fresh, and the three planted variants refused. MainResults.lean is Anthropic's file byte for byte, but elaborated here against complexitylib's Mathlib (Lean v4.36.0-rc2), not Anthropic's (v4.33.1). That ETHIsFalse here means what Anthropic proved there is the version seam: read, not decided. C2 is an implication. Its conclusion is already proved outright by complexitylib's own not_eth (certs/eth-cslib-d1.json); what C2 adds is the link from a lab's statement to the standard machine, so Anthropic's proof, and with Hawkley's chain OpenAI's, refutes ETH on cslib's multitape machine with encCNF, up to the seam. certs/eth-c2.json.
  • Anthropic’s proof in the same Lean. CERTIFIED ETH (complexitylib's, on cslib's deterministic multitape Turing machine with encCNF) is false, from Anthropic's own proof through C2, every step elaborated and checked in one Lean (v4.36.0-rc2): no step from Anthropic's proof to the standard machine crosses a version seam. Decided: the statement byte-equal to the pin, MainResults.lean byte-equal to Anthropic's, the three standard axioms, nanoda accepting all 77,276 declarations beneath it, leanchecker --fresh, the three planted variants refused, and lake comparator --paranoid accepting with all six checkers (con-leche and con-ron: 74,801 declarations). The proof that checks here is a modified copy of Anthropic's: 47 of its 809 files were changed to build on the newer Lean and Mathlib (renames, imports, tactic repairs; 45 declarations changed text only by a forced rename; every change listed with both sha256s in PORT.md). Lean checks whatever proof is there against Anthropic's unchanged statement, so the port changes nothing that is decided; it is said here because the proof is not Anthropic's bytes. This closes the second version seam for Anthropic's chain only. OpenAI's statement reaches ETHIsFalse inside OpenAI's Lean (v4.34.1, Hawkley's chain); that seam is read, not decided. certs/eth-chain.json.
  • OpenAI’s proof in the same Lean. CERTIFIED ETH (complexitylib's, on cslib's deterministic multitape Turing machine with encCNF) is false, from OpenAI's own proof through Hawkley's two links and C2, every step elaborated and checked in one Lean (v4.36.0-rc2): no step from OpenAI's proof to the standard machine crosses a version seam. Decided: the statement byte-equal to the pin, MainResults.lean byte-equal to Anthropic's, every ported file byte-equal to its scout pin (3,190) or modified as PORT.md declares (20), Hawkley's two theorem types as pinned, the three standard axioms, nanoda accepting all 101,618 declarations beneath it, leanchecker --fresh, the three planted variants refused, and lake comparator accepting with its named checkers (lean4lean-fuel, nanoda-pinned, paranoid, Lean default). As shipped, lake comparator --paranoid accepts with Lean paranoid and Lean default and its four bundled checkers stop at their own limits (nanoda: a worker thread's stack; lean4lean: its fuel; con-leche and con-ron: a compiled fuel constant, "never a verdict" in their charter) — recorded, not counted as a rejection. OpenAI's own Comparator challenge (its SubexponentialSAT.lean at 7ef5c0cc, unchanged; the path in p3.challenge) accepts the ported proof of exact_count_and_sat in the new Lean with the same named checkers. The proof that checks here is a modified copy of OpenAI's and Hawkley's: 20 of its 3,210 files were changed to build on the newer Lean and Mathlib (every change listed with both sha256s in OpenAIEth/PORT.md, and every file checked here against the scout pins: byte-equal to its pin, or modified exactly as declared, nothing else). Lean checks whatever proof is there against the unchanged statements (Hawkley's two theorem types printed by our file, MainResults.lean byte-equal to Anthropic's), so the port changes nothing that is decided; it is said here because the proof is not OpenAI's or Hawkley's bytes. This closes the version seam on OpenAI's side the way Anthropic's was closed (certs/eth-chain.json): by rebuilding the proof in the statement's Lean (v4.36.0-rc2), not by comparing kernels across v4.34.1 → v4.36.0-rc2. That complexitylib's ETH is the textbook ETH stays a reading of a definition. The judge's --paranoid run did not finish on this export (2.45 GB; the Anthropic chain's was 0.65 GB and all six checkers accepted there): the bundled nanoda 0.4.17 overflows a worker thread's stack and has no stack setting, lean4lean's fuel counter reaches zero, con-leche and con-ron exhaust a compiled fuel constant — each stop reproduced by hand on the comparator's own export (judge.diagnosis). The verdict reads the judge re-run with checkers that can finish: leanchecker-paranoid, our pinned nanoda with a 1 GiB thread stack, lean4lean with its fuel raised 100×, and Lean's default kernel. con-leche and con-ron are not among them; nothing here is their verdict either way. The amendment is dated in the pre-registration. After the record, at the con-leche maintainer’s request, con-leche and con-ron built from their master branches and run by hand on the same export accept all 98,686 declarations (con-leche needs 65.7 GiB at 32 workers, 65.9 at 16, 51.4 at 8, 34.3 at 4), and all 93,373 of the export of OpenAI’s own challenge: their fuel stops are fixed upstream, not yet in a Lean release. Both exports are public as a test case for the checkers (doi:10.5281/zenodo.23991348). Outside the judge, not part of the decision. So every stop of the four bundled checkers was a resource limit or an old build, and none was a rejection: nanoda and lean4lean accept once given room (a thread stack, a fuel setting), con-leche and con-ron accept on their master branches. certs/eth-openai-chain.json.
  • Lean’s own judge. CERTIFIED C1 and C2 were also judged by lake comparator --paranoid against challenges written from this page’s pins: Lean’s kernel, leanchecker-paranoid, lean4lean, nanoda, con-leche and con-ron all accept, and the two planted changed statements are rejected for a mismatch. The judge's sandbox (bubblewrap) could not create a user namespace on RunPod's containers, so every step ran with --inadvisably-no-sandbox. certs/eth-comparator.json.
  • What stays a reading. That any formal ETH, ours, cslib’s or a lab’s, is the textbook ETH is a reading of a definition. This lane has made it a reading of a standard machine with a reasonable binary encoding: cslib’s multitape Turing machine, reached from both labs’ statements (each inside one Lean, both proofs ported), and a word RAM at logarithmic word size, reached from complexitylib’s own proof.
§6 · open

What this page does not say

§7 · prior art

Sources the first reading opened

why these numbers stand as they do
  • decided — the record's count of decided claims
  • decided — the record's count of claims
  • computed — a wall-clock time on the rented machine: measured, not decided
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.