OpenAI Releases Formal Math Proofs: 4 Open-Source AI Math Tools You Can Run Locally

OpenAI recently unveiled a remarkable result: an internal model solved over 100 long-standing open math problems in a single month, and the complete proofs for the hardest problems — including those related to Navier-Stokes equations — were written in the formal proof language Lean and fully open-sourced on GitHub. Unlike past "we did it" announcements made behind closed doors, this release is different: the proof code is fully public, the formal verification scaffolding is open-sourced, and any third party can independently verify the results.

For everyday developers, students, and math enthusiasts, the more practical takeaway is this: a set of open-source AI math tools — ones that don't require access to OpenAI's internal models and can run on consumer-grade GPUs — are now available. This article breaks down the positioning, capabilities, and hardware requirements of four such tools, so you can pick the right one for your needs.

What OpenAI Open-Sourced

According to a summary by a Bilibili content creator, OpenAI's official announcement states that an internal model solved over 100 mathematical problems in one month and produced machine-verifiable proofs written in the formal language Lean. Three things happened simultaneously with this release:

• All proof code is publicly available and can be directly referenced and reused;
• The formal verification scaffolding is also open-sourced, allowing any third party to independently run and verify the proofs;
• A set of open-source projects (Lean Copilot, DeepSeek^Ad-Math-style models, OpenProver, etc.) are available concurrently — no access to OpenAI's internal models required, and consumer-grade GPUs are sufficient.

The most critical point here is "formal verification" as the gold standard. A math proof written by AI must be verified step-by-step by the Lean kernel — sorry (a placeholder for skipped steps) must equal zero, and errors must equal zero, before the proof is considered complete with no gaps. This standard applies even to OpenAI itself, and it is the core criterion for determining whether an AI-generated proof is actually trustworthy.

Lean is a theorem prover and functional programming language developed by Microsoft Research, currently at version Lean 4. Unlike ordinary mathematical writing, Lean requires every deductive step to be explicitly declared in a machine-checkable form and verified logically by its kernel. Mathlib is the community-maintained mathematics library for Lean, containing tens of thousands of formally verified theorems and lemmas — essentially a "mathematical encyclopedia" for the Lean ecosystem. The sorry keyword is a placeholder that allows authors to temporarily skip a subgoal and continue writing, but it generates a compiler warning — so sorry = 0 means no steps are left incomplete, making it the gold standard for measuring the completeness of a formal proof. The Navier-Stokes equations are a system of partial differential equations describing fluid motion; the existence and smoothness of their solutions is one of the seven Millennium Prize Problems, carrying a $1 million reward and still unsolved. OpenAI's work targets specific related problems, not the full Millennium Problem itself.

Four Tools, Four Completely Different Use Cases

Though all four tools revolve around "AI + mathematical proofs," their purposes differ significantly. Understanding their positioning is key to choosing the right one.

OpenAI Navier-Stokes Proof Repository

This is the code repository directly corresponding to OpenAI's publicly released Millennium-level proofs. It has been trending on GitHub with approximately 1,856 stars and is licensed under Apache 2.0. The repository is built on Lean 4.34 with the Mathlib mathematics library.

The most telling metric is sorry = 0 with zero errors — meaning no steps are skipped and every proof step has been independently verified by the Lean kernel. Running it locally is straightforward: clone the repository and compile. Hardware requirements are modest — approximately 8 GB of RAM and 5 GB of disk space (for caching Mathlib). This is ideal for researchers who want to study or reuse top-tier proof code directly.

Lean Copilot: An AI Assistant for Lean

Lean Copilot is developed by a team affiliated with Lean development and works as an AI proof assistant embedded directly in the Lean IDE. It has three core capabilities:

• Tactic suggestion: When you get stuck at by sorry, the AI recommends applicable proof tactics;
• Proof search: It enables large language models to collaborate with traditional automated provers (like ESAP-style tools) to search for multi-step proofs;
• Premise selection: When a proof goal involves the Mathlib library, the AI helps identify potentially useful lemmas.

Its hardware requirements are relatively modest: it runs on CPU alone; if using a local LLM, approximately 8 GB of RAM is needed; via a cloud API, the barrier is nearly zero. Best suited for programmers and engineers who are already writing proofs in Lean and want to work more efficiently.

DeepSeek-Math 7B: An Open-Source Math LLM

This is an open-source math-focused large language model with 7 billion parameters, capable of directly solving advanced math problems through conversation. On math competition benchmarks (MATH), the RL-trained version with tool use achieves approximately 60% accuracy — approaching GPT-4 levels and outperforming several comparable models. The fact that a 7B model can reach near-Minerva performance makes it exceptionally cost-effective.

