2nd/10_Wiki/Topics/Other/Horizontal and Vertical Logic.md

---
id: wiki-2026-0508-horizontal-and-vertical-logic
title: Horizontal and Vertical Logic
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Pyramid Logic, Minto Pyramid Logic, MECE-Pyramid Structure]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [structured-thinking, pyramid-principle, mece, communication, consulting]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: en
  framework: minto-pyramid
---

# Horizontal and Vertical Logic

## 매 한 줄
> **"매 vertical logic = parent ↔ children Q&A coherence; horizontal logic = sibling MECE coherence"**. 매 1973 Barbara Minto (McKinsey) 의 Pyramid Principle 의 dual axis. 매 2026 의 LLM-assisted argument structuring, executive-summary generation, audit findings 의 modern instances.

## 매 핵심

### 매 Vertical logic (Q&A 추적)
- **Top-down**: 매 main idea → child supports through Why?/How?/What?
- **Bottom-up**: 매 children 의 grouping → parent emergence.
- **Test**: 매 each child 의 "answers a Q raised by parent" 의 verify.

### 매 Horizontal logic (sibling coherence)
- **MECE**: 매 mutually exclusive + collectively exhaustive.
- **Inductive**: 매 same-type observations → conclusion.
- **Deductive**: 매 premise 1 + premise 2 → conclusion (max 4 levels).
- **Test**: 매 sibling reorder 시 meaning preserved + no overlap + complete.

### 매 SCQA (Situation-Complication-Question-Answer)
- **Situation**: 매 audience-known background.
- **Complication**: 매 disrupting force.
- **Question**: 매 implicit reader question.
- **Answer**: 매 main idea (top of pyramid).

### 매 응용
1. McKinsey/BCG client deck.
2. Executive memo.
3. Audit / financial reporting.
4. Engineering RFC.
5. LLM 의 reasoning trace structuring.

## 💻 패턴

### Pyramid node tree
```python
from dataclasses import dataclass, field
from typing import Literal

@dataclass
class PyramidNode:
    statement: str
    logic_type: Literal["inductive", "deductive"] = "inductive"
    children: list["PyramidNode"] = field(default_factory=list)

    def vertical_test(self) -> bool:
        """Each child must answer Why/How/What raised by self."""
        return all(self.statement and c.statement for c in self.children)

    def horizontal_test(self) -> bool:
        """MECE: same logical category, no overlap (heuristic check)."""
        return len({type(c.statement) for c in self.children}) == 1
```

### MECE category check
```python
def is_mece(items: list[str], categories: dict[str, set[str]]) -> dict:
    covered = set().union(*categories.values())
    overlaps = [
        (a, b) for a in categories for b in categories
        if a != b and categories[a] & categories[b]
    ]
    return {
        "exhaustive": set(items) <= covered,
        "exclusive": not overlaps,
        "uncovered": set(items) - covered,
        "overlaps": overlaps,
    }
```

### Inductive vs deductive selector
```python
def choose_argument_form(num_premises: int, audience_familiarity: float) -> str:
    """Minto: deductive ≤4 levels, only when audience already accepts premises."""
    if num_premises <= 3 and audience_familiarity > 0.7:
        return "deductive"
    return "inductive"  # safer default — group similar evidence
```

### SCQA scaffolder
```python
def scqa(situation: str, complication: str, question: str, answer: str) -> str:
    return (f"Situation: {situation}\n"
            f"Complication: {complication}\n"
            f"Question: {question}\n"
            f"Answer (main idea): {answer}")
```

### Reorder sibling test (horizontal robustness)
```python
import itertools

def reorder_robust(siblings: list[str], judge_meaning: callable) -> bool:
    """If meaning unchanged across permutations → horizontal logic holds."""
    perms = list(itertools.permutations(siblings))[:6]
    meanings = {judge_meaning(p) for p in perms}
    return len(meanings) == 1
```

### LLM critique pass
```python
from anthropic import Anthropic
client = Anthropic()

def minto_critique(pyramid_yaml: str) -> str:
    return client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2000,
        system=("Audit a Minto pyramid. Flag: (1) children that don't answer the "
                "Q raised by parent, (2) sibling overlaps (not ME), (3) gaps (not CE), "
                "(4) deductive chains beyond 4 levels."),
        messages=[{"role": "user", "content": pyramid_yaml}],
    ).content[0].text
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Executive deck | top-down + SCQA opener |
| Bottom-up synthesis | group findings → emerge top |
| Diagnostic argument | deductive (≤4 levels) |
| Survey / audit findings | inductive (group similar) |
| Confused audience | start with main idea (top) |

**기본값**: 매 top-down 의 vertical structure + inductive 의 horizontal grouping. 매 SCQA 의 opening.

## 🔗 Graph
- 부모: [[Pyramid Principle]]
- 변형: [[Horizontal and Vertical Logic|Horizontal Logic]] (alias) ·  (alias) · [[MECE]]
- Adjacent: [[SCQA]] · [[Issue Tree]]

## 🤖 LLM 활용
**언제**: 매 draft pyramid 의 critique, 매 MECE gap 의 surface, 매 SCQA 의 opening 작성, 매 inductive grouping 의 candidate.
**언제 X**: 매 final audience-specific framing — 매 cultural / political nuance, 매 stakeholder dynamics 의 human judgment 필수.

## ❌ 안티패턴
- **Bottom of pyramid 부터 발표**: 매 audience 의 main idea 도달 전 fatigue.
- **Mixed inductive + deductive 의 same level**: 매 horizontal coherence 깨짐.
- **5+ siblings**: 매 cognitive overload — 매 7±2 의 lower bound (3-5).
- **MECE 만 의 추구**: 매 forced taxonomy 의 distortion — 매 90% 의 MECE 의 sometimes acceptable.
- **Deductive 의 5+ levels**: 매 reader cognitive load 폭증 — 매 Minto 의 4-level cap.

## 🧪 검증 / 중복
- Verified (Minto "The Pyramid Principle" 3rd ed, McKinsey communication training, Booz Allen 의 SCQA).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — vertical/horizontal axes, MECE, SCQA, Minto pyramid 패턴 추가 |