Agent skill

Direct Proving

by frenzymath in frenzymath/Danus

Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through.

Apache-2.0Auto-check passed

Install Direct Proving

skills CLI
$ npx skills add frenzymath/Danus --skill direct-proving -a claude-code

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

GitHub CLI
$ gh skill install frenzymath/Danus direct-proving --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/frenzymath/Danus.git skills-src && mkdir -p .claude/skills && cp -r skills-src/agents/skills/worker/direct-proving .claude/skills/direct-proving && 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
direct-proving
GitHub stars
476
Token cost
~1.3k tokens
SKILL.md length
643 words
Files
2
Skills in repo
16
Repo updated
First seen
Licence
Apache-2.0

At a glance

Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through.

  • Works in 12 steps: Take one decomposition plan at a time. → For each subgoal, actively use the… → When a similar theorem has been found,… → …
  • A decomposition plan is created
  • SKILL.md covers Input Contract, Procedure, Output Contract and Tools, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Direct Proving is an agent skill from frenzymath/Danus. Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through. Use when a decomposition plan is created.

Its SKILL.md is about 1.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

The repository describes itself as: Orchestrating Mathematical Reasoning Agents with Fact-Graph Memory. The licence is Apache-2.0.

When your agent uses it

  • A decomposition plan is created

Example prompts

  • “/direct-proving”

Workflow steps

12 steps, taken from the first numbered list in SKILL.md.

  1. Take one decomposition plan at a time.
  2. For each subgoal, actively use the searched results, toy examples, and counterexamples that are most relevant to that subgoal.
  3. When a similar theorem has been found, try to adapt its proof idea, construction, or reduction to the current subgoal instead of treating…
  4. If the adapted theorem is only a partial result with extra hypotheses, first analyze why its method needs those hypotheses and where it…
  5. First attempt to prove all subgoals in that plan directly.
  6. Try to carry the whole plan through before switching into failure diagnosis mode.
  7. For each subgoal, record whether it is
  8. If a subgoal is blocked or you get stuck on it, FIRST invoke $construct-counterexamples for that subgoal — test whether it is false, too…
  9. If a proof adaptation attempt fails, identify why the migration fails. Be concrete: for example, note which hypothesis is missing, which…
  10. If a subgoal is solved with a self-contained partial result that the rest of the plan will USE downstream, partial-verify that result with…
  11. If all subgoals are solved directly AND the partial results that compose into a full proof have each been partial-verified as needed, mark…
  12. When a direction remains viable and supports sustained progress, work on it

What it can do on your machine

Read from SKILL.md and the folder at commit 6d92e8d. 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 json).

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

  • Network

    No URLs in SKILL.md.

    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

Direct Proving loads about 1.3k tokens when it runs. Until then it costs about 54 tokens; SKILL.md has 643 words of instructions outside code blocks.

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

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 frenzymath/Danus at commit 6d92e8d, republished under its Apache-2.0 licence (© frenzymath). 643 words, ~1,291 tokens.

Download SKILL.mdSave it as .claude/skills/direct-proving/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
direct-proving
description
Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through. Use when a decomposition plan is created.

Direct Proving

Use this skill to screen decomposition plans by first trying to carry the whole plan through, and if it does not fully go through, then identify the key stuck points.

Input Contract

Read:

  • one decomposition plan from subgoals
  • relevant immediate_conclusions, toy_examples, counterexamples, and failed_paths
  • relevant search results and references
  • any previously identified external statements whose proofs may be adaptable

