Weekly

News about Lean, the theorem prover and programming language.

Published Nov 19, 2026

23 items.

AI and formalization

Google's Teamwork-LEAP system formalizes the Weil conjectures in Lean

Teamwork-LEAP produced approximately 1.8 million lines of Lean code across 28,800 subagent invocations to formalize the conjectures, results about the number of solutions to polynomial equations over finite fields, originally proved by Pierre Deligne in 1974. The formalization comes from Google's Antigravity multi-agent system, which uses specialized agents powered by Gemini models.

Image: interestingengineering.com

Checked against: interestingengineering.com

Lean core

Henrik Böving adds epr tactic for EPR, a first-order logic fragment

Merged into Lean as #16468, the tactic uses a BitVec encoding combined with bv_decide and performs about level with Z3 on the TPTP EPR benchmark set. On verification conditions from Veil, a protocol verifier, it solves 769 (97%) of the 792 that lie fully within EPR and 1,082 (71%) of all 1,512.

Checked against: lean4#16468

AI and formalization

Codex agents prove Gonshor's 1986 conjecture on surreal birthdays in Lean

The conjecture says a surreal product's birthday (the length of its sign sequence) is at most the natural (Hessenberg) ordinal product of the factors' birthdays. Directed by dan (@gaearon), the agents proved the CombinatorialGames library's proof_wanted statement Surreal.birthday_mul_le and a Mathlib-only version with the definitions included, checked by Comparator and independent kernel checkers.

Checked against: gaearon/gonshor-birthday

AI and formalization

Hannah Cairo and five coauthors formalize Mizohata-Takeuchi power-loss theorem in Lean

The theorem states that for every smooth hypersurface whose second fundamental form is nonzero at some point, the local Mizohata-Takeuchi constant grows at least like a power of the radius, with the exponent chosen before the dimension and the surface. The AI-assisted formalization, registered in the Palomar registry, passed the official Lean Comparator.

Checked against: palomar-registry.orgVjekoKovac/lean-mt

AI and formalization

GPT-6.2 Astra formalizes Agata Smoktunowicz's gap theorem in Lean 4

Working alone, the model wrote about 1,800 lines of Lean in 94 minutes; Vals AI reports no other model on the Autoform-Hard leaderboard solves this task. The 2006 theorem concerns the growth of graded algebras, and Astra's proof avoids three deep results the published one uses, none in Mathlib, Lean's math library.

Image: vals.ai

Checked against: vals.ai

AI and formalization

Zayn Blore formalizes Charles J. Read's counterexample to the invariant subspace problem

Following Wiesław Śliwa's 2010 explicit version, the proof shows there is a bounded operator on the sequence space ℓ¹ that maps no closed subspace, other than 0 and the whole space, into itself. Drafted with Claude Code, it proves Google DeepMind's Formal Conjectures statement Invariant_subspace_problem_l1; the open separable Hilbert space case is not addressed.

Checked against: palomar-registry.orgzblore/fc-read-l1

Verification

&Truth says its proofs can be independently checked using Lean

In a post on X, &Truth argues that mathematical proof offers stronger assurance by establishing that code meets precise requirements, under explicit assumptions. Its initial focus is memory safety and absence of undefined behavior.

Checked against: @andTruthPBC on X

Verification

John Zhuoyang Ye and co-authors present QCCDCert, a Lean-verified trapped-ion quantum compiler

Hardware descriptions and operating rules are compiler inputs, so one theorem covers every candidate design: compiled code preserves program behavior and obeys those rules. QCCDCert provably avoids 11 defects found in three previous compilers, and an AI agent proposing devices from checked compilation results beats the fastest fixed design on 71 of 75 benchmark programs.

First page of the paper
Image: paperswithlean.com

Checked against: arXiv:2611.23469paperswithlean.com

Verification

Bowen Zhu and Jian Wu certify plasma solver outputs with Lean proofs

The paper reuses a machine-generated lemma from OpenAI's Lean 4 relativistic Vlasov-Maxwell library: initial fields determine the field at an outside point until plasma signals reach it. Eleven new Lean modules build on it, and the certified references exposed boundary and initialization errors in WarpX and Smilei that global energy checks missed.

First page of the paper
Image: paperswithlean.com

Checked against: arXiv:2611.23319paperswithlean.comtomzhu0225/vlasov-maxwell-pic-benchmark

Verification

Adam Reynolds publishes Noctium, a Lean 4 framework for proving Midnight contracts

The research preview compiles contracts written in a typed Lean DSL directly to native ZKIR circuits and Impact ledger plans, and executes them with Rust. It registers 40 active ZKIR 3.2.1 opcodes and has execution paths for C/C++, Kotlin (Android emulator tested), Swift (macOS and iOS simulator tested) and TypeScript (WASM, Chrome tested).

Checked against: awjreynolds/noctium

Verification

Smayan Agarwal and Aalok Thakkar's Kamot generates zippers, partly verified in Lean

