New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Proof Failure Explainer

by majiayu000 in majiayu000/claude-skill-registry

Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics.

MITAuto-check passedDevelopment

Install Proof Failure Explainer

skills CLI
$ npx skills add majiayu000/claude-skill-registry --skill proof-failure-explainer -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install majiayu000/claude-skill-registry proof-failure-explainer --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/majiayu000/claude-skill-registry.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/analysis/proof-failure-explainer .claude/skills/proof-failure-explainer && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
proof-failure-explainer
GitHub stars
666
Used in
1 other repo
Token cost
~2.5k tokens
SKILL.md length
892 words
Files
2
Skills in repo
1,273
Repo updated
First seen
Licence
MIT

At a glance

Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics.

  • Works in 5 steps: Gather Context → Identify Failure Category → Analyze Root Cause → …
  • The user encounters proof failures
  • SKILL.md covers Overview, Analysis Workflow, Common Failure Patterns and Examples, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Proof Failure Explainer is an agent skill from majiayu000/claude-skill-registry. Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics. Use when the user encounters proof failures, error messages in formal verification, stuck proof states, or asks why their Isabelle/Coq proof doesn't work.

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 1 other file (for example `metadata.json`).

It sits in Development, covering Root cause analysis. The repository describes itself as: Searchable Claude Code skills catalog with source-linked guides and generated registry artifacts. The licence is MIT.

When your agent uses it

  • The user encounters proof failures
  • Error messages in formal verification
  • Stuck proof states
  • Asks why their Isabelle/Coq proof doesnt work

Example prompts

  • “/proof-failure-explainer”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Gather Context
  2. Identify Failure Category
  3. Analyze Root Cause
  4. Explain the Failure
  5. Suggest Solutions

What it can do on your machine

Read from SKILL.md and the folder at commit 2d14a69. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are coq and isabelle).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • isabelle.in.tum.de
    • coq.inria.fr
    • softwarefoundations.cis.upenn.edu

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Proof Failure Explainer loads about 2.5k tokens when it runs. Until then it costs about 92 tokens; SKILL.md has 892 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~92
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from majiayu000/claude-skill-registry at commit 2d14a69, republished under its MIT licence (© majiayu000). 892 words, ~2,482 tokens.

Download SKILL.mdSave it as .claude/skills/proof-failure-explainer/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
proof-failure-explainer
description
Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics. Use when the user encounters proof failures, error messages in formal verification, stuck proof states, or asks why their Isabelle/Coq proof doesn't work.

Proof Failure Explainer

Overview

Diagnose and explain proof failures in Isabelle and Coq by analyzing proof states, error messages, and goal structures. This skill helps identify root causes and suggests fixes for common proof problems.

Analysis Workflow

Step 1: Gather Context

Collect information about the failure:

  1. Proof state:

    • Current goal(s)
    • Available hypotheses/assumptions
    • Context (definitions, lemmas in scope)

  2. Error message:

    • Exact error text
    • Which tactic failed
    • Line/position of failure

  3. Proof attempt:

    • What tactics were tried
    • What was expected to happen
    • Where the proof got stuck
Step 2: Identify Failure Category

Classify the type of failure:

Type Errors:

  • Type mismatch in expressions
  • Wrong function argument types
  • Incompatible type unification

Unification Failures:

  • Cannot unify terms
  • Existential variables not instantiated
  • Pattern matching failures

Missing Assumptions:

  • Unprovable without additional hypotheses
  • Missing preconditions
  • Insufficient context

Incorrect Goals:

  • Goal statement is false
  • Goal too strong or too weak
  • Wrong quantifier order

Tactic Failures:

  • Tactic not applicable to goal
  • Wrong tactic for goal structure
  • Induction hypothesis too weak

Scope Issues:

  • Variables not in scope
  • Shadowed variables
  • Context problems
Step 3: Analyze Root Cause

Examine the specific failure:

For Type Errors:

Check each term's type:
- What type does the term have?
- What type is expected?
- Where does the mismatch occur?

For Unification Failures:

Compare terms that should unify:
- Are they syntactically equal?
- What substitution would make them equal?
- Is that substitution possible?

For Missing Assumptions:

Identify what's needed:
- What fact would make the goal provable?
- Is it missing from hypotheses?
- Should it be a precondition?

For Incorrect Goals:

Verify goal correctness:
- Is the statement actually true?
- Can you find a counterexample?
- Is it too strong/weak?
Step 4: Explain the Failure

