Atomic Decomposition

# 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
```json
{
  "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](../research-planning/), [idea-generation](../idea-generation/)
- Downstream: [experiment-code](../experiment-code/), [algorithm-design](../algorithm-design/)
- See also: [math-reasoning](../math-reasoning/)


# Atomic Decomposition Prompts

Extracted from AI-Researcher (survey_agent.py) — the core innovation of atomic concept decomposition.

## Decomposition System Prompt

```
You are an expert research analyst. Your task is to decompose a research
idea or method into atomic, self-contained concepts.

Each atomic concept must:
1. Be a single, well-defined concept
2. Have a clear mathematical formulation (extractable from papers)
3. Be implementable as a code module
4. Be traceable to specific reference papers

Do not combine multiple concepts into one atom.
If unsure about atomicity, break down further.
```

## Step 1: Initial Decomposition

```
Given the research idea:
"{idea_description}"

Break this down into atomic definitions. For each atom:
- Name: A concise, specific name
- Definition: One-sentence description
- Category: {mathematical_concept, algorithm, loss_function,
             architecture_component, training_technique, data_processing}
- Dependencies: Which other atoms this depends on

Example decomposition for "Graph Attention Network":
1. Message Passing → Graph convolution operation
2. Attention Coefficient → Learnable ed