---
id: wiki-2026-0508-hypothesis-tree
title: Hypothesis Tree
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [hypothesis tree, issue tree, MECE, McKinsey method, structured problem-solving]
duplicate_of: none
source_trust_level: A
confidence_score: 0.88
verification_status: applied
tags: [problem-solving, consulting, mece, hypothesis-tree, mckinsey]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Methodology
  applicable_to: [Consulting, Strategy, Analysis]
---

# Hypothesis Tree (Issue Tree)

## 매 한 줄
> **"매 problem 의 의 의 hypothesis 의 hierarchy 의 의 의 의 decompose"**. McKinsey-style. 매 MECE (Mutually Exclusive, Collectively Exhaustive). 매 응용: 매 strategy consulting, 매 root cause analysis. 매 modern: 매 LLM-aided.

## 매 핵심

### 매 properties
- **MECE**: 매 매 branch 의 overlap X + 매 합 의 complete.
- **Hypothesis-driven**: 매 each leaf = testable claim.
- **Top-down**: 매 root = problem.
- **Action-oriented**: 매 leaf → 매 specific test/action.

### 매 응용
1. Strategy / consulting.
2. Root cause analysis.
3. Investment thesis.
4. Product diagnosis.
5. Research hypothesis structuring.

## 💻 패턴

### Tree structure
```python
@dataclass
class Hypothesis:
    statement: str
    children: list  # 매 sub-hypotheses
    evidence_for: list = None
    evidence_against: list = None
    test_plan: str = None
    status: str = 'unverified'  # verified / refuted / pending

# 매 example: Why is revenue declining?
revenue_decline = Hypothesis(
    'Revenue is declining',
    children=[
        Hypothesis('Price decreased', children=[
            Hypothesis('Discount strategy too aggressive', ...),
            Hypothesis('Competitive pricing pressure', ...),
        ]),
        Hypothesis('Volume decreased', children=[
            Hypothesis('Lost customers', children=[
                Hypothesis('Churn ↑', ...),
                Hypothesis('Acquisition ↓', ...),
            ]),
            Hypothesis('Lower order frequency', ...),
        ]),
        Hypothesis('Mix changed', children=[
            Hypothesis('Lower-margin products ↑', ...),
        ]),
    ],
)
```

### MECE check
```python
def is_mece(parent_set, children_sets):
    """매 mutually exclusive + collectively exhaustive."""
    # 매 ME: 매 두 child 의 intersection 의 empty
    for i, a in enumerate(children_sets):
        for b in children_sets[i+1:]:
            if a & b: return False, 'overlap'
    # 매 CE: 매 union = parent
    union = set().union(*children_sets)
    if union != parent_set: return False, 'incomplete'
    return True, 'mece'
```

### 80/20 prioritization
```python
def prioritize_hypotheses(hypotheses):
    """매 likelihood × impact."""
    scored = [(h.likelihood * h.impact, h) for h in hypotheses]
    return sorted(scored, key=lambda x: -x[0])
```

### Test plan per leaf
```python
def design_test(hypothesis):
    return {
        'hypothesis': hypothesis.statement,
        'data_needed': identify_data(hypothesis),
        'analysis': pick_method(hypothesis),
        'success_criteria': what_supports(hypothesis),
        'time_estimate': estimate_hours(hypothesis),
    }
```

### LLM-aided decomposition
```python
def llm_decompose(problem, llm, depth=3):
    if depth == 0: return Hypothesis(problem, [])
    
    prompt = f"""Decompose into 2-4 MECE sub-hypotheses:

Problem: {problem}

Output as JSON list. Each must be:
- Specific
- Testable
- Mutually exclusive with siblings
- Together exhaustive of parent"""
    
    sub_hypotheses = json.loads(llm.generate(prompt))
    return Hypothesis(problem, [llm_decompose(s, llm, depth - 1) for s in sub_hypotheses])
```

### Update tree (after evidence)
```python
def update_status(hypothesis, evidence):
    if evidence.refutes(hypothesis):
        hypothesis.status = 'refuted'
        # 매 prune children (no need to test)
    elif evidence.supports(hypothesis):
        hypothesis.evidence_for.append(evidence)
        if all(c.status == 'verified' for c in hypothesis.children):
            hypothesis.status = 'verified'
```

### 5 Why integration
```python
def append_5why(symptom, llm):
    """매 hypothesis tree root 의 의 5-why."""
    chain = [symptom]
    for _ in range(5):
        chain.append(llm.generate(f'Why: {chain[-1]}? Single root cause.'))
    return chain
```

### Decision tree visualization
```python
def render_tree(hypothesis, indent=0):
    status_icon = {'verified': '✓', 'refuted': '✗', 'pending': '?', 'unverified': '○'}
    print(' ' * indent + f'{status_icon[hypothesis.status]} {hypothesis.statement}')
    for c in hypothesis.children:
        render_tree(c, indent + 2)
```

### Pyramid Principle (Minto)
```python
def pyramid_summary(tree):
    """매 매 root insight 의 main message + 3 supporting."""
    return {
        'main': tree.synthesize(),
        'supporting': [c.synthesize() for c in tree.children[:3]],
        'evidence': [c.evidence_for for c in tree.children[:3]],
    }
```

### Communication template
```markdown
## Diagnosis (top-down)

**Main finding**: <1-line synthesis>

### Supporting points (MECE)
1. <Branch 1 finding> — evidence: ...
2. <Branch 2 finding> — evidence: ...
3. <Branch 3 finding> — evidence: ...

### Recommendations
- <Action from finding 1>
- <Action from finding 2>
```

### Hypothesis vs question
```python
# 매 ❌ Question only
"Is the price too high?"

# 매 ✅ Hypothesis (testable)
"Price increase of 10% in Q3 caused 15% volume drop because elasticity is -1.5"
```

### Saturation criterion
```python
def is_saturated(branch):
    """매 매 더 decompose 의 의 의 의 informative X."""
    if branch.depth > 4: return True
    if all(c.is_directly_testable() for c in branch.children): return True
    return False
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Strategic problem | Hypothesis tree (top-down) |
| Root cause | 5 Why → tree |
| Communication | Pyramid (Minto) |
| Diagnosis | MECE branches |
| Quick | LLM-aided initial decompose |

**기본값**: 매 LLM 의 의 의 initial decompose + 매 MECE check + 매 80/20 prioritize + 매 test plan per leaf + 매 Pyramid summary.

## 🔗 Graph
- 부모: [[Problem_Solving|Problem-Solving]] · [[Strategy]]
- 변형: [[MECE]] · [[Issue-Tree]] · [[Pyramid-Principle]]
- 응용: [[Root-Cause-Analysis]] · [[Strategy-Consulting]]
- Adjacent: [[Innovative Problem Solving]] · [[Iterative Prompting]]

## 🤖 LLM 활용
**언제**: 매 strategic / diagnostic. 매 communication.
**언제 X**: 매 narrow optimization.

## ❌ 안티패턴
- **Non-MECE**: 매 overlap or gap.
- **Question instead of hypothesis**: 매 not testable.
- **Too deep**: 매 over-decompose.
- **No evidence loop**: 매 stale.

## 🧪 검증 / 중복
- Verified (McKinsey methodology, Minto Pyramid Principle).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — tree + 매 MECE / 80/20 / Pyramid / LLM decompose code |
