Claim Decomposer

---
name: claim-decomposer
sub_type: guide
version: "1.1"
last_tested: "2026-09-16"
description: >
  Атомарная декомпозиция сложного утверждения: разложить → найти блокирующие атомы →
  построить Contradiction Map → Math-Code Trace → (опц.) формальное дерево дедукции
  LogicTree для цепочек ≥3 импликаций → Recomposition → Gate Decision.
  Уникальное ядро: видит cross-atom противоречия которые целостный анализ пропускает.
  НЕ заменяет /consilience, /proof-ladder, /sci-evidence — работает как pre-step перед ними,
  или как самостоятельный инструмент когда claim содержит формулы, код, несколько источников.
  Триггеры: /claim-decomposer, /decompose, "разложи утверждение", "найди противоречия в claim",
  "атомарный анализ", "что здесь сломано", "проверь логику", "atomic decomposition",
  "contradiction map", "recompose", "claim graph".
tokens: ~550
---

<!-- BSV — Brief Skill View | поиск: BSV
Скил   : claim-decomposer
TL;DR  : Разложи claim на атомы → найди blockers → Contradiction Map → Recomposition → Gate
Вызов  : /claim-decomposer, /decompose, разложи утверждение, найди противоречия
НЕ для : Целостный анализ одной простой гипотезы (→ /sci-evidence); evidence roadmap (→ /proof-ladder)
-->

# Claim Decomposer

## Зачем

Целостный анализ сложного утверждения — ловушка. Когда claim состоит из 5–10 шагов,
ошибка в шаге 3 маскируется корректностью шагов 1, 2, 4, 5. Системные противоречия
(атом A предполагает X, атом D предполагает не-X) вообще невидимы без полного графа.

Этот скилл делает одно: строит граф атомов, находит где граф рвётся, собирает обратно.
Всё остальное (фальсификация, consilience, evidence roadmap) — делегировать существующим скиллам.

---

## Шаг 0 — Context Lock

До разложения: зафикси что именно анализируем.

```
CLAIM: [точная формулировка — одно предложение или цитата]
SOURCE: [откуда claim — статья, код, проект, разговор]
SCOPE: [что входит в анализ, что явно исключено]
QUESTION_TYPE: descriptive / predictive / causal
```

Если causal → немедленно: нужен DAG + estimand до шага 1.
Если нет формулировки → задай один вопрос: "Что именно анализируем?"

Если claim (или отдельный атом, вскрывшийся уже в середине графа) в принципе не
формулируется фальсифицируемо (нет entity/predicate/measurable outcome — см.
Zero-Signal Gate, falsification-ladder.md Step -5) — это **ILL-POSED**, не KILL.
KILL — проверили и опровергли. ILL-POSED — проверять нечего. Не подменяй одно
другим: см. CLAIM_STATUS в Шаге 5 и обработку в Шаге 6.

---

## Шаг 1 — Claim Register

Выпиши все суб-утверждения из claim как нумерованный список.
Каждый атом — одно простое, фальсифицируемое утверждение.

**Формат:**
```
C1: [суб-утверждение]  [TYPE: empirical/logical/definitional/causal]  [EVIDENCE: cite/none]
C2: [суб-утверждение]  [TYPE]  [EVIDENCE]
...
```

**Правила:**
- "И" в одном предложении → разбить на два атома
- Запрещено: "возможно", "наверное", "скорее всего" — только чёткие, проверяемые утверждения
- Если атом нефальсифицируем → отметить `[UNFALSIFIABLE]` и вынести из анализа

---

## Шаг 2 — Critical Atoms

Из всего Claim Register выдели блокирующие:

```
BLOCKING_ATOMS: [C?, C?, ...]
  — атомы, провал которых убивает весь claim

LOAD_BEARING: [C?, C?, ...]
  — атомы, от которых зависят другие (D→A связи)

INDEPENDENT: [C?, C?, ...]
  — атомы, провал которых не убивает claim
```

Отметь граф зависимостей: C2 → C4 означает "C4 опирается на C2".

