SkillAgentSearch skills...

lean4-theorem-proving

Use when working with Lean 4 (.lean files), writing mathematical proofs, seeing "failed to synthesize instance" errors, managing sorry/axiom elimination, or searching mathlib for lemmas - provides build-first workflow, haveI/letI patterns, compiler-guided repair, and LSP integration

Install / Use

npx skills add benchflow-ai/skillsbench --skill lean4-theorem-proving

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

81/100

Category

Automation

Supported Platforms

Universal

Our assessment of lean4-theorem-proving

lean4-theorem-proving scores 81/100 on our quality scale, 2335th of 2,758 Automation skills we index.

Its SKILL.md is 8.8 KB long, well organised into 16 sections and no code examples: a thorough specification that gives an agent plenty to work with.

With 1,813 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
13/20
Description
15/15
Adoption
14/20
Freshness
11/15

Maintenance, license and trust

  • The repository was last updated about 4 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-08 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-06. Automated pattern scan on 2026-10-06. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

lean4-theorem-proving compared with similar skills

All 4 of these similar skills score higher than lean4-theorem-proving; compare them before choosing.

SkillScoreStarsUpdatedFormat
lean4-theorem-proving (this skill)by benchflow-ai811.8k4mo agoSKILL.md
Agent-Reachby Panniantong100114.0ktodayCLAUDE.md
rufloby ruvnet10082.3ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10040.6k12d agoCLAUDE.md
Scraplingby D4Vinci100104.9k5d agoMCP Server

Frequently asked questions

How do I install lean4-theorem-proving?
Run npx skills add benchflow-ai/skillsbench --skill lean4-theorem-proving. The install tabs above show the steps for each supported agent.
Which AI agents does lean4-theorem-proving 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 lean4-theorem-proving safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 98/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 lean4-theorem-proving still maintained?
The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.

name: lean4-theorem-proving description: Use when working with Lean 4 (.lean files), writing mathematical proofs, seeing "failed to synthesize instance" errors, managing sorry/axiom elimination, or searching mathlib for lemmas - provides build-first workflow, haveI/letI patterns, compiler-guided repair, and LSP integration

Lean 4 Theorem Proving

Core Principle

Build incrementally, structure before solving, trust the type checker. Lean's type checker is your test suite.

Success = lake build passes + zero sorries + zero custom axioms. Theorems with sorries/axioms are scaffolding, not results.

Quick Reference

| Resource | What You Get | Where to Find | |--------------|------------------|-------------------| | Interactive Commands | 10 slash commands for search, analysis, optimization, repair | Type /lean in Claude Code (full guide) | | Automation Scripts | 19 tools for search, verification, refactoring, repair | Plugin scripts/ directory (scripts/README.md) | | Subagents | 4 specialized agents for batch tasks (optional) | subagent-workflows.md | | LSP Server | 30x faster feedback with instant proof state (optional) | lean-lsp-server.md | | Reference Files | 18 detailed guides (phrasebook, tactics, patterns, errors, repair, performance) | List below |

When to Use

Use for ANY Lean 4 development: pure/applied math, program verification, mathlib contributions.

Critical for: Type class synthesis errors, sorry/axiom management, mathlib search, measure theory/probability work.

Tools & Workflows

7 slash commands for search, analysis, and optimization - type /lean in Claude Code. See COMMANDS.md for full guide with examples and workflows.

16 automation scripts for search, verification, and refactoring. See scripts/README.md for complete documentation.

Lean LSP Server (optional) provides 30x faster feedback with instant proof state and parallel tactic testing. See lean-lsp-server.md for setup and workflows.

Subagent delegation (optional, Claude Code users) enables batch automation. See subagent-workflows.md for patterns.

Build-First Principle

ALWAYS compile before committing. Run lake build to verify. "Compiles" ≠ "Complete" - files can compile with sorries/axioms but aren't done until those are eliminated.

The 4-Phase Workflow

  1. Structure Before Solving - Outline proof strategy with have statements and documented sorries before writing tactics
  2. Helper Lemmas First - Build infrastructure bottom-up, extract reusable components as separate lemmas
  3. Incremental Filling - Fill ONE sorry at a time, compile after each, commit working code
  4. Type Class Management - Add explicit instances with haveI/letI when synthesis fails, respect binder order for sub-structures

Finding and Using Mathlib Lemmas

Philosophy: Search before prove. Mathlib has 100,000+ theorems.

Use /search-mathlib slash command, LSP server search tools, or automation scripts. See mathlib-guide.md for detailed search techniques, naming conventions, and import organization.

Essential Tactics

Key tactics: simp only, rw, apply, exact, refine, by_cases, rcases, ext/funext. See tactics-reference.md for comprehensive guide with examples and decision trees.

