2nd/10_Wiki/Topics/AI_and_ML/Hypothesis Tree.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-hypothesis-tree	Hypothesis Tree	10_Wiki/Topics	verified	self	hypothesis tree issue tree MECE McKinsey method structured problem-solving	none	A	0.88	applied	problem-solving consulting mece hypothesis-tree mckinsey		2026-05-10	pending	language applicable_to Methodology 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

@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

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

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

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

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)

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

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

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)

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

## 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

# 매 ❌ 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

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 · 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