**Если у claim есть альтернативные пути поддержки (ИЛИ)** — запиши логику явно, например
`H = C1 & (C2 | C3)`, и (из репозитория Claude-cod-top-2026) запусти
`python scripts/claim_cutsets.py --logic "H = C1 & (C2 | C3)"` или `--decomposer <файл с этим выводом>`:
он посчитает минимальные наборы отказов (cuts), одиночные точки отказа и узлы, спрятанные под несколькими
«независимыми» путями. Только справка, не гейт; на чистом И даёт κ=1 и ничего нового не говорит
(`docs/derived-view-tools.md`).

---

## Шаг 3 — Math-Code Trace

**Только если claim содержит формулы, код, или численные утверждения.**

Для каждого математического атома:
1. Запиши исходную формулу/код
2. Пройди шаг за шагом: каждое преобразование → что оно делает
3. Найди где теоретическая формула расходится с реализацией
4. Проверь граничные условия (edge cases, sign conventions, index-off-by-one)

```
MATH_ATOM: C?
  FORMULA: [формула]
  TRACE:
    step 1: [преобразование] → [что получаем]
    step 2: ...
  DIVERGENCE: [где теория ≠ код, если есть]
  VERDICT: CONSISTENT / DIVERGENT / NEEDS_CHECK
```

---

## Шаг 3.5 — Formal Deduction Tree (LogicTree, опционально)

**Только если claim содержит ≥3 последовательно зависимых условных утверждения**
(если X, то Y, то Z — цепочка импликаций, не просто список независимых атомов).
Для claim'ов короче — пропусти, это лишний формализм там, где Contradiction Map
и так справляется.

**Зачем:** Contradiction Map (Шаг 4) ловит противоречие между парой атомов, когда
ты его ЗАМЕЧАЕШЬ, читая прозу. Для цепочки из 3+ импликаций это ненадёжно — скрытое
допущение в звене 2 из 4 легко упустить, потому что каждое отдельное звено читается
как разумное. LogicTree делает зависимость синтаксически видимой вместо того, чтобы
полагаться на внимательность при чтении.

Формализуй цепочку как посылки + цель, затем выведи ОБРАТНО от цели к посылкам:

```
P1: [предикат] ∧ [предикат] → [предикат]   [ссылка: C? / ASSUMED]
P2: [предикат] → [предикат]                 [ссылка: C? / ASSUMED]
...
GOAL: [целевой предикат — то, что claim утверждает в итоге]

BACKWARD_CHAIN: GOAL ← Pn ← Pn-1 ← ... ← P1

UNSUPPORTED_LINKS: [список Pi, помеченных ASSUMED — без атома-подтверждения из Шага 1]
```

**Что искать:**
- Каждая посылка Pi должна ссылаться на конкретный атом Ci из Claim Register (Шаг 1).
  Нет ссылки → это неатомизированное допущение, спрятанное внутри импликации, а не
  внутри отдельного атома, где его было бы видно.
- Если два звена цепи формализуются как P(x) и ¬P(x) (или логически несовместимые
  предикаты) — это формальное противоречие, перенеси его в Шаг 4 Contradiction Map
  явной строкой, не молчаливо.
- Обратная цепь короче прямой (несколько Pi схлопнулись в вывод одного) — не баг,
  сигнал что часть посылок избыточна или два звена стоит слить в claim'е.

**Выход:**
```
LOGICTREE_VERDICT:
  ALL_LINKS_SUPPORTED     — каждая посылка ссылается на атом из Claim Register
  UNSUPPORTED_LINK_FOUND  — минимум одна посылка не атомизирована (укажи какая)
  FORMAL_CONTRADICTION    — минимум два звена логически несовместимы (укажи какие)
```

**Связь с Recomposition Gate** (`rules/falsification-ladder.md` § Recomposition Gate):
именно `UNSUPPORTED_LINKS` — это конкретный, формальный ответ на вопрос "не добавляет
ли рекомпозиция скрытое допущение, которое никогда не тестировалось само по себе" —
вместо того чтобы полагаться на интуицию ревьюера при повторном чтении полного claim'а.

---

## Шаг 4 — Contradiction Map

Это главный шаг. Проверь каждую пару (Ci, Cj) на совместность.

**Матрица:**

