AI for Formal MathIssue 15Nov 14 – 21, 2026

The Flood of Open Problems in Machine Verification: From RH to AlphaProof Nexus

Highlights of This Issue

This issue is dominated by a community-milestone atmosphere. Three events push "machine verification" from a tool to research infrastructure itself: The verification files for the RH Lean proof report a Lean formalization of the Riemann Hypothesis, with all 175,187 modules compiling successfully, and the five headline theorems depending on only three standard axioms, accepted by independent kernel replays such as nanoda and con-leche—although the mathematical community has not yet accepted the proof at the natural-language level, the protocol of "multi-kernel independent verification" itself is already a paradigm sample. AlphaProof Nexus deploys LLM+Lean proof search on open problems: according to the Science paper, it autonomously solved 9 of 353 open Erdős problems (including two open for 56 years) and 44/492 OEIS conjectures, with the results repository making all Lean proofs public. Meanwhile, the authors of the 3D Euler singularity paper personally formalized the main theorem of "finite-time singularity formation" into a Lean proof with a one-to-one correspondence to each item in the paper, with no sorry, and used VerifySpine.lean to check the correspondence.

But as scale increases, the fidelity problem becomes sharper. The "9 Erdős problems" of AlphaProof Nexus, upon independent audit, are actually 9 statements across 7 problem numbers (including variants and partial results), reminding us of the gap between "machine verification passed" and "answered the original question"—A Checked Proof Can Still Answer a Different Question and Getting the (In)formal Statement Right both poke at this point from different angles. Several papers in this issue respond precisely to this gap: AutoIP uses deterministic non-emptiness tests to catch a theorem in classical regularization theory whose hypothesis was severely weakened, and Autonomous AI Agents Diverge quantifies for the first time the systematic preference divergence between agents and humans on "what to do next."

On the engineering side, agentic formalization is crossing from "demonstration" into the "migration and maintenance" stage. CompCert4Lean ported the core of the CompCert verified compiler from Rocq to Lean in six weeks, with one expert providing only 3 technical instructions; DAPS is the first to systematically mine 53 Lean Blueprint projects as premise-selection training resources. Meanwhile, new automation primitives introduced in Lean v4.36.0, such as the epr tactic, provide a stronger backend for proof search. The verification bottleneck itself is also being quantified: the AI review bottleneck reports that Mathlib already has a queue of 2,766 items awaiting review.

Community and Developments

  • Independent verification of the RH Lean proof: The verification files report that the Lean formalization of the Riemann Hypothesis compiles across 175,187 modules, with the five headline theorems depending on only three standard axioms, and is accepted by independent kernel replays such as nanoda and con-leche; the page explicitly states that machine verification does not equal the Clay Prize or acceptance by the mathematical community at the natural-language level.
  • AlphaProof Nexus solving open problems: The Nature research highlight and the Science paper report that LLM+Lean proof search autonomously solved 9/353 open Erdős problems (including two open for 56 years) and 44/492 OEIS conjectures; the results repository makes all Lean proofs and natural-language correspondences public. An independent audit points out that the "9 problems" are actually 9 statements across 7 problem numbers, and they should be viewed as a relative signal.
  • 3D Euler singularity paper authors self-verify: EulerBlowupPublic is a Lean proof by the authors formalizing the main theorem of "finite-time singularity formation" with a one-to-one correspondence to each item in the paper, with no sorry, and VerifySpine.lean checks the correspondence; Lean Weekly reported on it.
  • Lean v4.36.0 release: The release introduces the epr tactic (a Z3-style effective propositional solver) and improvements to grind for ring/EUCLD, adding new built-in automation primitives for proof search.
  • Autoform-Hard benchmark: Vals AI introduces a hard slice of 56 research-level Lean 4 tasks, and the first model to formalize the Smoktunowicz gap theorem becomes a capability-milestone signal.
  • FormalMATH benchmark: EMNLP 2026 Findings introduces a Lean4 benchmark of 5,560 statements, built via a multi-stage pipeline including semantic verification and negation falsification, going beyond type-checking-only auto-formalization benchmarks.
  • LeanLean October: larger-scale proof compression: MathArena uses proof compression as a benchmark task, covering 32 real Lean repositories and verifying validity with Lake Comparator, adding a new evaluation dimension beyond proof generation.