Procedure

  1. Take one decomposition plan at a time.
  2. For each subgoal, actively use the searched results, toy examples, and counterexamples that are most relevant to that subgoal.
  3. When a similar theorem has been found, try to adapt its proof idea, construction, or reduction to the current subgoal instead of treating it as a black-box citation.
  4. If the adapted theorem is only a partial result with extra hypotheses, first analyze why its method needs those hypotheses and where it fails for the current subgoal — do not skip this by merely trying to show the current object satisfies the extra hypotheses and applying the partial result directly.
  5. First attempt to prove all subgoals in that plan directly.
  6. Try to carry the whole plan through before switching into failure diagnosis mode.
  7. For each subgoal, record whether it is:
    • already solved directly
    • partially advanced
    • blocked
  8. If a subgoal is blocked or you get stuck on it, FIRST invoke $construct-counterexamples for that subgoal — test whether it is false, too strong, or missing hypotheses (not merely hard). If no counterexample emerges and the subgoal still resists after at least two genuine direct attempts, do not grind indefinitely: record the stuck point as an obstacle/dead_end finding (gm_add) so siblings skip it and the next round's master_guidance can bring fresh direction.
  9. If a proof adaptation attempt fails, identify why the migration fails. Be concrete: for example, note which hypothesis is missing, which construction does not transfer, which step breaks, which counterexample blocks the migration, or which part of the searched proof depends on structure absent in the current setting.
  10. If a subgoal is solved with a self-contained partial result that the rest of the plan will USE downstream, partial-verify that result with $verify-proof in partial-candidate mode before treating it as established. Adopting unverified partial results as building blocks is the single biggest correctness risk; the verifier is the sole authority on whether the partial result really holds.
  11. If all subgoals are solved directly AND the partial results that compose into a full proof have each been partial-verified as needed, mark the plan as solved and assemble the proof draft.
  12. When a direction remains viable and supports sustained progress, work on it deeply for 1–2 hours and try to establish one mathematically deep result that resolves a genuine obstacle or materially advances the main problem. Do not turn each routine calculation into its own fact, and do not bundle shallow observations merely to imitate depth; use supporting steps to prove the one substantive conclusion.
  13. If the plan does not fully go through, then identify the key stuck points as concretely as possible.
  14. Focus on locating the decisive failure modes of the plan after this first full attempt, not on polishing a full proof.
Show full SKILL.md (114 more words)Show less

Output Contract

Publish one record per attempted subgoal to global memory with gm_add (kind proof_attempt): claim = the subgoal + its status, evidence = the attempt / the partial proof if solved, plus these fields:

json
{
  "plan_id": "...",
  "attempt_type": "direct",
  "subgoal": "...",
  "attempt_summary": "...",
  "status": "solved|partial|stuck",
  "used_examples": ["..."],
  "used_counterexamples": ["..."],
  "counterexample_search_for_stuck_subgoal": {
    "performed": true,
    "summary": "...",
    "result": "refuted|not_refuted|inconclusive|not_needed"
  },
  "key_stuck_points": ["..."],
  "used_results": ["..."],
  "adapted_from": ["relevant statements or proofs whose ideas were migrated"],
  "migration_failures": ["why a proof adaptation or migration failed"],
  "branch_id": "optional"
}

Record the plan's updated status (screening / screened / solved) in your local memory or as a follow-up plan finding.

Tools

  • gm_add (publish the proof-attempt finding)
  • gm_search (recall examples, counterexamples, dead-ends, and verified facts)
  • fact_submit (verify any self-contained partial result before building on it; see $verify-proof)
  • search_arxiv_theorems

Failure Logging

If a decomposition plan does not solve the problem directly after attempting all of its subgoals, publish a dead_end finding (gm_add) that summarizes the plan-local stuck points and any important proof-migration failures, so siblings skip them.

© frenzymath, Apache-2.0. 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 agents/skills/worker/direct-proving of frenzymath/Danus.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit 6d92e8d

Compare with similar skills

Direct Proving 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.

Direct Proving compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Direct Proving this skillfrenzymath/Danus476—~1.3kAutomated safety check: PassApache-2.0
Direction Pickernexu-io/open-design100k—~472Automated safety check: WarnApache-2.0
Frontend Design Directionaffaan-m/ECC276k1 repos~1.1kAutomated safety check: PassMIT
Direction Attributethedaviddias/Front-End-Checklist74k—~534Automated safety check: PassMIT
Bio Crispr Screens Screen QcFreedomIntelligence/OpenClaw-Medical-Skills3.1k—~2.1kAutomated safety check: PassNone
Screen Recordinggithub/awesome-copilot40k—~2kAutomated safety check: PassMIT