|   | C1 | C2 | C3 | C4 | ... |
|---|----|----|----|----|-----|
| C1 | — | | | | |
| C2 | ? | — | | | |
| C3 | ? | ? | — | | |

Заполни каждую ячейку:
- ✅ совместимы
- ⚠️ напряжение (требуют дополнительного условия для совместности)
- ❌ противоречат (одновременно истинными быть не могут)

**Для каждого ❌:**
```
CONTRADICTION: Ci × Cj
  WHY: [объяснение конфликта]
  RESOLUTION_OPTIONS:
    a) [вариант разрешения]
    b) [вариант разрешения]
  BLOCKS_CLAIM: yes / no
```

---

## Шаг 5 — Recomposition

После атомарного анализа и Contradiction Map — собери обратно.

```
ATOMS_SURVIVED:  [список C? которые прошли проверку]
ATOMS_FAILED:    [список C? с причиной]
ATOMS_UNCERTAIN: [список C? требующих дополнительной проверки]

CONTRADICTIONS_BLOCKING: [количество + список]
CONTRADICTIONS_RESOLVABLE: [количество + список]

CLAIM_STATUS:
  HOLD      — все blocking atoms выжили, нет blocking contradictions
  WEAKEN    — claim частично верен, укажи в каком диапазоне
  PIVOT     — claim нужно переформулировать (укажи как)
  KILL      — ≥1 blocking atom провален или blocking contradiction неразрешима
  ILL-POSED — claim не сформулирован фальсифицируемо (нет entity/predicate/outcome).
              Это НЕ то же, что KILL: KILL = проверили и опровергли; ILL-POSED = проверить
              нечего. См. Zero-Signal Gate (falsification-ladder.md Step -5 → REFUSE).

RECOMPOSED_CLAIM: [что можно утверждать после анализа — честно, без лишнего]
```

---

## Шаг 6 — Gate Decision + Handoff

Вердикт + что делать дальше:

```
GATE: GO / CONDITIONAL / STOP / ILL-POSED

IF GO:
  → Следующий шаг: [конкретное действие]
  → Рекомендуемый скилл: /consilience / /proof-ladder / /sci-evidence build

IF CONDITIONAL:
  → Что нужно проверить: [список]
  → Proxy test (если реальные данные недоступны): [что можно проверить сейчас]

IF STOP:
  → Blocking reason: [один конкретный атом или противоречие]
  → Pivot direction: [куда переформулировать]
  → Сохранить в null_results: yes / no

IF ILL-POSED:
  → Причина: [какой entity/predicate/outcome не удалось назвать]
  → Это НЕ null_results (там опровергнутое), это незавершённая формулировка —
    не сохранять как KILL, вернуться к Шагу 0 с уточняющим вопросом
```

---

## Делегирование существующим скиллам

Claim Decomposer не делает сам:

| Задача | Делегировать |
|--------|-------------|
| 5 миров где неправ | `/sci-evidence falsify` |
| 5 путей к доказательству | `/consilience` |
| 7-уровневая лестница доказательств | `/proof-ladder` |
| 9 экспертов по гипотезе | `/hypothesis-lab` |
| Конкурирующие гипотезы | `/hypothesis-arbiter` |
| Adversarial review | `/skeptic` |

Claim Decomposer делает: граф атомов → противоречия → recomposition → handoff к нужному скиллу.

---

## Когда использовать

**Используй если:**
- Claim содержит ≥4 суб-утверждений
- Claim включает формулы или код
- Несколько источников evidence (могут противоречить)
- Кто-то сказал "это правильно/неправильно" — но ты не понимаешь почему
- Перед запуском `/consilience` на сложный проект

**Не используй если:**
- Одна простая гипотеза без подчастей → `/sci-evidence falsify`
- Нужен evidence roadmap → `/proof-ladder`
- Нужна экспертная панель → `/hypothesis-lab`

---

## Связанные скиллы

- `/sci-evidence` — фальсификация + evidence building (после decompose)
- `/consilience` — независимые пути доказательства (после decompose)
- `/proof-ladder` — стратегический маршрут доказательства
- `/hypothesis-arbiter` — когда atoms стали конкурирующими гипотезами
- `/hd-mavp-router` — если нужен полный оркестрированный аудит