Open Questions

  1. The RH proof and AlphaProof Nexus establish "multi-kernel independent verification" as a protocol, but the independent audit shows that the "9 problems" are actually 9 statements across 7 problem numbers. When the gap between machine verification and "answered the original question" can only be bridged by manual comparison of natural-language statements, can this step be automated—or will statement-fidelity verification become a more persistent bottleneck than proof search?
  2. Autonomous AI Agents Diverge shows that agents avoid densely connected core regions and "regularize" high-surprise proof bodies to LLM standards. If agent-produced proofs systematically favor a certain "LLM style," does this undermine the value of formalization as a mathematical discovery tool—that is, do we get not "proofs closer to the essence" but "more predictable proofs"?
  3. AutoIP uses deterministic non-emptiness tests to catch degenerate hypotheses in classical theorems. How broad a range of error types can such statement-level mechanical tests cover? Between the "one-to-one correspondence" represented by the 3D Euler formalization and "compiles but answers a different question," is there an automatically decidable intermediate layer of fidelity?
  4. The "audit-then-rebuild" workflow of CompCert4Lean frees humans from technical solutions, but the AI review bottleneck shows that Mathlib already has a queue of 2,766 items awaiting review. When agent migration and generation far outpace human review capacity, will "auditing" itself become a step that needs to be agentized—and does this circle back to the preference-bias risk of question 2?

