130k Lines of Formal Topology in Two Weeks: Simple and Cheap Autoformalization for Everyone?

Abstract: This is a brief description of a project that has already autoformalized a large portion of the general topology from the Munkres textbook (which has in total 241 pages in 7 chapters and 39 sections). The project has been running since November 21, 2025 and has as of January 4, 2026, produced 160k lines of formalized topology. Most of it (about 130k lines) have been done in two weeks,from December 22 to January 4, for an LLM subscription cost of about \$100. This includes a 3k-line proof of Urysohn's lemma, a 2k-line proof of Urysohn's Metrization theorem, over 10k-line proof of the Tietze extension theorem, and many more (in total over 1.5k lemmas/theorems). The approach is quite simple and cheap: build a long-running feedback loop between an LLM and a reasonably fast proof checker equipped with a core foundational library. The LLM is now instantiated as ChatGPT (mostly 5.2) or Claude Sonnet (4.5) run through the respective Codex or Claude Code command line interfaces. The proof checker is Chad Brown's higher-order set theory system Megalodon, and the core library is Brown's formalization of basic set theory and surreal numbers (including reals, etc). The rest is some prompt engineering and technical choices which we describe here. Based on the fast progress, low cost, virtually unknown ITP/library, and the simple setup available to everyone, we believe that (auto)formalization may become quite easy and ubiquitous in 2026, regardless of which proof assistant is used.

• The paper presents a novel autoformalization pipeline that converts 130k lines of topology text into formal proofs in 14 days at a cost below $100.
• It leverages an efficient feedback loop between commercial LLM coding interfaces and the Megalodon proof assistant to automate formalization with minimal human intervention.
• Key results include full formalizations of major theorems and robust error recovery mechanisms, demonstrating scalable and cost-effective formal mathematics.

Large-Scale Autoformalization of Topology: Methods, Achievements, and Implications

Project Overview and Motivation

"130k Lines of Formal Topology in Two Weeks: Simple and Cheap Autoformalization for Everyone?" (2601.03298) documents an unprecedented autoformalization effort that formalized over 130,000 lines of the topology content from Munkres' standard textbook in 14 days, at a subscription LLM cost of approximately \$100. This was achieved not by relying on specialized or proprietary toolchains but by constructing an efficient feedback loop between commercial LLM coding interfaces (ChatGPT/Codex 5.2 and Claude Sonnet 4.5) and the higher-order set-theoretic proof assistant Megalodon, augmented with minimal but judicious prompt engineering and automation.

This work exemplifies an end-to-end pipeline for informal-to-formal translation of mainstream mathematical text using only commodity AI infrastructure and a publicly available but previously obscure ITP. The experiment's central claims are that large-scale autoformalization is now operationally trivial and affordable for non-experts, and that the performance of high-quality LLMs in long-feedback cycles significantly lowers traditional barriers in formal mathematics.

System Architecture and Experimental Protocols

The pipeline operationalizes autoformalization by establishing the following sequence:

• Frontend LLM Agent: A shell-isolated instance of the LLM coding interface (OpenAI Codex or Claude Code) operates continuously in a Linux sandbox (bubblewrap), driven by prompt automation scripts that feed a stable, minimal instruction prompt after every task completion.
• Proof Engine: The backend is the Megalodon higher-order set-theory proof checker, initialized with Chad Brown's base library for set theory and surreal numbers. Most library proofs are removed and replaced by "admit" placeholders, retaining only a few exemplars to provide the LLM necessary proof reference material.
• Workflow Rules: A codified instruction file (CLAUDE.md) strictly specifies editable code regions, preservation of work, prohibition of duplicate axioms, and priorities for replacing admits with actual proofs and focusing on canonical theorems.
• Automation and Monitoring: Scripts monitor LLM session activity via tmux and inject prompts automatically to keep the agent productive and avoid idle time. The use of cost- and usage-tracking utilities, theorem dependency extractors, and backup diff logs provides fine-grained project control.
• Interventions: While the system is largely unsupervised, the experimenter retained the ability to inject high-priority tasks, e.g., directing proof focus to the Urysohn lemma or Tietze extension when LLM drift or local minima was observed.

Achievements and Quantitative Results

The project formalized essentially the entire spectrum of Munkres topology at scale. Key strong results include:

• Volume and Coverage: Over 160,000 lines were produced by January 4, 2026, with 130,000 in just two weeks. More than 1,500 named lemmas/theorems are stated and (mostly) proved.
• Major Theorems: Full formalizations (with complete proofs, no admits) of the Urysohn Lemma (3,000 lines), Urysohn Metrization Theorem (2,000 lines), and Tietze Extension Theorem (over 10,000 lines for its core case), among many others.
• Automated Progress on Challenging Theorems: For instance, the LLM autonomously discovered that to complete Step II of the Tietze proof, formalization of metric space completeness and uniform limits was necessary—requiring substantial infrastructure refactoring and generalization outside the order of the textbook. Ultimately, the system generated the full functional/infinite-step proof and, as a corollary, all standard variants of the Tietze theorem.
• Minimal Supervision: Prompting needs were reduced to near zero with prompt-loop automation; only bottlenecks (context drift, long proofs, forward-reference deadlocks) required human intervention.
• Cost Effectiveness: The total LLM usage cost for this scale of formalization is claimed to be below \$100, primarily utilizing subscription-based API access rather than metered per-query billing.