Provide clear explanation:

  1. State the problem:

    • "The proof fails because..."
    • Point to specific issue

  2. Show the mismatch:

    • Highlight conflicting terms/types
    • Show what was expected vs. actual

  3. Explain why it fails:

    • Why the tactic doesn't work
    • Why terms don't unify
    • Why the goal is unprovable
Step 5: Suggest Solutions

Offer concrete fixes:

  1. Immediate fixes:

    • Correct the type annotation
    • Add missing assumption
    • Fix goal statement
    • Use different tactic

  2. Alternative approaches:

    • Different proof strategy
    • Strengthen/weaken goal
    • Generalize before induction
    • Add helper lemmas

  3. Code examples:

    • Show corrected version
    • Demonstrate working proof
    • Explain why it works

Common Failure Patterns

For detailed patterns and examples, see failure_patterns.md.

Quick Diagnosis Guide
SymptomLikely CauseQuick Check
"Type unification failed"Type mismatchCheck types with Check (Coq) or term (Isabelle)
"Unable to unify X with Y"Terms don't matchCompare X and Y - are they equal?
"Tactic failure"Wrong tacticCheck goal structure - does tactic apply?
"Not found in environment"Scope issueIs variable quantified?
Proof gets stuckMissing hypothesisWhat fact would help?
Goal unprovableIncorrect statementIs the goal actually true?

Examples

Example 1: Type Mismatch

User's Failing Proof (Coq):

coq
Definition double (n : nat) : nat := n + n.

Lemma test : double true = 2.

Error:

The term "true" has type "bool" while it is expected to have type "nat".

Explanation: The proof fails because of a type mismatch:

  • double expects an argument of type nat
  • You provided true, which has type bool
  • Coq cannot apply a function expecting nat to a bool argument

Solution:

coq
Lemma test : double 1 = 2.
Proof.
  unfold double. reflexivity.
Qed.
Example 2: Unification Failure

User's Failing Proof (Coq):

coq
Lemma comm_fail : forall x y z : nat, x + y = y + z.
Proof.
  intros. reflexivity.
Qed.

Error:

Unable to unify "x + y" with "y + z".

Explanation: The proof fails because:

  • reflexivity requires both sides to be syntactically equal
  • x + y and y + z are not equal without knowing x = z
  • You're trying to prove something that's not true in general

Solution: Either fix the goal or add the necessary assumption:

coq
(* Option 1: Fix the goal to something true *)
Lemma comm_correct : forall x y : nat, x + y = y + x.
Proof.
  intros. lia.
Qed.

(* Option 2: Add assumption *)
Lemma comm_with_assumption : forall x y z : nat, x = z -> x + y = y + z.
Proof.
  intros. rewrite H. reflexivity.
Qed.
Example 3: Missing Assumption

User's Failing Proof (Isabelle):

isabelle
lemma "x > 0 ⟹ x + y > y"
  by simp

Error:

Failed to apply initial proof method

Explanation: The proof fails because:

  • For integers, x + y > y requires x > 0
  • The assumption is stated, but simp alone is insufficient
  • Need arithmetic reasoning, not just simplification

Solution:

isabelle
lemma "x > (0::int) ⟹ x + y > y"
  by arith

Or in Coq:

coq
Lemma add_positive : forall x y : nat, x > 0 -> x + y > y.
Proof.
  intros. lia.
Qed.
Show full SKILL.md (372 more words)Show less
Example 4: Wrong Tactic

User's Failing Proof (Coq):

coq
Lemma or_intro : forall P Q : Prop, P -> P \/ Q.
Proof.
  intros. split.
Qed.

Error:

Unable to unify "?P /\ ?Q" with "P \/ Q".

Explanation: The proof fails because:

  • split is for conjunction (/\), not disjunction (\/)
  • The goal is P \/ Q (disjunction)
  • You need left or right for disjunction

Solution:

coq
Lemma or_intro : forall P Q : Prop, P -> P \/ Q.
Proof.
  intros. left. assumption.
Qed.
Example 5: Incorrect Goal

User's Failing Proof (Isabelle):

isabelle
lemma list_comm: "xs @ ys = ys @ xs"

Error:

Failed to apply initial proof method

Explanation: The proof fails because:

  • List append (@) is NOT commutative
  • The goal is false in general
  • Counterexample: [1] @ [2] = [1,2] but [2] @ [1] = [2,1]

Solution: Fix the goal to something true:

isabelle
(* Append is associative, not commutative *)
lemma list_assoc: "(xs @ ys) @ zs = xs @ (ys @ zs)"
  by simp
Example 6: Wrong Induction Variable

User's Failing Proof (Coq):

coq
Lemma app_length : forall (A : Type) (l1 l2 : list A),
  length (l1 ++ l2) = length l1 + length l2.
