Lean4Lean: Towards a Verified Typechecker for Lean, in Lean (2403.14064v2)

Abstract: In this paper we present a new "external checker" for the Lean theorem prover, written in Lean itself. This is the first complete typechecker for Lean 4 other than the reference implementation in C++ used by Lean itself, and our new checker is competitive with the original, running between 20% and 50% slower and usable to verify all of Lean's mathlib library, forming an additional step in Lean's aim to self-host the full elaborator and compiler. Moreover, because the checker is written in a language which admits formal verification, it is possible to state and prove properties about the kernel itself, and we report on some initial steps taken in this direction to formalize the Lean type theory abstractly and express the relation between the kernel functions and the type theory. We plan to use this project to help justify any future changes to the kernel and type theory and ensure unsoundness does not sneak in through either the abstract theory or implementation bugs.

• The paper develops Lean4Lean, an external verifier implemented in Lean to formalize Lean’s metatheory and boost correctness.
• It validates mathlib and core libraries while operating 20-50% slower than the C++ kernel, ensuring improved trust in proofs.
• The work paves the way for self-hosting Lean’s elaborator and compiler, advancing formal verification and reliable theorem proving.

Lean4Lean: Towards a Formalized Metatheory for the Lean Theorem Prover

In "Lean4Lean: Towards a formalized metatheory for the Lean theorem prover," Mario Carneiro details the development of an "external verifier" for the Lean theorem prover itself, implemented in Lean. This initiative marks a significant milestone as it introduces the first complete verifier for Lean 4 aside from its original C++ implementation. The verifier demonstrates competitive performance, running between 20% and 50% slower than the reference C++ implementation and is proven capable of comprehensively verifying Lean's mathlib library. This work aligns with Lean's broader objective to self-host its full elaborator and compiler, thereby enhancing the system's self-sufficiency and reliability. The development also opens avenues for formal verification of the kernel properties, thus improving the credibility of proofs constructed within Lean by eliminating potential implementation errors.

Lean and Metatheory Development

Lean, a prominent theorem prover, offers a leaner kernel than its counterparts, like Coq. It gained attention due to its simpler foundational design and lack of soundness bugs in Lean 3's kernel. However, Lean 4's overhaul, aimed at implementing most components in Lean, brought new features which introduced some soundness bugs. Additionally, Lean 4’s redesign of its metaprogramming infrastructure necessitated new external verifiers due to the obsolescence of those used for Lean 3.

Carneiro embarks on reintroducing external verifiers to reestablish Lean's soundness, utilizing Lean as the language for the verification process. A kernel written in Lean permits users to leverage easy querying of internal states and facilitates proof tasks, thanks to Lean's dual functionality as both a programming and proving environment.

Technical Insights

The paper elaborates on the verifier, named Lean4Lean, demonstrating its capacity to validate the entirety of foundational Lean packages, including Lean itself, its standard library, and Mathlib. Although Lean4Lean operates slower than the C++ kernel, the trade-off is justified by the extra assurances it provides and its role as a complementary tool in ascertaining correctness.

The manuscript also ventures into formalizing Lean’s metatheory, setting a course towards verifying Lean4Lean’s correctness against the metatheory, akin to goals outlined in the MetaCoq project. The primary contributions highlight the encoding of typing judgments, along with empirical results aligned with theoretical consistency checks for the Lean type theory kernel.

Future Directions

Carneiro's work on Lean4Lean opens prospective research avenues, both practically and theoretically. Practically, it suggests enhancements in Lean's capacity for internal justification of kernel and type theory alterations. Theoretically, it provides groundwork for a robust verification framework that might eventually enhance similar theorem provers by offering replicable methodologies and insights into formalizing metatheory.

The project could see fruitful future developments, potentially influencing the integration of Lean in areas demanding high reliability and trust in computational proofs. Verification efforts in Lean could inspire analogous endeavors in other theorem proving ecosystems, driving forward the commitment to advancing formal methods and verifying mathematical software.

The intersections of logical foundations, computer-assisted proofs, and software reliability underscore the implications of Carneiro’s contributions, marking substantial progress in the ongoing formalization efforts in interactive theorem provers. This work pushes the understanding and trust in formalized math by offering a pathway to more secure, verified computational tools.