Contradictory to some prior expectations, the system demonstrates that advanced LLMs—when coupled with even limited domain-specific context, minimal scripting, and a classical proof assistant—are capable of sustaining deep, semantically consistent mathematical development, including robust handling of object dependencies, proof obligation discharge, and error recovery even across arbitrarily lengthy scripts.

Methodological Analysis and System Behavior

This autoformalization protocol required innovations in several operational dimensions:

• Feedback Loop Tuning: The interplay between LLM agent and proof checker was carefully managed to avoid context window overflow, catastrophic forgetting, or logic system drift. Isolation in the bubblewrap shell permitted us to maximize LLM API autonomy without risk.
• Prompt Engineering: The CLAUDE.md "rules file" was continuously updated to encode best practices, error corrections (such as the avoidance of accidental mass deletions), and dependency tracking practices. This evolved iteratively in response to observed LLM behavior (e.g., excessive work on stubs rather than hard theorems).
• Proof Refactoring and Compactification: As file size reached hundreds of thousands of lines and Megalodon verification slowed, the agent exhibited capacity for proof factorizations and infrastructural abstraction, albeit limited by the system's internal context memory and necessitating occasional resets.
• Dependency Tracking and Progress Monitoring: Scripts computed proof dependency graphs and flagged recursively admitted (not-yet-formalized) theorems, thereby guiding the agent to close critical gaps. Notably, uniform-limit machinery and metric completions had to be moved forward, breaking from textbook linearity.

Theoretical and Practical Implications

This experiment provides rigorous empirical evidence that broad portions of standard mathematical scholarship can now be formalized rapidly and with limited expert intervention. The following implications are especially salient:

• Proof Assistant Agnosticism: Success did not depend on high-resource or widely publicized proof assistants. Megalodon, a higher-order set-theory system with minimal LLM exposure, was sufficient; the LLM generalized its internal representation of Megalodon syntax, logic, and proof patterns from a small set of provided examples.
• Economic Accessibility: The total cost profile is competitive even with graduate student labor on similar projects, and the resource requirement is primarily cloud LLM subscription, rather than traditional infrastructure or human-in-the-loop curation.
• Scalability and Automation: Prompt-loop automation and minimal but targeted scripting allow for projects of scale (textbook/chapter length) to proceed without continuous human "babysitting," lowering the barrier for individual researchers and democratizing formalization.
• Coding Agent Robustness: Commodity LLM coding agents demonstrated resilience under long-running proof construction, nontrivial file manipulations, and recovery from significant logical or contextual errors with only lightweight intervention.

Challenges and Limits

Despite strong results, several challenges were observed:

• Session Compactification: LLM session state files eventually reached hard limits, necessitating manual resets and deliberate context re-initialization to preserve project progress. Native mechanisms for session compactification and memory management remain inadequate for extremely long-running sessions.
• LLM Tendency Toward Local Minima: Agents could become "distracted" (e.g., focusing on simple exercises, redundant refactorings, or repeated expansion instead of abstraction), requiring explicit override prompts to reallocate focus to rich theorems.
• Forward Reference and Textbook Nonlinearity: Key theorems sometimes required moving prerequisite machinery (e.g., metric completeness) forward out of textbook order, which the LLM eventually accomplished but only after costly detours and substantial trial-and-error.
• Proof Checking Scalability: File-based verification with Megalodon slowed as the library grew. Future work will require file modularization or proof admission pragmas to scale to even larger corpora.

Prospects for Future AI-Augmented Formalization

The demonstrated pipeline points toward a future where fully automated, end-to-end autoformalization of complex mathematical domains is routine. Expected future directions include:

• Integration with Optimized Orchestration: Adapting orchestration tools to further minimize prompt drift, dynamically balance theorem proving effort, and learn optimal task routing policies.
• Generalization to Further Domains: Extending the same methodology to textbooks in algebra, analysis, geometry, and logic, thus rapidly increasing the body of formally certified mathematics.
• Proof Synthesis and High-Level Abstraction: Encouraging the LLM to generate not only mass formalizations but also higher-level, reusable proof strategies, further increasing the impact on verification and discovery.
• Collaboration and Evaluation Benchmarks: Parameterized, reproducible pipelines may become new benchmarks for both formalization research and evaluation of next-generation LLMs in mathematical reasoning.

Conclusion

The results in "130k Lines of Formal Topology in Two Weeks: Simple and Cheap Autoformalization for Everyone?" (2601.03298) indicate that AI-driven autoformalization has reached a level of practical maturity permitting rapid, large-scale, low-cost translation of mainstream mathematical text into formal, machine-checked proofs. The methodology is minimally reliant on sophisticated infrastructure or high-maintenance orchestration, instead harnessing LLM progression and classical proof checking in a tightly coupled feedback loop. These results commit the autoformalization community to further investigate cost, scale, and reliability, and demonstrate that the era of democratized, AI-augmented formal mathematics is now a reality.