Augmented Lean Formalisation (ALF)

• Augmented Lean Formalisation (ALF) is a suite of methodologies that enhances Lean-based formalization via data augmentation, retrieval, and iterative certification.
• It emphasizes statement mutation, self-distillation, and tool-augmented refinement to expand the training corpus while maintaining type and semantic correctness.
• By incorporating auxiliary systems like compiler feedback and semantic auditing, ALF improves automation, modularity, and fidelity in formal verification processes.

Searching arXiv for papers on Augmented Lean Formalisation and closely related Lean autoformalization work. Augmented Lean Formalisation (ALF) denotes a family of methodologies that augment Lean-based formalization with additional machinery for scale, robustness, or faithfulness. In the most explicit usage, ALF is a statement-level data-augmentation mechanism for Lean theorem proving that mutates verified Lean statements into type-correct formal variants and populates them with training signal via self-distillation without running Lean verification on every mutated instance (Leang et al., 10 Jun 2026). Across adjacent literature, the same expression is also used more broadly for workflows that combine Lean’s kernel-checked verification with retrieval, compiler feedback, interactive environments, multi-agent orchestration, semantic auditing, or human review to support autoformalization, proof search, and domain-specific verification (Shen et al., 27 May 2025). The unifying theme is not a single algorithm but a design principle: formalization is strengthened by coupling Lean with auxiliary systems that improve coverage, automation, compositionality, or semantic control.

1. Conceptual scope and definitions

In its narrowest and most operationalized sense, ALF is introduced as the central data-augmentation mechanism in Pythagoras-Prover. There, each original Lean statement $s$ yields exactly one formal variant $s'$ in each of five categories: simplification, generalisation, lemma proposal, proof-step decomposition, and reformulation. These variants are required to remain well-formed Lean statements of type Prop, and they are populated with proofs by self-distillation rather than exhaustive Lean verification (Leang et al., 10 Jun 2026).

Other papers employ ALF in a broader methodological sense. “Towards a Mathematics Formalisation Assistant using LLMs” describes an ALF workflow in which an LLM proposes Lean code, Lean checks it, and retrieval, postprocessing, and human repair are used to improve outputs (Agrawal et al., 2022). “Towards Automated Formal Verification of Backend Systems with LLMs” treats ALF as the integration of kernel-checked formal verification in Lean 4 with LLM-guided formalization, theorem synthesis, and proof search over translated Scala backend code (Xu et al., 13 Apr 2025). “REAL-Prover” presents ALF as proof-step generation augmented by retrieval from Mathlib and an interactive Lean 4 environment (Shen et al., 27 May 2025).

A further cluster of papers uses ALF to name or characterize tool-augmented NL→Lean formalization. “Understanding Tool-Augmented Agents for Lean Formalization” defines the agentic core as a closed loop of draft, verify, and repair built from fine-tuned drafting, symbol-level knowledge search, and compiler feedback (Zhang et al., 16 Apr 2026). “Beyond Compilation” sharpens the notion by separating formal validity, Lean competence, and semantic faithfulness, arguing that compilation is only one component of reliable formalization (Zhang et al., 30 Jun 2026). “Lean Atlas” does not use the term explicitly, but operationalizes the same idea by augmenting type checking with targeted human semantic verification and introducing “aligned Lean code” as a quality standard for AI-generated formalizations (Yanahama et al., 16 Mar 2026).

A concise taxonomy of representative ALF interpretations in the literature is as follows.

Paper	ALF interpretation	Primary augmentation
“Pythagoras-Prover” (Leang et al., 10 Jun 2026)	statement mutation plus self-distillation	data scaling
“REAL-Prover” (Shen et al., 27 May 2025)	retrieval-augmented proof-step generation	premise retrieval and interactive proof states
“Beyond Compilation” (Zhang et al., 30 Jun 2026)	tool-augmented statement formalization	semantic evaluation beyond compile rate
“Lean Atlas” (Yanahama et al., 16 Mar 2026)	human-in-the-loop semantic verification	dependency-pruned review
“FormalScience” (Meadows et al., 24 Apr 2026)	agentic scientific autoformalisation	compiler loop plus human alignment gate
“Beyond the Library” (Moakhar et al., 30 Jun 2026)	type-first, multi-agent research formalization	dynamic vocabulary creation and auxiliary lemmas

This spread suggests that ALF functions both as a named mechanism and as a broader research program for strengthening Lean formalization by external augmentation.

2. Core technical patterns

