Prove
Formal theorem proving with machine verification in Lean 4
What You Can Do
You can formally verify mathematical proofs by translating theorems into Lean 4 code, leveraging Mathlib's extensive library of formalized mathematics. The skill guides you through researching existing lemmas, designing proof strategies, testing approaches, implementing formal proofs, and verifying correctness—turning informal mathematical claims into machine-checked theorems without requiring deep Lean syntax expertise.
Features
research, design, test, implement, and verify proofs systematically
access 100,000+ formalized lemmas and theorems via Loogle type-aware search
find existing lemmas by mathematical structure, not just keywords
Claude produces production-ready proof scripts with proper syntax
test proof tactics incrementally before final verification
Lean 4 compiler confirms correctness; no human review needed
Web search and Loogle queries identify proven strategies
Clear templates for translating informal proofs to formal notation
Example Output
Example 1: Group Homomorphism Identity Preservation
theorem group_homomorphism_preserves_id (G H : Type*) [Group G] [Group H]
(φ : G →* H) : φ 1 = 1 :=
map_one φ
Proof verified: ✓ Compiles without errors
Example 2: Continuous Functions on Compact Sets
theorem continuous_on_compact_is_uniform (f : ℝ → ℝ) (K : Set ℝ)
(hf : ContinuousOn f K) (hK : IsCompact K) :
UniformContinuousOn f K :=
hf.uniformContinuousOn_of_compact hK
Proof verified: ✓ Uses Mathlib's compact space theorem (2 lemmas)
Example 3: Research Phase Output
For "Monsky's theorem":
- Located Mathlib.NumberTheory.Zsqrtd.Basic with relevant field theory
- Found 47 candidate lemmas via type signature matching
- Identified proof strategy: construct explicit counterexample using 2-adic valuation
What's Included
- SKILL.md: Complete 5-phase workflow specification with Lean 4 syntax templates
- Loogle search checklists: Type signature patterns for common mathematical structures (groups, rings, topology, analysis)
- Proof strategy templates: Induction, case analysis, contradiction, and term-mode proof skeletons
- Lean 4 tactic quick reference: Common tactics with examples (rw, simp, exact, apply, sorry)
- Mathlib navigation guide: How to browse and import modules for group theory, topology, and number theory
Who It's For
- Mathematicians and pure math researchers — Formalize theorems without learning theorem prover syntax
- Logic and computation theory specialists — Verify proof correctness at machine precision
- Academic mathematicians — Create publication-ready machine-verified proofs
- PhD students in mathematics — Formalize dissertation theorems for reproducibility
- Automated theorem proving practitioners — Scale proof verification across research libraries
Best For
- Formalizing existing mathematical theorems from papers and textbooks
- Verifying correctness of abstract algebra proofs (groups, rings, fields)
- Proving topology and analysis theorems (continuity, compactness, convergence)
- Generating Lean 4 code from informal mathematical statements
- Discovering related lemmas and proof strategies through Mathlib search
You might also like
When a user uploads a file to Claude, you can intelligently detect its type and read it using the appropriate method. Instead of blindly running cat on binary files or loading massive CSVs into context, this skill routes each file type to the right tool, reading only what's needed to answer the user's question. You'll extract text from PDFs, parse structured data from CSVs and JSON, process images, and decompress archives—all without wasting context or producing garbage output.
by seifbenayed
You can systematically analyze construction estimates by breaking down components, validating labor and material pricing against market data, identifying embedded errors or outdated assumptions, and applying data-driven contingency allocation. Claude helps you produce risk-adjusted cost projections that are defensible to stakeholders and competitive in bid scenarios, reducing estimate variance and catching pricing gaps before client submission.
by parcadei
This skill maps construction claims as interdependent probability states rather than isolated analyses, allowing you to evaluate how changes in one contractual interpretation cascade through damages calculations, delay causation, and liability allocation. You can simultaneously model competing scenarios—concurrent causation, ambiguous change order triggers, insurance coverage dependencies—and identify which settlement positions minimize exposure across all correlated outcomes, not just single interpretations.
by parcadei
You'll follow the strict TDD workflow: write a failing test that defines expected behavior, verify it fails, write minimal production code to pass the test, then refactor for quality. This approach ensures complete test coverage, catches bugs early, and produces well-designed code backed by comprehensive test suites. Claude guides you through each phase with examples and enforces TDD principles to prevent shortcuts.
by parcadei
You can interact with NotebookLM programmatically to automate research workflows, content generation, and knowledge management tasks. This skill guides you through creating and managing notebooks, adding diverse source types (URLs, YouTube videos, PDFs, Google Drive files, text), generating multiple content formats (podcasts, reports, quizzes, flashcards, mind maps, slides, infographics), and conducting intelligent research through source-aware chat interactions.
You can perform end-to-end PDF operations including extracting text and metadata from documents, merging multiple PDFs into a single file, splitting PDFs by page ranges, filling fillable forms programmatically, and adding text overlays to non-fillable PDFs. This skill handles both simple read operations and complex document workflows, making it essential for document processing, form automation, and PDF batch operations.
by seifbenayed
You can rapidly process multiple subcontractor bid responses—from trade contractors, material suppliers, and specialty vendors—into a cohesive, auditable estimate structure. Claude extracts key bid components, identifies pricing inconsistencies against benchmarks or prior projects, flags scope gaps and exclusions, and organizes everything by CSI division for seamless estimate assembly. This eliminates manual spreadsheet comparison and reduces the risk of overlooked scope omissions or pricing anomalies when managing 15+ concurrent bids.
by parcadei
Query your local Screenpipe instance to retrieve screen recordings, audio transcriptions, UI element accessibility trees, keyboard/mouse input logs, and productivity analytics. You can search by keywords, filter by content type (audio, OCR, accessibility, input), set time ranges, and extract structured data about your applications, meetings, and work sessions without sending data to external servers.
by az9713