Similar skills

  • Direction Picker

    nexu-io/open-design

    Resolves the visual direction at the plan stage from the brief and design system, without asking the user.

    100k GitHub stars~472 tokensUpdated today
    Frontend & DesignAuto-check: warnings
  • Set an ECC-specific frontend design direction for production UI work.

    276k GitHub starsUsed in 1 repo~1.1k tokens
    Frontend & DesignAuto-check passed
  • Direction Attribute

    thedaviddias/Front-End-Checklist

    A skill your agent uses when reviewing templates, rendered HTML, or shared components related to Set text direction for RTL languages.

    74k GitHub stars~534 tokensUpdated 3 days ago
    Auto-check passed
  • Bio Crispr Screens Screen Qc

    FreedomIntelligence/OpenClaw-Medical-Skills

    Quality control for pooled CRISPR screens. An agent skill from FreedomIntelligence/OpenClaw-Medical-Skills.

    3.1k GitHub stars~2.1k tokensUpdated 2 mo ago
    Research & ScienceAuto-check passed
  • Screen Recording

    github/awesome-copilot

    Official

    Create annotated animated GIF demos and screen recordings for pull requests and documentation.

    40k GitHub stars~2k tokensUpdated today
    DevelopmentAuto-check passed
  • macOS Screen Recorder

    sickn33/agentic-awesome-skills

    macOS screen recorder that captures the main display PLUS system audio via ScreenCaptureKit — no BlackHole/loopback driver, no sudo, just the standard Screen Recording permission.

    47k GitHub starsUsed in 1 repo~727 tokens
    Auto-check passed

More from frenzymath/Danus

All 16 skills in this repo
  • Validate externally referenced theorems by querying arXiv theorem search first and Codex's built-in web search second.

    476 GitHub stars~852 tokensUpdated 1 mo ago
    Auto-check passed
  • Construct candidate counterexamples to test a proposed conjecture, lemma, or intermediate claim by keeping the assumptions true while making the claimed conclusion fail.

    476 GitHub stars~790 tokensUpdated 1 mo ago
    Auto-check passed
  • Construct Toy Examples

    frenzymath/Danus

    Generate and analyze simpler examples that satisfy both the assumptions and the conclusion of a theorem statement or subgoal.

    476 GitHub stars~541 tokensUpdated 1 mo ago
    Auto-check passed
  • Identify Key Failures

    frenzymath/Danus

    Synthesize the common stuck points across failed decomposition plans.

    476 GitHub stars~586 tokensUpdated 1 mo ago
    Auto-check passed
  • Derive immediate mathematical consequences from a theorem statement or subgoal.

    476 GitHub stars~587 tokensUpdated 1 mo ago
    Auto-check passed
  • Propose multiple subgoal decomposition plans for the current theorem using the information already gathered.

    476 GitHub stars~580 tokensUpdated 1 mo ago
    Auto-check passed

Questions about Direct Proving

What does Direct Proving do?

Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through. Direct Proving is an agent skill from frenzymath/Danus. Screen a decomposition plan by first trying to prove all of its subgoals directly, then identifying the key stuck points if the plan does not fully go through.

When should I use Direct Proving?

Direct Proving fits situations like: A decomposition plan is created.

How do I install Direct Proving in Claude Code?

Run `npx skills add frenzymath/Danus --skill direct-proving -a claude-code`. Or copy the skill folder (agents/skills/worker/direct-proving in frenzymath/Danus) into .claude/skills/direct-proving in your project. Claude Code loads it when a task matches its description.

How do I install Direct Proving in Codex?

Run `npx skills add frenzymath/Danus --skill direct-proving -a codex`. Or copy the skill folder (agents/skills/worker/direct-proving in frenzymath/Danus) into .agents/skills/direct-proving in your project. Codex loads it when a task matches its description.

Can I use Direct Proving 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 frenzymath/Danus --skill direct-proving -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/direct-proving, .gemini/skills/direct-proving, .github/skills/direct-proving and .opencode/skills/direct-proving in your project.

What does Direct Proving need to run?

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

Does Direct Proving access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Direct Proving 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 Direct Proving use?

Direct Proving is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Direct Proving use?

About 1.3k tokens (SKILL.md is roughly 5.2k 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 Direct Proving?

Skills that share tags, products or a category with Direct Proving: Direction Picker (nexu-io/open-design, 100k stars), Frontend Design Direction (affaan-m/ECC, 276k stars), Direction Attribute (thedaviddias/Front-End-Checklist, 74k stars) and Bio Crispr Screens Screen Qc (FreedomIntelligence/OpenClaw-Medical-Skills, 3.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Direct Proving?

frenzymath (a GitHub organization) maintains it in frenzymath/Danus, which has 476 GitHub stars. The repository holds 16 skills in this directory. The repository was last updated on August 27, 2026.

Source: frenzymath/Danus on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.