Domain-Specific Patterns

Analysis & Topology: Integrability, continuity, compactness patterns. Tactics: continuity, fun_prop.

Algebra: Instance building, quotient constructions. Tactics: ring, field_simp, group.

Measure Theory & Probability (emphasis in this skill): Conditional expectation, sub-σ-algebras, a.e. properties. Tactics: measurability, positivity. See measure-theory.md for detailed patterns.

Complete domain guide: domain-patterns.md

Managing Incomplete Proofs

Standard mathlib axioms (acceptable): Classical.choice, propext, quot.sound. Check with #print axioms theorem_name or /check-axioms.

CRITICAL: Sorries/axioms are NOT complete work. A theorem that compiles with sorries is scaffolding, not a result. Document every sorry with concrete strategy and dependencies. Search mathlib exhaustively before adding custom axioms.

When sorries are acceptable: (1) Active work in progress with documented plan, (2) User explicitly approves temporary axioms with elimination strategy.

Not acceptable: "Should be in mathlib", "infrastructure lemma", "will prove later" without concrete plan.

Compiler-Guided Proof Repair

When proofs fail to compile, use iterative compiler-guided repair instead of blind resampling.

Quick repair: /lean4-theorem-proving:repair-file FILE.lean

How it works:

  1. Compile → extract structured error (type, location, goal, context)
  2. Try automated solver cascade first (many simple cases handled mechanically, zero LLM cost)
    • Order: rfl → simp → ring → linarith → nlinarith → omega → exact? → apply? → aesop
  3. If solvers fail → call lean4-proof-repair agent:
    • Stage 1: Haiku (fast, most common cases) - 6 attempts
    • Stage 2: Sonnet (precise, complex cases) - 18 attempts
  4. Apply minimal patch (1-5 lines), recompile, repeat (max 24 attempts)

Key benefits:

  • Low sampling budget (K=1 per attempt, not K=100)
  • Error-driven action selection (specific fix per error type, not random guessing)
  • Fast model first (Haiku), escalate only when needed (Sonnet)
  • Solver cascade handles simple cases mechanically (zero LLM cost)
  • Early stopping prevents runaway costs (bail after 3 identical errors)

Expected outcomes: Success improves over time as structured logging enables learning from attempts. Cost optimized through solver cascade (free) and multi-stage escalation.

Commands:

  • /repair-file FILE.lean - Full file repair
  • /repair-goal FILE.lean LINE - Specific goal repair
  • /repair-interactive FILE.lean - Interactive with confirmations

Detailed guide: compiler-guided-repair.md

Inspired by: APOLLO (https://arxiv.org/abs/2505.05758) - compiler-guided repair with multi-stage models and low sampling budgets.

Common Compilation Errors

| Error | Fix | |-------|-----| | "failed to synthesize instance" | Add haveI : Instance := ... | | "maximum recursion depth" | Provide manually: letI := ... | | "type mismatch" | Use coercion: (x : ℝ) or ↑x | | "unknown identifier" | Add import |

See compilation-errors.md for detailed debugging workflows.

Documentation Conventions

  • Write timeless documentation (describe what code is, not development history)
  • Don't highlight "axiom-free" status after proofs are complete
  • Mark internal helpers as private or in dedicated sections
  • Use example for educational code, not lemma/theorem

Quality Checklist

Before commit:

  • [ ] lake build succeeds on full project
  • [ ] All sorries documented with concrete strategy
  • [ ] No new axioms without elimination plan
  • [ ] Imports minimal

Doing it right: Sorries/axioms decrease over time, each commit completes one lemma, proofs build on mathlib.

Red flags: Sorries multiply, claiming "complete" with sorries/axioms, fighting type checker for hours, monolithic proofs (>100 lines), long have blocks (>30 lines should be extracted as lemmas - see proof-refactoring.md).

Reference Files

Core references: lean-phrasebook.md, mathlib-guide.md, tactics-reference.md, compilation-errors.md

Domain-specific: domain-patterns.md, measure-theory.md, instance-pollution.md, calc-patterns.md

Incomplete proofs: sorry-filling.md, axiom-elimination.md

Optimization & refactoring: performance-optimization.md, proof-golfing.md, proof-refactoring.md, mathlib-style.md

Automation: compiler-guided-repair.md, lean-lsp-server.md, lean-lsp-tools-api.md, subagent-workflows.md

Related Skills

View on GitHub
GitHub Stars1.8k
CategoryAutomation
Updated4mo ago
Forks368

Languages

PDDL

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info
lean4-theorem-proving — Universal Skill: Install & Safety Check | SkillAgent