Papers in this issue

  1. DAPS restores dependency structure to premise selection, achieving +11.41 Recall@16 over LeanHammer and a 7× recall margin on rare, out-of-distribution queries.

    Editor's note

    The first systematic mining of 53 Lean Blueprint projects (3,805 nodes) as premise-selection training resources, injecting dependency structure into both training data and model architecture: 2-hop subgraph sampling + structural neighborhood encoding with type/hop/position/degree embeddings, and multi-positive group-level contrastive objectives. Compared to LeanContext from Issue 14 (MC/EC decoupled benchmark) and Lean Graph Search from Issue 10 (PageRank dependency propagation), the increment lies in using dependency structure for both training and inference, achieving a 7x recall improvement on OOD competition problems. The Blueprint corpus and code are public, providing a reproducible artifact for premise selection; downstream proof experiments cover only 7-8B models, so results should be viewed as relative signals.

  2. CompCert4Lean ports CompCert's verified C compiler to Lean in six weeks via parallel LLM agents, discharging all 4,908 proofs and enabling 11.7% faster agent-driven optimizations.

    Editor's note

    In six weeks, one expert directed parallel LLM agents to port the core of the CompCert 3.17 verified compiler from Rocq to Lean, completing all 4,908 proof obligations with no project-specific axioms. The workflow increment lies in dividing dependencies into 166 units, performing semantic auditing before large-scale proof reconstruction (the first audit found 1,091 statements reduced to True), and parallel proof polishing against frozen interfaces; of 1,071 human-machine interactions, only 3 were technical instructions. Compared to Iris-Lean from Issue 7 (multi-year migration) and ITPEval from Issue 11 (cross-ITP translation), the increment is that proof agents can migrate large verified codebases, and the Lean port makes agent-optimized compilers more effective (11.7% runtime reduction vs 2.3%). The focus is more on compiler verification than mathematics, but the methodology is highly transferable.

  3. A complete Lean 4 formalization proves p-harmonious functions converge to the viscosity solution of the normalized p-Laplacian for 2 ≤ p < ∞, with no unproved statements.

    Editor's note

    The first complete Lean 4 formalization: p-harmonic functions converge to the normalized p-Laplacian Dirichlet problem viscosity solution as the step size tends to zero, including the full Barles–Souganidis argument, Aleksandrov's theorem, and Jensen's lemma, relying only on Mathlib and standard axioms. Compared to the linear elliptic PDE formalization from Issue 8 (divergence form), the increment lies in handling non-divergence, degenerate elliptic operators, and singular gradient terms—advancing formalization into viscosity solution theory for nonlinear PDEs. The complete reproducible artifact (Lean code + technical companion) provides rich material for future training and evaluation.

  4. Formalizing classical inverse problems in Lean exposed a textbook theorem with overly restrictive hypotheses and junk-value hazards, showing statement review, not proof checking, is the key bottleneck.

    Editor's note

    Proposes AutoIP, a Lean library of inverse-problem linear regularization theory auto-formalized by AI agents, and introduces a review model where "reviewers only compare formal statements with natural-language correspondences and never read proofs," paired with deterministic (non-AI) non-emptiness tests. The increment lies in programmatic non-emptiness obligations catching a degenerate hypothesis in a classical theorem of regularization theory that is more stringent than it appears—a powerful example of formalization as a discovery machine. Compared to Trellis from Issue 7 (process semantics) and AIProver from Issue 9 (certificate-driven), its non-emptiness tests and hash proof system are reusable in any auto-formalization pipeline.

  5. AI agents in proof formalization act as "sorry autofillers," targeting explicit gaps and peripheral regions while humans work the dense, surprising core.

    Editor's note

    The first systematic quantification of systematic preference divergence between AI agents and humans in Lean formalization: using a "simulated collaboration" method to compare editing behavior across 9 large human-collaborative repositories, finding that agents strongly prefer explicit sorry markers, avoid densely connected core regions, and regularize high-surprise proof bodies to LLM standards. Compared to Issue 14's Reap analysis of RL reshaping search behavior, this paper focuses on "what to do next" preference differences, providing the first large-scale cross-model empirical evidence. It has direct value for designing more aligned proof agents and human-machine collaboration workflows, with datasets and code public.

  6. PAPER2LEAN converts entire mathematical papers into compiling Lean projects without proof placeholders, achieving 95.7% source fidelity across 20 optimization papers.

    Editor's note

    An end-to-end agentic framework that automatically formalizes an entire mathematical research paper (PDF) into an integrated Lean project, coordinating statement formalization, semantic checking/repair, proof construction, and library integration via a dependency DAG, producing the OptPaper-20 corpus (494 files, 110,910 lines of Lean). Compared to Maestro from Issue 11 (global coordination) and ProofFlow from Issue 9 (dependency-DAG auto-formalization), the increment lies in paper-level dependency-graph-driven full pipelines and systematic reporting of semantic fidelity (95.7% fidelity rate) and failure cases (e.g., 'by a similar argument' being omitted), clearly showing that compilation success does not equal source fidelity. It relies on frontier closed-source models and is not compared with other pipeline systems, so results should be viewed as relative signals.

  7. AUXSPEC pairs declarative postconditions with executable counterparts in Lean, enabling test-case-based rewards that boost specification generation pass@4 from 0.7% to 82.7% and surpass frontier models.

    Editor's note

    Proposes a Lean framework pairing declarative postconditions with executable counterparts, enabling test-case execution as reinforcement-learning rewards to train specification generators. Compared to specification-generation methods relying on proofs or LLM judges, the increment lies in scalable execution-based feedback signals, with significant gains on both in-domain and OOD (Verina) benchmarks. Models, data, and the AuXSpec-Test benchmark are public, providing a direct contribution to auto-formalization and verified code generation; the focus is more on program specifications than mathematical theorems.

  8. SemantEq defines a principled equivalence relation for formal statements and achieves perfect precision with 65.6% recall, outperforming prior systems while rejecting all non-equivalent pairs.

    Editor's note

    Proposes a more principled equivalence relation for formal statements: each statement can only be transformed into another via allowed step chains (logical rearrangement, bridging rewrites, variable transformations, structural weakening), and audits proofs based on proof terms rather than tactic scripts. Compared to structure-aware equivalence (SAE) from Issue 11 and ShadowBench from Issue 4, the increment lies in advancing equivalence determination to proof-term-based restricted step chains and separating proof generation from acceptance, allowing stronger provers to improve recall without changing acceptance criteria. Code and data are public, providing a reproducible artifact for auto-formalization evaluation.