Across the literature, ALF systems recur around a small number of technical patterns. One pattern is retrieval grounding. Formalization or proving is conditioned on retrieved Mathlib facts, formal definitions, or proof traces. REAL-Prover uses LeanSearch-PS to embed proof states and Mathlib theorems into one vector space and retrieve top-$k$ premises for the current proof state (Shen et al., 27 May 2025). CRAMF builds a concept–definition knowledge base from Mathlib4, indexes over 26,000 formal definitions and 1,000+ core mathematical concepts, and injects retrieved definitions into prompts to reduce hallucination and resolve conceptual polymorphism (Lu et al., 9 Aug 2025). The Formal Language Knowledge Corpus work takes the same direction at the corpus level, showing that when queries are translated to Lean and retrieval is performed over a Lean corpus, average answer correctness on the Google Mathematics Dataset hard split rises from 54% to 73% (Zayyad et al., 2024).

A second pattern is verification-coupled iteration. Tool-augmented agents repeatedly draft Lean code, compile it, inspect diagnostics, and repair the result. The factorial analysis paper formalizes this as the interplay of Fine-tuned Model Querying, Knowledge Search, and Compiler Feedback, with the full agent reaching 89.5% compilation and 60.5% Faithful accuracy on a 400-theorem benchmark (Zhang et al., 16 Apr 2026). FormalScience instantiates the same structure through a compile-and-correct loop $L(C^{(t)})$, followed by a human-gated semantic refinement loop and re-verification (Meadows et al., 24 Apr 2026).

A third pattern is separation between statement generation and kernel trust. In backend verification, LLMs translate Scala into Lean, synthesize theorems, and search for proofs, but Lean’s kernel remains the ground truth: a requirement counts as verified only if Lean accepts the proof, while proving a negated theorem confirms a bug (Xu et al., 13 Apr 2025). In research-level autoformalization beyond Mathlib, Claim Check pins theorem or lemma statements byte-for-byte so that proofs cannot silently weaken or edit the target (Moakhar et al., 30 Jun 2026).

A fourth pattern is semantic alignment control. “Beyond Compilation” defines faithfulness as a conjunction of compilation and strict judge consensus, exposing a 29.0-point gap between compile-pass and consensus-faithful outputs for a full tool-augmented agent (Zhang et al., 30 Jun 2026). Lean Atlas attacks the same problem structurally: Lean Compass prunes proof-level dependencies from theorem values and computes the project-specific declarations whose semantic correctness can affect a selected theorem set, enabling targeted human review (Yanahama et al., 16 Mar 2026).

A fifth pattern is modularization into reusable formal artifacts. The directed topology formalization around the Directed Van Kampen theorem is presented as ALF-aligned because it builds modular Lean components—directed_space, dipath, directed_map, dihomotopy_rel, path-cover infrastructure, the functor $d\pi : dTop \to Cat$, and a categorical pushout theorem—that are reusable and automation-friendly (Basold et al., 2023). The asymptotic statistics pipeline makes the same distinction explicitly by separating theorem-agnostic infrastructure, a statistical concept layer, and theorem-specific assembly files (Wei et al., 3 Jun 2026).

3. Statement augmentation and training-data expansion

The most explicit formalization of ALF as a named mechanism is the Pythagoras-Prover data pipeline. Lean statements are treated as typed terms $s : Prop$, and mutation operators $T_i$ produce variants $s'$ that preserve well-typedness, elaboration validity, and the “formal character” of the seed problem (Leang et al., 10 Jun 2026). The five operational categories—simplification, generalisation, lemma proposal, proof-step decomposition, and reformulation—instantiate families of rewrites such as commutativity, associativity, quantifier restructuring, inequality adjustments under strengthened hypotheses, scaling and reparameterisation, and substitution via known lemmas.

The self-distillation stage then populates each mutated statement with exactly one proof attempt from the post-RL teacher that generated the mutation family, followed by statement-alignment filtering. Acceptance requires that the generated proof reference the exact mutated goal; this is a sanity check rather than kernel verification. The retained labels store the complete theorem text and proof body, and the resulting corpus is mixed with verified proofs from the RL stage (Leang et al., 10 Jun 2026).

This yields a substantial corpus expansion. The ALF self-distillation corpus is reported as approximately 2 million instances, about a 2.5× expansion over the seed. A random audit of 2,000 ALF self-distilled instances yields an 87.8% compile rate, which is used as statistical evidence that high-quality training signal can be generated without per-instance Lean verification (Leang et al., 10 Jun 2026). The same work also introduces MiniF2F-ALF, a contamination-sensitive perturbation benchmark constructed by applying the ALF mutation scheme plus variable and numeric perturbations to MiniF2F-Test items (Leang et al., 10 Jun 2026).

