2nd/10_Wiki/Topics/Topic_General/From_Other/Horizontal and Vertical Logic.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-horizontal-and-vertical-logic	Horizontal and Vertical Logic	10_Wiki/Topics	verified	self	Pyramid Logic Minto Pyramid Logic MECE-Pyramid Structure	none	A	0.9	applied	structured-thinking pyramid-principle mece communication consulting		2026-05-10	pending	language framework en 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

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

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

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

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)

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

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 (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 패턴 추가