Three versions are available on Hugging Face: Base (pretrained), Instruct (conversational), and RL (reinforcement learning). It has the lowest hardware barrier of the four tools: FP16 requires approximately 16 GB of VRAM (e.g., RTX 4090 or A100-class GPUs), while 4-bit quantization brings it down to 8 GB VRAM, runnable on an RTX 3060. Particularly accessible for budget-conscious students and engineers looking to experiment.

MATH benchmark (Hendrycks Math) is a widely used academic math evaluation set covering algebra, geometry, number theory, combinatorics, calculus, and other competition-level topics — 12,500 problems in total, ranging in difficulty from AMC to AIME, scored out of 100%. Minerva is a math-specialized large language model released by Google in 2022 (fine-tuned from PaLM) that set state-of-the-art results on MATH at the time, serving as an important reference baseline for evaluating math model performance. RL (reinforcement learning) versions refer to models fine-tuned via process-based or outcome-based rewards, encouraging the model to produce verifiably correct solution steps rather than merely plausible-sounding text. 4-bit quantization is a model compression technique that reduces weight representations from 16-bit floats to 4-bit integers, cutting VRAM usage by roughly 75% at the cost of minor accuracy loss — typically acceptable for inference tasks, enabling models that originally required an A100 to run on consumer RTX 3060 GPUs.

OpenProver: An Agent System for Automated Proof Search

OpenProver is developed by a team at Charles University in Prague and was accepted at the CICM conference. It uses a three-stage Planner–Worker–Verifier agent architecture:

• Planner decomposes the proof task into subgoals;
• Worker tries multiple proof strategies in parallel;
• Verifier automatically validates results using the Lean 4 kernel — if a proof fails, it sends control back to the Planner; if it succeeds, the result is retained.

Three highlights stand out: reproducible evaluation, an interactive terminal, and research-grade benchmarks based on ProofNet. For research-level problems, its capabilities exceed those of Lean Copilot, but the barrier to entry is higher — better suited for researchers with some background in formal methods.

CICM (Conferences on Intelligent Computer Mathematics) is one of the most important academic venues in formal mathematics and automated reasoning. Acceptance there means OpenProver's methodology has undergone peer review. ProofNet is a research-grade benchmark dataset designed for formal mathematical proofs, with problems sourced from undergraduate to graduate-level math textbooks — far more difficult than competition problems, serving as a standard test set for evaluating the upper-bound capabilities of automated proof systems. The Planner–Worker–Verifier architecture is essentially a "plan–execute–verify" multi-agent loop: the Planner breaks down complex proof goals into subgoals, the Worker explores multiple proof paths in parallel, and the Verifier acts as a judge. This design allows the system to automatically backtrack and retry upon failure without human intervention, and is one of the dominant paradigms in AI-assisted theorem proving today.

How to Choose: Match by Role

Overall, the four tools can be quickly matched to user type:

• Students: Choose DeepSeek-Math — lowest hardware requirements, just chat to solve problems;
• Programmers/Engineers: Choose Lean Copilot — deeply integrated into the Lean development workflow, with noticeable productivity gains;
• Want to study top-tier proofs: Go directly to the OpenAI Navier-Stokes proof repository;
• Research use: Choose OpenProver — stronger automated proof search capabilities via its agent system.

The onboarding cost is also low: OpenProver can be up and running in about 30 minutes, DeepSeek-Math requires just five lines of Python, and Lean Copilot integrates with two added dependencies.

Why This Matters

The real significance of this wave of open-sourcing isn't that "AI solved a few more problems" — it's that verifiability has been placed at the center. Mathematical proofs are different from natural language generation: correct is correct, wrong is wrong, and the Lean kernel will mercilessly reject any skipped step or logical gap. Every step provided by the AI must pass machine verification, which moves "AI doing math" from demonstration to trustworthiness.

For individual users, all these tools are open-source and free, runnable on consumer hardware — meaning the barrier to formal mathematical proof is dropping rapidly. Whether you're solving calculus problems, writing formulas for a paper, or exploring cutting-edge open problems, there's a capable open-source solution available for each use case.

(The information in this article is drawn from a Bilibili content creator's summary of OpenAI's official announcement and each project's README. Data is current as of the relevant announcement dates. Some proper nouns follow the phonetic transcriptions used in the video, such as Navier-Stokes and Mathlib; please refer to the official repositories for authoritative spellings.)