/obtain-immediate-conclusions
Derive immediate mathematical consequences from a theorem statement or subgoal. Use when starting a new problem, branch, or subgoal, or when cheap progress or a cleaner reformulation is needed before deeper proof search.
$ npx -y skills add frenzymath/Danus --skill obtain-immediate-conclusions --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
- Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
- You can call itInvoke it directly when you want it.
- Slash command
/obtain-immediate-conclusions
Context preview
The summary Claude sees to decide when to auto-load this skill.
Derive immediate mathematical consequences from a theorem statement or subgoal. Use when starting a new problem, branch, or subgoal, or when cheap progress or a cleaner reformulation is needed before deeper proof search.
SKILL.md
obtain-immediate-conclusions.SKILL.mdname: obtain-immediate-conclusions
description: Derive immediate mathematical consequences from a theorem statement or subgoal. Use when starting a new problem, branch, or subgoal, or when cheap progress or a cleaner reformulation is needed before deeper proof search.
Obtain Immediate Conclusions
Extract direct implications before speculative reasoning.
Input Contract
Read from memory and current context:
- `problem_id`
- current theorem/subgoal statement
- memory
Procedure
1. Normalize notation and restate the claim in equivalent forms. 2. List direct consequences that follow from definitions and basic algebraic/logical manipulations. 3. Split consequences into necessary conditions and candidate sufficient conditions. 4. Mark each consequence with confidence and justification type. 5. For every conclusion, explicitly decide whether it is likely fragile and should be stress-tested by counterexample. 6. If a conclusion is fragile, record why it is fragile and indicate that `$construct-counterexamples` should be considered next.
Output Contract
Publish each conclusion to global memory with `gm_add` (kind `conclusion`): `claim` = the conclusion's statement, `evidence` = the derivation/justification that makes it checkable, and carry these fields in the record:
{
"statement": "...",
"justification_type": "by_definition|calculation|known_fact|logical_equivalence",
"confidence": 0.0,
"is_fragile": false,
"fragility_reason": "",
"suggested_followup": "none|construct-counterexamples",
"scope": "global|branch|subgoal",
"branch_id": "optional",
"subgoal_id": "optional"
}Rules:
- `is_fragile` must always be present.
- If `is_fragile=true`, then `fragility_reason` must explain the risk and `suggested_followup` should be `construct-counterexamples`.
- If `is_fragile=false`, use `fragility_reason=""` and `suggested_followup="none"`.
Tools
- `gm_add` (publish the conclusion finding)
- `gm_search` (recall related findings across the swarm)
- `search_arxiv_theorems` for nontrivial consequences
- Codex built-in web search for background definitions/terminology
Failure Logging
If no meaningful consequence is found, note it in your local memory (`events`) with:
- `event_type="immediate_conclusions_stalled"`
- missing assumptions and suspected blockers
Read more
name: obtain-immediate-conclusions description: Derive immediate mathematical consequences from a theorem statement or subgoal. Use when starting a new problem, branch, or subgoal, or when cheap progress or a cleaner reformulation is needed before deeper proof search.
Obtain Immediate Conclusions
Extract direct implications before speculative reasoning.
Input Contract
Read from memory and current context:
- `problem_id`
- current theorem/subgoal statement
- memory
Procedure
1. Normalize notation and restate the claim in equivalent forms. 2. List direct consequences that follow from definitions and basic algebraic/logical manipulations. 3. Split consequences into necessary conditions and candidate sufficient conditions. 4. Mark each consequence with confidence and justification type. 5. For every conclusion, explicitly decide whether it is likely fragile and should be stress-tested by counterexample. 6. If a conclusion is fragile, record why it is fragile and indicate that `$construct-counterexamples` should be considered next.
Output Contract
Publish each conclusion to global memory with `gm_add` (kind `conclusion`): `claim` = the conclusion's statement, `evidence` = the derivation/justification that makes it checkable, and carry these fields in the record:
{
"statement": "...",
"justification_type": "by_definition|calculation|known_fact|logical_equivalence",
"confidence": 0.0,
"is_fragile": false,
"fragility_reason": "",
"suggested_followup": "none|construct-counterexamples",
"scope": "global|branch|subgoal",
"branch_id": "optional",
"subgoal_id": "optional"
}Rules:
- `is_fragile` must always be present.
- If `is_fragile=true`, then `fragility_reason` must explain the risk and `suggested_followup` should be `construct-counterexamples`.
- If `is_fragile=false`, use `fragility_reason=""` and `suggested_followup="none"`.
Tools
- `gm_add` (publish the conclusion finding)
- `gm_search` (recall related findings across the swarm)
- `search_arxiv_theorems` for nontrivial consequences
- Codex built-in web search for background definitions/terminology
Failure Logging
If no meaningful consequence is found, note it in your local memory (`events`) with:
- `event_type="immediate_conclusions_stalled"`
- missing assumptions and suspected blockers
Danus orchestrates mathematical reasoning agents with fact-graph memory. A main agent (Claude Code) steers a swarm of autonomous codex workers that prove; a cold-start verifier is the sole authority on correctness: a result becomes real only once it passes.
Other skills on danus.
- /consult
Consult a strong reasoning model for strategy — feed it the current elaboration, take its reply as the next master_guidance, and dispatch workers from it. This is the main agent's high-intelligence step (workers prove; the consult decomposes and steers). Runs over the gpt_pro
Open skill - /elaboration
Write a high-signal-to-noise mathematical progress synthesis of a project from the shared stores (global memory + fact graph), following a fixed verdict→routes→interfaces→dangers→bridges template and a strict honesty discipline. Use it each strategic cycle, right before the
Open skill - /human-summary
Write a human-readable mathematical progress report (compiled PDF) on a project for the operator / the mathematician who posed the problem. This is NOT `elaboration` (dense input for the strategy consult) and NOT the dashboard. Render from the fact graph's verified
Open skill - /initialize
First-run setup interview for a Danus deployment. Run it on the FIRST session, whenever runtime/.danus-initialized is absent or OPERATOR.md is still the blank template, or when the operator asks to set up / initialize / onboard / re-configure. It greets the operator, explains
Open skill - /write-paper
Turn a project's verified fact graph into a publishable LaTeX paper in a configurable house style — a standalone amsart .tex with a real bibliography, compiled to PDF. Use when a project's target theorem is established and the operator wants the paper, or asks to
Open skill - /check-referenced-statements
Validate externally referenced theorems by querying arXiv theorem search first and Codex's built-in web search second. Use when a markdown proof cites statements from external papers.
Open skill

