formal proof development

The multigraded Proj construction lacks a complete formalization in interactive theorem provers, hindering mechanized verification in algebraic geometry. Method: Building on Lean 4 and mathlib, and grounded in dependent type theory, we present the first full formalization of the multigraded Proj construction—including its definition, categorical structure, functoriality from graded rings to graded schemes, and properties of projective morphisms. Contribution: We develop the first reusable, machine-checked library for multigraded Proj, formally verifying key results such as graded localization, open immersions, and the universal property of relative Proj. This foundation enables rigorous formalization of more advanced constructions in algebraic geometry—e.g., sheaves of graded modules and relative projective space—and advances the integration of generative science into formal mathematics.

This work addresses the challenge of integrating dependent type theory in Lean 4 with automated theorem provers (ATPs). We propose the first formally verified, reliable translation from dependent types to first-order logic (FOL). Methodologically, we leverage Lean 4’s metaprogramming capabilities to perform dependent type erasure and structured FOL encoding, and integrate SMT/ATP tools—including Z3 and Vampire—via a novel, general-purpose ATP interface. Our key contributions are: (i) the first formal verification of translation correctness within a dependent type system; and (ii) significant improvements in automated proof success rates on real mathematical lemmas from the Mathlib4 benchmark, surpassing prior tools’ limitations. This work establishes a new paradigm for interactive theorem provers that jointly achieves high expressive power and robust automation.

This work addresses the automatic translation of informal natural-language mathematical proofs into formal Lean 4 proofs—a task hindered by poor alignment between informal reasoning and structured verification languages, as well as weak controllability. We propose the novel “Chain of States” (CoS) intermediate representation, the first to explicitly decouple proof-structure modeling from tactic generation. CoS enables staged state extraction and structured tactic synthesis, and we further develop an interactive formalization framework alongside a domain-specific training dataset. Evaluated on multiple mathematical benchmarks, our approach significantly outperforms prior methods, achieving substantial gains in proof success rate. Results demonstrate that CoS effectively improves formalization accuracy and verifiability under limited computational budgets, validating its design principles and practical efficacy.

Lean lacks SMT-driven automated proof capabilities comparable to Isabelle/HOL’s Sledgehammer. This paper presents the first end-to-end solution in Lean for generating and faithfully reconstructing SMT proofs: it automatically encodes Lean goals into SMT-LIB, invokes external solvers (e.g., Z3, CVC5) for verification, and reliably reconstructs their proofs as checkable, native Lean terms. The approach leverages Lean’s metaprogramming framework and a custom reconstruction algorithm, significantly reducing the trusted computing base while preserving logical soundness and enhancing automation. Evaluated on the Sledgehammer benchmark suite, it achieves strong performance. As a standalone SMT-LIB proof checker, it attains high verification success rates, operates with a minimal trusted base, and incurs only moderate runtime overhead.

Formal verification of the Lean 4 kernel’s correctness remains an open challenge. Method: This paper develops the first fully Lean 4–implemented external type checker, formally specifying its type-theoretic semantics and rigorously proving semantic equivalence between the implementation and the formal semantics. The checker supports end-to-end verification of the entire mathlib library (>1 million lines) and achieves 50%–80% of the performance of the C++ reference implementation. Contribution/Results: It presents the first complete formalization of Lean’s type theory within Lean itself; establishes a provably sound correspondence between kernel primitives and semantic inference rules, thereby providing dual reliability guarantees for kernel evolution; and constitutes a critical step toward a fully self-hosting Lean compiler—significantly enhancing the trustworthiness and maintainability of the theorem prover.

This work addresses the challenge of integrating the industrial-scale B-Method tool Atelier B with the Lean proof assistant by introducing BARReL, a library implemented in Lean 4 that enables users to carry out the entire development process—from formal specification to machine refinement—using standard B syntax within Lean. The key innovation lies in leveraging Lean’s dependent type system to explicitly encode well-definedness conditions for partial B operators, thereby ensuring that all proof obligations are free from ill-formed instances. Furthermore, metaprogramming is employed to automatically generate well-definedness constraints and basic automation tactics. The approach has been validated on representative case studies, laying the foundation for a highly reliable and extensible, Lean-native toolchain for the B Method.

Existing infrastructure struggles to meet the demands of AI-driven mathematical research for Lean 4, particularly in high-throughput processing, scalable verification, multi-version support, and request-level isolation. This work proposes the first cloud-native Lean 4 service platform, which uniquely enables high concurrency, per-request isolation, and coexistence of multiple Lean 4 and Mathlib versions. The platform integrates 14 metaprogramming tools—including proof checking, semantic source code manipulation, deterministic repair, and lemma extraction—and provides seamless access via HTTP API, Python SDK, CLI, and a web UI, eliminating the need for local deployment. Already publicly deployed, it has processed over 500 million requests and powered Axiom Math’s perfect score in the 2025 Putnam Competition, thereby addressing a critical gap in scalable theorem-proving infrastructure.

This study systematically evaluates the effectiveness of large language models in generating formal mathematical proofs in Lean 4. Leveraging the miniF2F and miniCTX datasets, the authors conduct a comprehensive assessment of prominent models—including Gemini, Claude, Nemotron, and GPT-OSS—using both the established pass@$k$ metric and a newly introduced refine@$k$ measure, which jointly account for accuracy and reasoning cost. Experimental results show that Gemini 3.1 Pro achieves a refine@32 rate of 92% on miniF2F, while Claude Opus 4.7 reaches 86% on miniCTX. Notably, Nemotron 3 Super and GPT-OSS 120B deliver high performance at a cost of less than \$0.01 per correctly generated proof. This work pioneers the integration of economic efficiency into the evaluation framework for formal proof generation, proposing a more practical and application-oriented benchmarking paradigm.

This work addresses the high computational cost of independently formalizing each candidate answer in Lean-based mathematical reasoning for answer selection. To overcome this inefficiency, the authors propose the BASE framework, which introduces a novel “formalize once, edit the rest” paradigm: one base candidate is first formally verified in Lean, and then a custom-designed LEANSCRIBE rewriting model identifies its answer expression and generates reusable editing functions to efficiently produce the remaining K−1 formalized statements. Evaluated across four benchmark datasets and three solvers under 12 configurations, the approach consistently achieves significant gains in both efficiency and accuracy. Notably, when K=8, it reduces the number of formalization calls by approximately fivefold, yielding a Pareto improvement that simultaneously lowers formalization cost and enhances selection performance.

This work addresses the challenge of achieving efficient and reliable formal verification of production-grade cryptographic code written in Rust. We present the first end-to-end Rust-to-Lean 4 verification pipeline, integrating the Charon, Aeneas, and Hax frameworks for symbolic extraction, leveraging the ArkLib and CompPoly libraries of formally specified cryptographic primitives, and introducing the Aristotle and Aleph AI-powered provers to automatically discharge complex proof obligations. All results are rigorously validated by the Lean 4 kernel. Our approach successfully reproduces and fully verifies key cryptographic primitives from Plonky3 and RISC Zero—including FRI folding, finite field arithmetic, Horner evaluation, and Merkle inclusion proofs—and automatically completes proofs for two longstanding open conjectures.