Proof.
  intros. induction l2.
  - reflexivity.
  - simpl. (* Gets stuck *)

Explanation: The proof fails because:

  • Inducting on l2 (second list)
  • But ++ (append) is defined recursively on the first argument
  • Need to induct on l1 instead

Solution:

coq
Lemma app_length : forall (A : Type) (l1 l2 : list A),
  length (l1 ++ l2) = length l1 + length l2.
Proof.
  intros. induction l1.
  - reflexivity.
  - simpl. rewrite IHl1. reflexivity.
Qed.

Diagnostic Questions

When analyzing a failure, ask:

  1. Type-related:

    • What are the types of all terms?
    • Do the types match expectations?
    • Is there implicit type coercion?

  2. Unification-related:

    • What terms need to be equal?
    • Are they syntactically equal?
    • What would make them equal?

  3. Assumption-related:

    • What facts are available?
    • What facts are needed?
    • Are preconditions satisfied?

  4. Goal-related:

    • Is the goal statement correct?
    • Is it actually true?
    • Is it too strong/weak?

  5. Tactic-related:

    • What does this tactic do?
    • Does it apply to this goal?
    • What goal structure does it expect?

  6. Induction-related:

    • Which variable to induct on?
    • Is the IH strong enough?
    • Need to generalize first?

Best Practices

  1. Read error messages carefully: They often pinpoint the exact issue
  2. Check types first: Many failures are type-related
  3. Verify goal correctness: Make sure the statement is actually true
  4. Test with simple cases: Try the proof on a simple example
  5. Use automation cautiously: Understand why tactics fail
  6. Consult documentation: Check tactic requirements and behavior
  7. Search for similar proofs: Look for patterns in standard library
  8. Break down complex goals: Prove helper lemmas first

Debugging Tools

Isabelle
  • term "expr" - Check type of expression
  • thm theorem_name - Display theorem
  • find_theorems pattern - Search for relevant theorems
  • sledgehammer - Automated proof search
  • try - Try multiple tactics
Coq
  • Check term - Display type
  • Print name - Show definition
  • Search pattern - Find lemmas
  • Show Proof - Display proof term
  • Set Printing All - Show implicit arguments
  • Locate symbol - Find definition of notation

Resources

© majiayu000, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in skills/analysis/proof-failure-explainer of majiayu000/claude-skill-registry.

  • SKILL.md
  • metadata.json

Open the folder on GitHubat commit 2d14a69

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in majiayu000/claude-skill-registry, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Proof Failure Explainer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Proof Failure Explainer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Proof Failure Explainer this skillmajiayu000/claude-skill-registry6661 repos~2.5kAutomated safety check: PassMIT
Code Design Rationale Investigatorcursor/plugins10k9 repos~2.6kAutomated safety check: PassNone
OpenLogi macOS Permissions TriageAprilNEA/OpenLogi23k—~2.5kAutomated safety check: NotesApache-2.0
Bug Finder for daisyUIsaadeghi/daisyui43k—~2.3kAutomated safety check: PassMIT
Root Cause Debugginggarrytan/gstack136k—~1.4kAutomated safety check: PassMIT
Review PRapache/shardingsphere21k—~6.4kAutomated safety check: PassApache-2.0

Similar skills

  • Code Design Rationale Investigator

    cursor/plugins

    Official

    Digs into why code is shaped the way it is by checking git history, pull requests and connected tools in parallel, then reporting a cited read on the tradeoffs.

    10k GitHub starsUsed in 9 repos~2.6k tokens
    DevelopmentAuto-check passed

  • OpenLogi macOS Permissions Triage

    AprilNEA/OpenLogi

    Decides whether an OpenLogi device problem on macOS is a privacy-permission (TCC) problem, using agent log lines, and says which identity needs which grant.

    23k GitHub stars~2.5k tokensUpdated 5 days ago
    DevelopmentAuto-check: notes

  • Bug Finder for daisyUI

    saadeghi/daisyui

    Investigates suspected bugs in the daisyUI monorepo through read-only analysis, then writes a decision-ready fix plan in tmp/bugs without changing any product code.

    43k GitHub stars~2.3k tokensUpdated 8 days ago
    DevelopmentAuto-check passed

  • Root Cause Debugging

    garrytan/gstack

    Investigates bugs, errors and stack traces in phases and requires a root-cause hypothesis to be confirmed before any fix is written.

    136k GitHub stars~1.4k tokensUpdated today
    DevelopmentAuto-check passed

  • Review PR

    apache/shardingsphere

    Review Apache ShardingSphere or user-authorized downstream pull requests and PR discussions from public or authorized repository evidence.

    21k GitHub stars~6.4k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Graph-Based Bug Tracing

    tirth8205/code-review-graph

    Traces a bug through a code knowledge graph, following callers, callees and execution flow before opening source files, within a small token budget.

    32k GitHub starsUsed in 1 repo~287 tokens
    DevelopmentAuto-check passed

