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
You can deploy this agent to execute specific implementation tasks within a larger development plan. It operates independently with fresh context, follows test-driven development principles for every code change, and creates comprehensive handoff documentation that captures progress, decisions, and learnings for the next task executor. This ensures consistent code quality, prevents rework, and maintains continuity across distributed implementation efforts.
by parcadei
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
You can construct geometric objects (points, lines, polygons, multigeometries), execute boolean operations (intersection, union, difference), apply spatial predicates (contains, intersects, within), calculate measurements (area, length, distance, centroid), and transform geometries through translation, rotation, and scaling. This skill handles geometry validation, invalid geometry repair, and complex spatial analysis tasks.
by parcadei
This skill systematically reviews backend code to uncover bugs, performance bottlenecks, security vulnerabilities, and architectural debt before deployment. You provide code (functions, diffs, or full files), and it delivers prioritized findings with detailed explanations and actionable fixes. Every review includes severity assessment, code examples, and concrete recommendations to improve quality and safety.
You can transform fragmented cost data, subcontractor quotes, and contingency calculations into cohesive, defensible bid packages that stakeholders understand and trust. This skill guides you through hierarchical cost aggregation, dynamic contingency modeling based on project risk, multi-tier markup application, and narrative integration that links scope assumptions to pricing—enabling you to develop competitive proposals with justified pricing strategies.
by parcadei
You can paste CPM schedule exports from Primavera P6, Microsoft Project, or narrative descriptions into Claude to perform comprehensive constraint analysis and identify schedule optimization opportunities. The skill analyzes activity relationships, float distributions, resource constraints, and schedule vulnerability patterns to quantify which activities drive project completion, measure schedule buffer effectiveness, and develop quantified mitigation strategies that balance acceleration with cost and logistical feasibility.
by parcadei
Use lnget to fetch files and data from HTTP endpoints that require L402 Lightning micropayments. The tool automatically detects payment requirements (HTTP 402 responses), processes Lightning payments through your connected LND node, and retries requests—all without manual intervention. You can preview costs before paying, manage authentication tokens, and output results in machine-readable JSON or raw format.
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