2nd/10_Wiki/Topics/Computer_Science_and_Theory/Wicked-Problems.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-wicked-problems	Wicked Problems	10_Wiki/Topics	verified	self	Ill-Defined Problems Complex Systems Problems	none	A	0.85	applied	problem-solving systems-thinking design methodology		2026-05-10	pending	language framework Methodology Systems Thinking

Wicked Problems

매 한 줄

"매 well-defined 의 X 한 problem". Rittel & Webber (1973) "Dilemmas in a General Theory of Planning" — 매 social policy / climate / AI safety / urban planning 의 characterize, 매 2026 AI alignment debate (Claude Opus 4.7 RLHF objective design) 의 textbook example.

매 핵심

매 10가지 특성 (Rittel-Webber)

1. No definitive formulation.
2. No stopping rule (when is it "solved"?).
3. Solutions are good/bad, not true/false.
4. No immediate or ultimate test of solution.
5. Every solution is a "one-shot operation" (no trial-and-error).
6. No enumerable set of potential solutions.
7. Every wicked problem is essentially unique.
8. Every wicked problem is a symptom of another problem.
9. Multiple explanations possible (choice depends on worldview).
10. Planner has no right to be wrong (consequences matter).

매 vs Tame problems

Tame	Wicked
Clear goal	Goal contested
Defined boundary	Diffuse, expanding
Known solution methods	No clear method
Repeatable (chess, sudoku)	One-shot (urban policy)
Right/wrong	Better/worse

매 응용 examples

1. Climate change.
2. Healthcare reform.
3. AI alignment / safety.
4. Homelessness.
5. Education policy.
6. Pandemic response.
7. LLM evaluation (what is "helpful"?).

💻 패턴

Stakeholder mapping

# Power-Interest grid
import matplotlib.pyplot as plt

stakeholders = {
    "Regulators": (9, 8),
    "Users": (3, 9),
    "Engineers": (5, 7),
    "Investors": (8, 5),
    "Public": (2, 6),
}
fig, ax = plt.subplots()
for name, (power, interest) in stakeholders.items():
    ax.scatter(power, interest)
    ax.annotate(name, (power, interest))
ax.set_xlabel("Power"); ax.set_ylabel("Interest")
ax.axhline(5); ax.axvline(5)
# Quadrants: Manage Closely / Keep Satisfied / Keep Informed / Monitor

Causal Loop Diagram (CLD)

Symptom-fix vs root-fix:
   homelessness ↑ → shelter beds ↑ → visible homelessness ↓ (symptomatic)
                                    → root causes unaddressed → homelessness ↑ (R loop)

   homelessness ↑ → housing units ↑ → root addressed → homelessness ↓ (B loop, slow)

Multi-criteria decision analysis (MCDA)

import numpy as np

# Solutions × Criteria matrix
options = ["Tax", "Subsidy", "Regulate", "Invest"]
criteria = ["Equity", "Cost", "Speed", "Acceptance"]
weights = np.array([0.4, 0.2, 0.2, 0.2])
scores = np.array([
    [9, 4, 6, 3],   # Tax
    [7, 3, 8, 8],   # Subsidy
    [8, 7, 4, 5],   # Regulate
    [6, 2, 3, 7],   # Invest
])
ranking = scores @ weights
print(dict(zip(options, ranking)))

Scenario planning

# Build 2x2 scenario matrix on key uncertainties
def scenario_2x2(axis_x, axis_y, scenarios):
    """
    axis_x, axis_y: pairs (low, high) of critical uncertainties
    scenarios: 4 narrative descriptions
    """
    return {
        f"{axis_x[0]} + {axis_y[0]}": scenarios[0],
        f"{axis_x[1]} + {axis_y[0]}": scenarios[1],
        f"{axis_x[0]} + {axis_y[1]}": scenarios[2],
        f"{axis_x[1]} + {axis_y[1]}": scenarios[3],
    }

Argument mapping

# Decompose claim into premises + objections
class ArgumentNode:
    def __init__(self, claim, support=None, attack=None):
        self.claim = claim
        self.support = support or []  # premises
        self.attack = attack or []    # rebuttals

root = ArgumentNode(
    "Ban autonomous weapons",
    support=[
        ArgumentNode("They lack moral judgment"),
        ArgumentNode("Risk of escalation"),
    ],
    attack=[
        ArgumentNode("Defensive use can save lives"),
    ]
)

Adaptive management (Holling)

# Iterate: model → act → monitor → revise
def adaptive_loop(problem, max_iter=10):
    model = initial_model(problem)
    for i in range(max_iter):
        action = decide(model)
        result = act_and_observe(action)
        model = update(model, result)
        if converged(model): break
    return model
# Embraces uncertainty — wicked problems lack closed-form solutions

매 결정 기준

상황	Approach
Single optimal solution exists	Tame — use OR/optimization
Multiple stakeholders, contested goals	Wicked — stakeholder + scenario
Long-time-horizon, uncertain	Adaptive management
Ethics-laden	Argument mapping + deliberation
LLM RLHF reward design	Treat as wicked — pluralistic eval

기본값: Acknowledge wickedness, use stakeholder mapping + MCDA + adaptive iteration; avoid pretending it's tame.

🔗 Graph

• 부모: Problem_Solving · Systems_Thinking
• 응용: AI_Safety_and_Alignment
• Adjacent: Root-Cause-Analysis-RCA · Complex-Adaptive-Systems

🤖 LLM 활용

언제: Policy design, AI safety / alignment problems, multi-stakeholder system design (no objective ground truth), strategy under deep uncertainty. 언제 X: Engineering bug — use RCA. Optimization with clear objective — use OR. Well-specified algorithm — use complexity theory.

❌ 안티패턴

• Treat wicked as tame: 매 wicked problem 의 single-objective optimization 의 reduce → 매 unintended consequences (e.g., Goodhart's law).
• Analysis paralysis: 매 wicked problem 의 wait for "complete" understanding — 매 never come.
• Ignore stakeholders: 매 technocratic top-down 의 wicked problem 의 fail (Robert Moses urban renewal).
• One-shot deployment: 매 ship-and-forget — wicked problems 의 adaptive iteration 의 require.

🧪 검증 / 중복

• Verified (Rittel & Webber 1973 seminal paper, Conklin "Dialogue Mapping" 2005, Snowden "Cynefin").
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Wicked problems with 10 traits, MCDA, scenario, AI alignment angle