More from majiayu000/claude-skill-registry

All 1,273 skills in this repo

  • Deep Research

    majiayu000/claude-skill-registry

    Multi-source deep research using firecrawl and exa MCPs. An agent skill from majiayu000/claude-skill-registry.

    666 GitHub starsUsed in 6 repos~1.1k tokens
    Auto-check passed

  • Exa Search

    majiayu000/claude-skill-registry

    Neural search via Exa MCP for web, code, and company research.

    666 GitHub starsUsed in 5 repos~856 tokens
    Auto-check passed

  • Fal AI Media

    majiayu000/claude-skill-registry

    Unified media generation via fal.ai MCP — image, video, and audio.

    666 GitHub starsUsed in 5 repos~1.7k tokens
    Auto-check passed

  • Pyzotero

    majiayu000/claude-skill-registry

    Interact with Zotero reference management libraries using the pyzotero Python client.

    666 GitHub starsUsed in 5 repos~1.6k tokens
    Auto-check: notes

  • Bgpt Paper Search

    majiayu000/claude-skill-registry

    Search scientific papers and retrieve structured experimental data extracted from full-text studies via the BGPT MCP server.

    666 GitHub starsUsed in 4 repos~619 tokens
    Auto-check: notes

  • Bio Alignment Pairwise

    majiayu000/claude-skill-registry

    Perform pairwise sequence alignment using Biopython Bio.Align.PairwiseAligner.

    666 GitHub starsUsed in 4 repos~1.7k tokens
    Auto-check passed

Categories

Questions about Proof Failure Explainer

What does Proof Failure Explainer do?

Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics. Proof Failure Explainer is an agent skill from majiayu000/claude-skill-registry. Analyze and explain why Isabelle or Coq proofs fail, identifying the root cause such as type mismatches, missing assumptions, incorrect goals, unification failures, or inapplicable tactics.

When should I use Proof Failure Explainer?

Proof Failure Explainer fits situations like: the user encounters proof failures; error messages in formal verification; stuck proof states; asks why their Isabelle/Coq proof doesnt work.

How do I install Proof Failure Explainer in Claude Code?

Run `npx skills add majiayu000/claude-skill-registry --skill proof-failure-explainer -a claude-code`. Or copy the skill folder (skills/analysis/proof-failure-explainer in majiayu000/claude-skill-registry) into .claude/skills/proof-failure-explainer in your project. Claude Code loads it when a task matches its description.

How do I install Proof Failure Explainer in Codex?

Run `npx skills add majiayu000/claude-skill-registry --skill proof-failure-explainer -a codex`. Or copy the skill folder (skills/analysis/proof-failure-explainer in majiayu000/claude-skill-registry) into .agents/skills/proof-failure-explainer in your project. Codex loads it when a task matches its description.

Can I use Proof Failure Explainer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add majiayu000/claude-skill-registry --skill proof-failure-explainer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/proof-failure-explainer, .gemini/skills/proof-failure-explainer, .github/skills/proof-failure-explainer and .opencode/skills/proof-failure-explainer in your project.

What does Proof Failure Explainer need to run?

SKILL.md names no scripts, command-line tools or credentials: Proof Failure Explainer is instructions for the agent only.

Does Proof Failure Explainer access the network?

SKILL.md names 3 domains. As links in the text: isabelle.in.tum.de, coq.inria.fr and softwarefoundations.cis.upenn.edu. This is read from the text; nothing was executed.

Is Proof Failure Explainer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Proof Failure Explainer use?

Proof Failure Explainer is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Proof Failure Explainer use?

About 2.5k tokens (SKILL.md is roughly 9.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Proof Failure Explainer?

Skills that share tags, products or a category with Proof Failure Explainer: Code Design Rationale Investigator (cursor/plugins, 10k stars), OpenLogi macOS Permissions Triage (AprilNEA/OpenLogi, 23k stars), Bug Finder for daisyUI (saadeghi/daisyui, 43k stars) and Root Cause Debugging (garrytan/gstack, 136k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Proof Failure Explainer?

majiayu000 (a GitHub user) maintains it in majiayu000/claude-skill-registry, which has 666 GitHub stars. The repository holds 1,273 skills in this directory. The repository was last updated on October 7, 2026.

Source: majiayu000/claude-skill-registry on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.