Kamot converts datatype declarations in a restricted Haskell fragment into zippers, which pair a focused position in a data structure with the context needed to rebuild it. Lean 4 verifies simulation, bounds, and completeness of the generated code for finite single self-recursive datatypes, using only core Lean; the rest is proved on paper.

First page of the paper
Image: paperswithlean.com

Checked against: arXiv:2611.22572paperswithlean.comdoi.org

Verification

Daksh Shami and Charles Yuan verify MARBLE's rewrite rules in Lean 4

The MARBLE language compiles publication-style matrix formulas into quantum circuits, applying algebraic rewrite rules that decompose each matrix into simpler matrices with known circuits; Lean 4 proofs show every rule preserves matrix semantics. MARBLE matches or surpasses 37 of 39 published baselines and produces exponentially smaller circuits than the leading tool FABLE.

First page of the paper
Image: paperswithlean.com

Checked against: arXiv:2611.17756paperswithlean.com

Lean core

Leo de Moura makes equation lemmas keep haves instead of inlining them

Keeping them avoids duplicating their values and preserves the join points that do notation introduces, which vcgen +jp needs to produce 2 verification conditions instead of 2ⁿ⁺¹ for n sequential ifs. Sebastian Graf added @[vcgen_rintro], an attribute that tells vcgen how to destructure a binder while it introduces the binders of a goal.

Checked against: lean4#16208lean4#16235lean4#16291

Lean core

Julia Himmel reimplements Lean's IO.Process.spawn using libuv

The merged pull request fixes a number of bugs on all platforms and makes spawning much faster in processes that use a lot of memory. In a breaking change, spawn now throws an error if the command cannot be started; previously, on POSIX platforms, spawn succeeded and the child exited with code 255.

Checked against: lean4#16418

Lean core

Lean's CI now builds and tests Lean Beam on every Linux run

Lean Beam (leanprover/lean-beam) lets AI agents try commands and tactics in a file's context without changing its source. Sebastian Ullrich's pull request #16447 makes PRs that break Lean Beam's build or tests fail before reaching a nightly, and unstamped PR toolchains now bundle it like releases do.

Checked against: leanprover/lean-beamlean4#16447

Lean core

Naoya Yamashita releases leanfran, connecting Lean with Rust, Python, TypeScript and Clojure

The tool compiles Lean functions to those languages, with proofs checked by Lean during generation and erased from the executable code; in reverse, it translates supported host-language functions to Lean for checking against Lean specifications. Its backends are tested against Lean's native C backend but have not been proved correct in Lean.

LeanとRust・Python・TypeScript・Clojureを双方向につなぐleanfranを作った
Image: s.conao3.com

Checked against: conao3/lean-leanfrans.conao3.comleanprover.zulipchat.com

Lean core

Naoya Yamashita's leanassay checks whether Lean theorems pin down implementations

Its #assay f command breaks f in many small ways and reports broken versions that satisfy every theorem about f but change what f returns on an input meeting a theorem's hypotheses. The Apache-2.0 package for Lean 4.35.0 does not need the proofs, so it also works on theorems that are still sorry.

Checked against: conao3/lean-leanassay

Lean core

Lean 4 repository has 10,056 GitHub stars

The leanprover/lean4 repository, home of the Lean 4 programming language and theorem prover, has 10,056 stars on GitHub. The repository was created in April 2018, and GitHub lists its language as Lean.

Checked against: leanprover/lean4

Lean core

Mac Malone lets Lake packages declare their own cache services

Services are specified in a cache_service TOML table or Lean DSL declaration and can be used via lake cache get --service. A new downloadCacheService package option sets the service Lake uses by default for lake cache get of the package and, when the artifact cache is enabled, for on-demand downloads during builds.

Checked against: lean4#16302lean4#16351

Lean core

Sebastian Ullrich speeds up deriving Repr, BEq, and Hashable on mutual blocks

Lean now derives these classes once per mutual block, generating the auxiliary functions once for the whole block instead of once per type. This removes quadratic elaboration cost: deriving Repr on every type of a 76-type mutual block went from 309 seconds and 10.2 GB to 62 seconds and 1.3 GB.

Checked against: lean4#16339

Papers and events

Leo de Moura presents "Scaling Lean for AI" at SViL, Stanford

The November 7, 2026 slide deck by the Lean FRO's chief architect covers AI-written proofs, including Claude's Lean proof of Fermat's Last Theorem, and verification projects such as AWS's Cedar, Microsoft's SymCrypt, and Google's Kraken. It concludes that software verification is now a major use case and scalability the new challenge.

Checked against: leodemoura.github.io

Papers and events

Xueying Qin, Marco Peressotti and Fabrizio Montesi mechanise asynchronous choreographies in Lean

The paper presents Nyarlathotep, the first asynchronous nondeterministic choreographic programming framework, and proves that endpoint projection, which compiles a global program into network programs, is sound and complete and yields deadlock-free networks. The Lean 4 mechanisation takes about 20,000 lines using CSLib, compared with about 40,000 for Mech, the less featureful calculus Nyarlathotep extends.

First page of the paper
Image: paperswithlean.com

Checked against: arXiv:2611.24649paperswithlean.com