PluginBench
Skill
Review
Audit score 70

atomic-decomposition

lingzhi227/agent-research-skills

Decompose research papers into atomic concepts with bidirectional math-to-code mapping.

What is atomic-decomposition?

This skill breaks down complex research ideas and papers into self-contained atomic concepts, each with extracted mathematical formulas and corresponding code implementations. Use it when studying formal papers that require grounding in both theory and practice.

  • Decompose research ideas into atomic, self-contained concepts
  • Extract mathematical formulas from papers with LaTeX notation
  • Identify code implementations for each mathematical concept
  • Create structured knowledge entries linking theory to code
  • Verify bidirectional consistency between formulas and implementations
  • Trace assumptions and constraints for each atomic definition

How to install atomic-decomposition

npx skills add https://github.com/lingzhi227/agent-research-skills --skill atomic-decomposition
Claude Code
Cursor
Windsurf
Cline

How to use atomic-decomposition

  1. 1.Provide a research idea, paper title, or method description as input
  2. 2.The skill will decompose the concept into atomic definitions
  3. 3.For each atomic definition, it extracts the mathematical formula from papers
  4. 4.It then searches for corresponding code implementations in repositories
  5. 5.Review the generated knowledge entries linking each formula to code
  6. 6.Verify consistency: confirm every math formula has a code implementation and vice versa
  7. 7.Identify any gaps where theory lacks code or code lacks formal grounding

Use cases

Good for
  • Understanding a machine learning paper by mapping each algorithm component to its math formula and reference implementation
  • Studying a systems paper by decomposing architectural concepts into formal definitions with corresponding code modules
  • Building a knowledge base for a complex method by ensuring every formula has verified code and vice versa
  • Identifying gaps in understanding when code exists but lacks formal mathematical grounding
  • Comparing multiple implementations of the same mathematical concept across different codebases
Who it's for
  • Researchers studying formal papers requiring mathematical rigor
  • Engineers implementing algorithms from academic publications
  • Students learning complex systems with both theoretical and practical components
  • Teams building reproducible implementations of published methods

atomic-decomposition FAQ

What makes a concept 'atomic'?

An atomic concept is a single, self-contained idea with clear mathematical foundations, implementable in code, and traceable to specific papers. It should not combine multiple concepts.

What if I find code without a corresponding mathematical formula?

Document it as a gap. The skill emphasizes bidirectional consistency—every code module should trace back to a formal mathematical definition.

How detailed should the mathematical formulas be?

Extract the exact LaTeX formulas from papers, including assumptions and constraints. The goal is formal grounding sufficient to understand and implement the concept.

Can I use this for non-academic code?

The skill is designed for research papers and formal methods. It works best when source material includes mathematical formulations and published implementations.

What if a paper lacks code implementations?

The skill will identify this as a gap. You can then search open-source repositories for implementations, or note that the concept needs implementation.

Full instructions (SKILL.md)

Source of truth, from lingzhi227/agent-research-skills.


name: atomic-decomposition description: Decompose research ideas into atomic, self-contained concepts with bidirectional math-code mapping. For each concept, extract the math formula from papers and find code implementations. Use for complex system papers requiring formal grounding. argument-hint: [idea-or-paper]

Atomic Decomposition

Decompose research ideas into atomic concepts with math formula <-> code implementation mapping.

Input

  • $0 — Research idea, paper, or method description

References

  • Decomposition prompts and workflow: ~/.claude/skills/atomic-decomposition/references/decomposition-prompts.md

Workflow (from AI-Researcher Survey Agent)

Step 1: Break Down into Atomic Definitions

Analyze the research idea and decompose into atomic, self-contained concepts:

  • Each atom should be a single concept
  • Must have clear mathematical foundations
  • Must be implementable in code
  • Must be traceable to specific papers

Step 2: For Each Atomic Definition

A. Paper Survey (Math Formula)

  • Search papers for the mathematical formulation
  • Extract the exact LaTeX formula
  • Note assumptions and constraints
  • Record reference papers

B. Code Survey (Implementation)

  • Search codebases for implementations
  • Extract the corresponding code
  • Note implementation details and variations
  • Record reference repositories

C. Create Knowledge Entry

{
  "definition": "Kernelized Gumbel-Softmax Operator",
  "math_formula": "Z = \\text{softmax}((\\log \\pi + g) / \\tau), g \\sim \\text{Gumbel}(0,1)",
  "code_implementation": "def gumbel_softmax(logits, tau=1.0): ...",
  "reference_papers": ["Paper Title 1"],
  "reference_codebases": ["github_user/repo_name"],
  "assumptions": ["Differentiable relaxation of discrete sampling"],
  "connections": ["Used in Component X of the proposed method"]
}

Step 3: Compile Knowledge Base

  • Merge all atomic definitions into a structured knowledge base
  • Verify consistency: every math formula has a code implementation
  • Verify completeness: every code module traces to a formal definition
  • Identify any gaps (formulas without code, or code without theory)

Rules

  • Each atomic definition must be specific enough to trace to concrete formulas and code
  • Do not skip or combine definitions — analyze each separately
  • If unsure about atomicity, err on the side of breaking down further
  • Document breakdown reasoning before analysis
  • Every mathematical concept in the paper must have verified code
  • Every code module must trace back to a formal mathematical definition

Related Skills

  • Upstream: research-planning, idea-generation
  • Downstream: experiment-code, algorithm-design
  • See also: math-reasoning