prove
Formal theorem proving with research, testing, and verification phases
Install / Use
npx skills add parcadei/Continuous-Claude-v3 --skill proveInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of prove
prove scores 86/100 on our quality scale, 1790th of 2,790 Automation skills we index.
Its SKILL.md is 7.4 KB long, well organised into 19 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.
With 3,943 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 10 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-03 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 94/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
ReviewOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review judged it risky: The skill instructs the agent to install elan by piping a remote script into a shell: `curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh`.
- noteInstalls by piping a downloaded script into a shellline 25
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh
AI review: risky
- The skill instructs the agent to install elan by piping a remote script into a shell: `curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh`.
- Piping a downloaded script directly into `sh` bypasses review and is explicitly called out as risky for skill/rules files.
- The command is for a legitimate tool (Lean version manager), so it is not malicious, but it weakens the agent's safeguards.
AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-10-01. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
prove compared with similar skills
All 4 of these similar skills score higher than prove; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| prove (this skill)by parcadei | 86 | 3.9k | 10mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 103.6k | 2d ago | MCP Server |
Frequently asked questions
- How do I install prove?
- Run
npx skills add parcadei/Continuous-Claude-v3 --skill prove. The install tabs above show the steps for each supported agent. - Which AI agents does prove work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is prove safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands (1 minor note below). An AI review judged it risky: The skill instructs the agent to install elan by piping a remote script into a shell:
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh. It is MIT-licensed and scores 94/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand. - Is prove still maintained?
- The repository was last updated about 10 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: prove description: Formal theorem proving with research, testing, and verification phases triggers: ["prove", "verify", "show that", "is it true", "formalize"] allowed-tools: [Bash, Read, Write, Edit, WebSearch, WebFetch, AskUserQuestion, Grep, Glob] priority: high
/prove - Machine-Verified Proofs (5-Phase Workflow)
For mathematicians who want verified proofs without learning Lean syntax.
Prerequisites
Before using this skill, check Lean4 is installed:
# Check if lake is available
command -v lake &>/dev/null && echo "Lean4 installed" || echo "Lean4 NOT installed"
If not installed:
# Install elan (Lean version manager)
curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh
# Restart shell, then verify
lake --version
First run of /prove will download Mathlib (~2GB) via lake build.
Usage
/prove every group homomorphism preserves identity
/prove Monsky's theorem
/prove continuous functions on compact sets are uniformly continuous
The 5-Phase Workflow
┌─────────────────────────────────────────────────────────────┐
│ 📚 RESEARCH → 🏗️ DESIGN → 🧪 TEST → ⚙️ IMPLEMENT → ✅ VERIFY │
└─────────────────────────────────────────────────────────────┘
Phase 1: RESEARCH (before any Lean)
Goal: Understand if/how this can be formalized.
-
Search Mathlib with Loogle (PRIMARY - type-aware search)
# Use loogle for type signature search - finds lemmas by shape loogle-search "pattern_here" # Examples: loogle-search "Nontrivial _ ↔ _" # Find Nontrivial lemmas loogle-search "(?a → ?b) → List ?a → List ?b" # Map-like functions loogle-search "IsCyclic, center" # Multiple conceptsQuery syntax:
_= any single type?a,?b= type variables (same var = same type)Foo, Bar= must mention both
-
Search External - What's the known proof strategy?
- Use Nia MCP if available:
mcp__nia__search - Use Perplexity MCP if available:
mcp__perplexity__search - Fall back to WebSearch for papers/references
- Check: Is there an existing formalization elsewhere (Coq, Isabelle)?
- Use Nia MCP if available:
-
Identify Obstacles
- What lemmas are NOT in Mathlib?
- Does proof require axioms beyond ZFC? (Choice, LEM, etc.)
- Is the statement even true? (search for counterexamples)
-
Output: Brief summary of proof strategy and obstacles
CHECKPOINT: If obstacles found, use AskUserQuestion:
- "This requires [X]. Options: (a) restricted version, (b) accept axiom, (c) abort"
Phase 2: DESIGN (skeleton with sorries)
Goal: Build proof structure before filling details.
-
Create Lean file with:
- Imports
- Definitions needed
- Main theorem statement
- Helper lemmas as
sorry
-
Annotate each sorry:
-- SORRY: needs proof (straightforward) -- SORRY: needs proof (complex - ~50 lines) -- AXIOM CANDIDATE: v₂ constraint - will test in Phase 3 -
Verify skeleton compiles (with sorries)
Output: proofs/<theorem_name>.lean with annotated structure
Phase 3: TEST (counterexample search)
Goal: Catch false lemmas BEFORE trying to prove them.
For each AXIOM CANDIDATE sorry:
-
Generate test cases
-- Create #eval or example statements #eval testLemma (randomInput1) -- should return true #eval testLemma (randomInput2) -- should return true -
Run tests
lake env lean test_lemmas.lean -
If counterexample found:
- Report the counterexample
- Use AskUserQuestion: "Lemma is FALSE. Options: (a) restrict domain, (b) reformulate, (c) abort"
CHECKPOINT: Only proceed if all axiom candidates pass testing.
Phase 4: IMPLEMENT (fill sorries)
Goal: Complete the proofs.
Standard iteration loop:
- Pick a sorry
- Write proof attempt
- Compiler-in-the-loop checks (hook fires automatically)
- If error, Godel-Prover suggests fixes
- Iterate until sorry is filled
- Repeat for all sorries
Tools active:
- compiler-in-the-loop hook (on every Write)
- Godel-Prover suggestions (on errors)
Phase 5: VERIFY (audit)
Goal: Confirm proof quality.
-
Axiom Audit
lake build && grep "depends on axioms" output- Standard: propext, Classical.choice, Quot.sound ✓
- Custom axioms: LIST EACH ONE
-
Sorry Count
grep -c "sorry" proofs/<file>.lean- Must be 0 for "complete" proof
-
Generate Summary
✓ MACHINE VERIFIED (or ⚠️ PARTIAL - N axioms) Theorem: <statement> Proof Strategy: <brief description> Proved: - <lemma 1> - <lemma 2> Axiomatized (if any): - <axiom>: <why it's needed> File: proofs/<name>.lean
Research Tool Priority
Use whatever's available, in order:
| Tool | Best For | Command |
|------|----------|---------|
| Loogle | Type signature search (PRIMARY) | loogle-search "pattern" |
| Nia MCP | Library documentation | mcp__nia__search |
| Perplexity MCP | Proof strategies, papers | mcp__perplexity__search |
| WebSearch | General references | WebSearch tool |
| WebFetch | Specific paper/page content | WebFetch tool |
Loogle setup: Requires ~/tools/loogle with Mathlib index. Run loogle-server & for fast queries.
If no search tools available, proceed with caution and note "research phase skipped".
Checkpoints (automatic)
The workflow pauses for user input when:
- ⚠️ Research finds obstacles
- ❌ Testing finds counterexamples
- 🔄 Implementation hits unfillable sorry after N attempts
Output Format
┌─────────────────────────────────────────────────────┐
│ ✓ MACHINE VERIFIED │
│ │
│ Theorem: ∀ φ : G →* H, φ(1_G) = 1_H │
│ │
│ Proof Strategy: Direct application of │
│ MonoidHom.map_one from Mathlib. │
│ │
│ Phases: │
│ 📚 Research: Found in Mathlib.Algebra.Group.Hom │
│ 🏗️ Design: Single lemma, no sorries needed │
│ 🧪 Test: N/A (trivial) │
│ ⚙️ Implement: 3 lines │
│ ✅ Verify: 0 custom axioms, 0 sorries │
│ │
│ File: proofs/group_hom_identity.lean │
└─────────────────────────────────────────────────────┘
What I Can Prove
| Domain | Examples | |--------|----------| | Category Theory | Functors, natural transformations, Yoneda | | Abstract Algebra | Groups, rings, homomorphisms | | Topology | Continuity, compactness, connectedness | | Analysis | Limits, derivatives, integrals | | Logic | Propositional, first-order |
Limitations
- Complex proofs may take multiple iterations
- Novel research-level proofs may exceed capabilities
- Some statements are unprovable over ℚ (need ℝ extension)
Behind The Scenes
- Lean 4.26.0 - Theorem prover
- Mathlib - 100K+ formalized theorems
- Godel-Prover - AI tactic suggestions (via LMStudio)
- Compiler-in-the-loop - Automatic verification on every write
- Research tools - Nia, Perplexity, WebSearch (graceful degradation)
See Also
/loogle-search- Search Mathlib by type signature (used in Phase 1 RESEARCH)/math-router- For computation (integrals, equations)/lean4- Direct Lean syntax access
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Scrapling
103.6k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