The empirical role of ALF in this setting is twofold. First, it scales beyond Lean checker throughput by decoupling corpus growth from exhaustive kernel verification. Second, it reduces reliance on a statement’s surface form by forcing the model to see nearby formal variants rather than a single canonical phrasing. Continued SFT on ALF data is reported to improve pass@32 by +5–7 points over the SFT-only baseline, and mutation robustness on MiniF2F-ALF remains highest for the ALF-trained 32B model at 85.0% pass@32 (Leang et al., 10 Jun 2026).

This data-centric interpretation of ALF is distinct from retrieval- or agent-centric variants, but it shares the same broader goal: formal competence should generalize across formally meaningful perturbations rather than overfit a fixed statement distribution.

4. Tool augmentation, retrieval, and interactive proving

A second major strand of ALF emphasizes interaction with Lean and Mathlib during formalization or proof search. The earliest paper in the set, “Towards a Mathematics Formalisation Assistant using LLMs,” combines input-dependent prompt selection, Codex generation, Lean-aware postprocessing, and elaboration filtering. For theorem statements, the method reports nearly 75% accuracy on 120 theorem statements, with retrieval based on sentence embeddings and YAKE keywords and with elaboration serving as a strong proxy for correctness (Agrawal et al., 2022). For proofs, no completion is perfect out of the box, but comment-interleaved prompt formats make at least one sampled completion easy to repair for most of the 13 theorem case studies (Agrawal et al., 2022).

REAL-Prover develops this direction into a retrieval-augmented Lean 4 prover. LeanSearch-PS retrieves Mathlib premises conditioned on the current proof state, Jixia-interactive applies tactics and returns updated proof states or errors, and the prover performs best-first tree search with normalized path log-probability scoring

$$\text{score} = \frac{\sum_{t=0}^{L-1} \log p(a_t \mid s_t)}{L^\alpha},$$

using $\alpha = 0.5$ (Shen et al., 27 May 2025). On ProofNet, the system attains 23.7% Pass@64; on FATE-M, a new algebra benchmark, it reaches 56.7% Pass@64, with retrieval producing a +12.0 point gain on FATE-M relative to the no-retrieval variant (Shen et al., 27 May 2025).

CRAMF shifts the retrieval unit from premises to concepts. It constructs a concept–definition ontology from Mathlib4, augments query strings with domain-level and application-level signals via

$s'$0

and uses dual-channel retrieval plus reranking to inject top-$s'$1 definitions into prompts (Lu et al., 9 Aug 2025). On formalization benchmarks, CRAMF yields consistent gains, with relative improvement reaching 62.1% and averaging approximately 29.9% across models and datasets (Lu et al., 9 Aug 2025).

The tool-augmented formalization literature also isolates the marginal value of these components. In the factorial analysis paper, compiler feedback is the dominant intervention, contributing +32.3 points to Faithful accuracy, while search adds +6.8 points and a fine-tuned translation expert adds +0.9 points on average. Search also reduces REPL calls by approximately 27–30% when feedback is active (Zhang et al., 16 Apr 2026). “Beyond Compilation” reproduces the same decomposition under a stricter faithfulness protocol and shows that feedback is the largest validity lever but also exposes a larger compile-pass semantic-failure bucket (Zhang et al., 30 Jun 2026).

Together, these systems establish a common ALF pattern: the Lean kernel or elaborator is not merely a final checker but an active participant in a closed-loop formalization process.

5. Semantic faithfulness, auditing, and human alignment

A persistent concern in ALF research is that type checking does not establish semantic fidelity to the source mathematics. Several papers address this directly. “Beyond Compilation” formulates faithful statement formalization as a separate evaluation problem and defines

$s'$2

iff the output compiles and both judge scores are at least 9. Under this metric, the full tool-augmented agent reaches 89.5% compile rate but only 60.5% consensus-faithful accuracy on the 400-entry benchmark, leaving a 29.0-point compile-pass but consensus-unfaithful gap (Zhang et al., 30 Jun 2026). Human audits support this boundary: 96.0% of consensus positives are human-confirmed faithful, while 82.4% of compile-pass consensus negatives are human-confirmed semantic failures (Zhang et al., 30 Jun 2026).

Lean Atlas proposes a complementary structural response. Its core algorithm, Lean Compass, starts from a set of theorem targets $s'$3, prunes all edges originating from theorem proof terms, computes the reachable set in the pruned graph, and includes all axioms, yielding the project-specific declarations whose semantic correctness can affect the target theorems (Yanahama et al., 16 Mar 2026). On proof-heavy projects, this yields very large reductions in review surface: approximately 99% for PrimeNumberTheoremAnd, 96.2% for Carleson, and 94.4% for Brownian Motion, with smaller but still significant reductions for PhysLib, a six-theorem FLT milestone subset, and XMSS (Yanahama et al., 16 Mar 2026). The notion of “aligned Lean code” then designates code that is both type-correct and human-verified for semantic correctness (Yanahama et al., 16 Mar 2026).

