---
id: wiki-2026-0508-decision-theory
title: Decision Theory
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [의사결정 이론, Choice Theory, Rational Choice]
duplicate_of: none
source_trust_level: A
confidence_score: 0.92
verification_status: applied
tags: [decision-theory, expected-utility, bayesian, game-theory, RL]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: python
  framework: scipy/pymc
---

# Decision Theory

## 매 한 줄
> **"매 rational choice = argmax_a E[U(outcome|a)]"**. 매 1944 von Neumann-Morgenstern 의 expected utility axiomatization 부터 매 2026 LLM agent 의 tool-use planning, RLHF reward modeling, 매 autonomous driving 의 risk-sensitive policy 까지 — 매 단일 framework 로 uncertainty 하 행동 선택 의 formalization.

## 매 핵심

### 매 분류
- **Normative**: 매 ideal rational agent 가 어떻게 결정해야 하는가 (EUT, Savage axioms).
- **Descriptive**: 매 humans 가 실제로 어떻게 결정하는가 (prospect theory, bounded rationality).
- **Prescriptive**: 매 humans 가 더 나은 결정을 위해 어떻게 도울 것인가 (decision support systems).

### 매 핵심 도구
- **Expected Utility (EU)**: `EU(a) = Σ P(s) · U(s, a)`.
- **Bayesian Decision Theory**: 매 prior + likelihood → posterior → decision.
- **Minimax / Maximin**: 매 worst-case robustness.
- **Pareto Optimality**: 매 multi-objective tradeoff frontier.
- **Value of Information (VoI)**: 매 추가 데이터 수집의 expected gain.

### 매 응용
1. **RL reward shaping**: 매 PPO/GRPO objective 의 expected return 매개변수화.
2. **A/B test stopping rule**: 매 sequential Bayesian decision (BALD acquisition).
3. **Medical triage**: 매 cost-sensitive classification 의 utility-weighted threshold.
4. **LLM agent tool-use**: 매 ReAct planner 가 매 tool call 의 expected reward 비교.

## 💻 패턴

### Expected Utility 계산
```python
import numpy as np

def expected_utility(action, states, probs, utility_fn):
    """E[U] = Σ P(s|a) · U(s, a)."""
    return sum(p * utility_fn(s, action) for s, p in zip(states, probs))

# Risk-averse: U(x) = log(x), Risk-neutral: U(x) = x
actions = ['invest', 'save']
states = [100, -20]  # outcomes per action
probs = {'invest': [0.6, 0.4], 'save': [1.0, 0.0]}
log_utility = lambda s, a: np.log(s + 1000)  # wealth-based

best = max(actions, key=lambda a: expected_utility(a, states, probs[a], log_utility))
```

### Bayesian Posterior Decision
```python
import pymc as pm

with pm.Model() as model:
    theta = pm.Beta('theta', alpha=2, beta=2)        # prior
    obs = pm.Binomial('obs', n=10, p=theta, observed=7)
    trace = pm.sample(2000, return_inferencedata=True)

posterior = trace.posterior['theta'].values.flatten()
# Decision: launch if P(theta > 0.5) > 0.95
launch = (posterior > 0.5).mean() > 0.95
```

### Minimax Regret
```python
def minimax_regret(payoff_matrix):
    # Regret(a, s) = max_a' payoff(a', s) - payoff(a, s)
    best_per_state = payoff_matrix.max(axis=0)
    regret = best_per_state - payoff_matrix
    max_regret_per_action = regret.max(axis=1)
    return max_regret_per_action.argmin()  # action minimizing max regret
```

### Value of Information
```python
def value_of_information(prior_decision_eu, posterior_decision_eu, info_cost):
    """VoI = E[best decision with info] - E[best decision without info] - cost."""
    return posterior_decision_eu - prior_decision_eu - info_cost
```

### POMDP Belief Update (LLM Agent)
```python
def belief_update(belief, action, observation, transition_fn, obs_fn):
    """b'(s') = η · O(o|s',a) · Σ T(s'|s,a) · b(s)."""
    new_belief = {}
    for s_prime in belief:
        prior = sum(transition_fn(s, a=action, s_p=s_prime) * b
                    for s, b in belief.items())
        new_belief[s_prime] = obs_fn(observation, s_prime, action) * prior
    norm = sum(new_belief.values())
    return {s: v / norm for s, v in new_belief.items()}
```

### Multi-Armed Bandit (Thompson Sampling)
```python
import numpy as np
class ThompsonBandit:
    def __init__(self, n_arms):
        self.alpha = np.ones(n_arms)
        self.beta = np.ones(n_arms)
    def pull(self):
        samples = np.random.beta(self.alpha, self.beta)
        return samples.argmax()
    def update(self, arm, reward):
        self.alpha[arm] += reward
        self.beta[arm] += (1 - reward)
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Probabilities known, utilities clear | Expected Utility maximization |
| Uncertainty about probabilities | Bayesian decision (priors) |
| Adversarial environment | Minimax / Game theory |
| Multi-objective tradeoff | Pareto frontier |
| Sequential with information | POMDP / VoI |
| Online with exploration | Bandit / RL |

**기본값**: 매 Bayesian Expected Utility — 매 priors explicit + posterior update 가능.

## 🔗 Graph
- 부모: [[Probability Theory]]
- 변형: [[Prospect Theory]] · [[POMDP]]
- 응용: [[Reinforcement Learning]] · [[Multi-armed-Bandit-Problem]]
- Adjacent: [[Optimal-Control-Theory]] · [[Entropy in Information Theory|Information Theory]] · [[Risk_Management|Risk-Management]]

## 🤖 LLM 활용
**언제**: 매 agent planner 의 tool selection, 매 RLHF reward design, 매 active learning data acquisition.
**언제 X**: 매 utility function 의 specification 매 impossible 한 multi-stakeholder ethics — 매 voting / negotiation 사용.

## ❌ 안티패턴
- **Naive EU under heavy-tailed risk**: 매 expected value finite 이지만 ruin probability 가 nonzero — 매 Kelly criterion / log-utility 사용.
- **Ignoring Allais paradox**: 매 humans violate independence axiom — 매 prescriptive ≠ descriptive.
- **Probability ≈ frequency only**: 매 Bayesian subjective prob 도 valid — 매 single-event decision 에 frequency 강요 X.
- **Over-precise priors**: 매 unknown unknowns 에 매 epsilon-contamination / robust priors.

## 🧪 검증 / 중복
- Verified (Savage 1954, *Foundations of Statistics*; Kahneman & Tversky 1979 prospect theory; Russell & Norvig *AIMA* 4ed Ch.16-17).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with EU, Bayesian, POMDP, bandit patterns |
