Lean on Vampire Proofs (Short Paper)
This short paper outlines ongoing efforts to enhance user trust in the automated theorem prover Vampire by reconstructing its proofs as trusted proofs within the Lean proof assistant.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
The Big Picture: The Genius Robot and the Strict Auditor
Imagine you have a super-intelligent robot named Vampire. This robot is a master mathematician. It can solve incredibly complex logic puzzles and prove theorems (mathematical truths) in seconds. It's so fast and powerful that it's used to check software security, design neural networks, and solve hard math problems.
However, there's a catch: Vampire is a "black box." It gives you the answer, but it doesn't always show its homework. It might skip steps, use shortcuts, or make assumptions that are hard to verify. If you are building a nuclear reactor or a self-driving car, you can't just trust the robot's word; you need to be 100% sure the math is right.
Enter Lean. Think of Lean as a hyper-strict, by-the-book auditor. Lean is an "Interactive Theorem Prover." It is incredibly slow and meticulous, but it never makes a mistake. If Lean says a proof is valid, it is absolutely, undeniably true.
The Problem: Vampire is fast but untrustworthy on its own. Lean is trustworthy but too slow to solve the hard problems from scratch.
The Solution: The authors of this paper built a bridge between them. They created a system where Vampire does the heavy lifting to find the answer, and then Lean checks the work step-by-step to ensure it's correct.
How It Works: The "Translator" Analogy
Imagine Vampire is a brilliant chef who cooks a complex 10-course meal in 5 minutes. But the chef speaks a secret language and doesn't write down the recipe. You (the customer) are worried the chef might have used poison or forgotten a step.
The authors built a translator and a recipe book.
- The Cooking (Vampire): Vampire solves the problem. It finds the solution and generates a "proof" (the recipe).
- The Translation: The system takes Vampire's secret recipe and translates it into a language Lean understands. It breaks the massive, complex proof down into tiny, tiny steps.
- The Audit (Lean): Lean reads the translated recipe. It checks every single ingredient and every single cooking instruction.
- Did the chef actually mix the flour and eggs?
- Is the temperature correct?
- Does the final dish actually taste like the goal?
If Lean approves every single step, you can trust the meal. If Lean finds a mistake, the whole thing is rejected.
The Technical "Magic" (Simplified)
The paper details how they made this translation happen:
- The "Inference Rules" (The Cooking Techniques): Vampire uses about 200 different "moves" or rules to solve problems. The authors identified the most important ones and wrote specific "tactics" (instructions) for Lean to understand them. It's like teaching Lean how to recognize a "chop," a "sauté," or a "bake" in Vampire's secret language.
- The "Skolemization" (The Magic Names): Sometimes Vampire needs to invent temporary names for things to solve a puzzle (like saying, "Let's call this mystery number 'Bob'"). Lean doesn't like guessing names. The authors built a system to ensure that when Vampire invents "Bob," Lean knows exactly who "Bob" is and why he was named that way, so the logic holds up.
- The "AVATAR" Feature (The Team Split): Vampire has a special trick called AVATAR where it splits a big problem into smaller sub-problems and asks a different type of solver (a SAT solver) to handle the logic parts. The authors made sure that when Vampire splits the work, Lean can still follow the trail and check the final result, even if the pieces were solved by different "team members."
The Results: Does It Work?
The team tested this on thousands of math problems (from a library called TPTP).
- Success Rate: It worked amazingly well. For standard problems, 98% of the time, Lean successfully checked Vampire's work. For slightly harder problems, it was 85%.
- Speed: There is a small cost. Because Lean has to check every single step, it takes longer than just letting Vampire run alone. However, the paper shows that the time it takes to check the proof is reasonable and doesn't break the system.
- The "Trust" Factor: The biggest win is that the "Trusted Computing Base" (the amount of code you have to trust to believe the result) is now tiny. You only have to trust the Lean kernel (which is tiny and verified) and the Vampire-to-Lean translator. You don't have to trust Vampire's entire complex engine.
Why Does This Matter?
In the real world, we rely on computers for critical things:
- Cybersecurity: Proving a code has no holes.
- Software Analysis: Proving a banking app won't lose your money.
- AI Safety: Proving a neural network won't make a dangerous decision.
If we rely on Vampire alone, we are taking a risk. If we rely on Lean alone, it might take too long to solve the problem. By combining them, we get the speed of a race car (Vampire) with the safety of a seatbelt (Lean).
Summary
This paper is about teaching a fast, messy genius (Vampire) how to write its homework in a way that a slow, perfect teacher (Lean) can grade. The result is a system where we can get fast answers to hard problems, but with the absolute guarantee that the math is correct.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.