The asymptotic statistics formalization develops semantic control into a full hypothesis-discipline. Its Auditor requires every main-theorem hypothesis and concept-layer field to be anchored to verbatim source text, justified as a Lean encoding artifact, marked as source-implied, or rejected as potential drift (Wei et al., 3 Jun 2026). Seven checks are run whenever a main signature or audited definition changes, including absence of stray sorry, axiom-baseline preservation, row coverage for hypotheses and instance binders, conclusion fidelity, and joint consistency (Wei et al., 3 Jun 2026). Concrete rejected strengthenings include hL_coercive, hL_continuous, hy_meas, and several semi-parametric hypotheses, all removed or re-architected away (Wei et al., 3 Jun 2026).

FormalScience introduces a lighter-weight human alignment gate for scientific autoformalization. After compiler-guided correction, the model self-critiques the alignment of the Lean file against the source question and answer, and a human expert accepts or rejects the result. This gate is combined with post-hoc dataset-wide measures Formal Quality, Logical Preservation, and Mathematical Consistency; on FormalPhysics the corresponding values are 73.5%, 72.0%, and 72.5%, with 100% formal validity (Meadows et al., 24 Apr 2026).

These systems collectively counter a common misconception: a Lean declaration can compile, and even admit a formal proof, while still misrepresenting the intended statement. In ALF research, semantic faithfulness is therefore treated as an independent systems problem rather than as a byproduct of elaboration.

6. Applications, representative domains, and outlook

ALF methods now span pure mathematics, theorem proving, software verification, scientific formalization, and research-level mathematics. In directed topology, the Lean formalization of directed spaces and the Directed Van Kampen theorem is explicitly framed as an ALF-aligned artifact because it yields mathematically robust, reusable, and automation-friendly formal components for compositional reasoning about concurrent systems (Basold et al., 2023). The central theorem establishes, under open-cover hypotheses, a pushout decomposition

$s'$4

in Cat, and the paper argues that this reduces deduction of properties of a composed concurrent system to that of subsystems (Basold et al., 2023).

In backend systems, ALF translates Scala services into Lean 4, synthesizes API and table-level theorems, and attempts both proofs and negation proofs. On four realistic Scala projects, the method formally verifies over 50% of requirements, confirms 8 of 11 injected bugs by negation proofs, and reports an average verification cost of approximately \$2.19 per API in one setting (Xu et al., 13 Apr 2025). The trust model remains kernel-centric: only Lean-accepted proofs count as verification (Xu et al., 13 Apr 2025).

In scientific domains, FormalScience applies ALF to quantum mechanics and electromagnetism. It builds FormalPhysics, a 200-item corpus of university-level physics problems, expanded informal solutions, and Lean 4 proofs with no sorry and no axioms. The paper emphasizes domain-specific semantic drift, introducing categories such as notational collapse, abstraction elevation, proof strategy substitution, and implicit premise selection (Meadows et al., 24 Apr 2026).

Research-level ALF is represented most strongly by “Beyond the Library,” which formalizes PutnamBench and five STOC papers using a multi-agent, type-first pipeline. The system dynamically creates missing types and validates them with auxiliary lemmas before formalizing the main theorems. It solves 32 of 32 randomly sampled PutnamBench problems and formalizes the main theorems and proofs of all five selected STOC papers; two of these are proved with no axioms beyond Lean’s kernel (Moakhar et al., 30 Jun 2026). In one case, the system finds a concrete counterexample to a published lemma and isolates the gap by admitting a later result as a scoped axiom, illustrating that ALF can expose defects in source mathematics rather than merely transcribe it (Moakhar et al., 30 Jun 2026).

The asymptotic statistics project shows the same research-facing trajectory in a domain with thin Mathlib coverage. It reports approximately 80,700 lines across 151 files, around 240 definitions, and around 1,000 lemmas and theorems, all axiom-clean, with cornerstone results covering LAN, asymptotic representation, Hájek–Le Cam convolution, Local Asymptotic Minimax, and a semi-parametric convolution theorem (Wei et al., 3 Jun 2026).

A plausible implication is that ALF is evolving from a collection of heuristics into a systems discipline with distinct subfields: data augmentation, retrieval-grounded proving, semantic evaluation, audit-driven formalization, and domain-specific library construction. The main unresolved tension across these strands is consistent: Lean’s kernel provides strong local correctness, but scalable formalization still depends on external mechanisms to control statement drift, library mismatch, or missing vocabulary. Current work therefore treats augmentation not as an optional convenience, but as the central engineering layer through which Lean formalization is made scalable, reusable, and source-faithful.