2nd/10_Wiki/Topics/AI_and_ML/Bounded_Rationality.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-bounded-rationality	Bounded Rationality	10_Wiki/Topics	verified	self	제한적 합리성 satisficing Herbert Simon heuristic ecological rationality fast and frugal	none	A	0.92	applied	decision-theory behavioral-economics simon satisficing heuristic cognitive-limit ai-decision		2026-05-10	pending	language applicable_to decision theory Agent Design Decision Systems Heuristic Algorithms

Bounded Rationality

📌 한 줄 통찰

"매 perfect optimization 의 X — 매 'good enough' 의 satisfice". Herbert Simon (1955) 의 Nobel-winning concept. 매 cognitive limit + 매 information limit + 매 time limit. 매 heuristic 의 not-irrational 가, 매 적응적. 매 modern AI agent 의 design principle.

📖 핵심

매 3 limit (Simon)

1. Limited information: 매 모든 의 X.
2. Cognitive limits: 매 brain capacity.
3. Time pressure: 매 deadline.

→ 매 "rational man" 의 fiction.

Satisficing (Simon's term)

• 매 "satisfy + suffice".
• 매 enumerate 의 X — 매 첫 매 acceptable.
• 매 aspiration level 의 set.
• 매 search 의 stop.

vs Optimization

Optimization	Satisficing
매 모든 alternative	매 sequential evaluation
매 perfect	매 good enough
매 unrealistic	매 realistic
매 expensive	매 cheap

매 Gigerenzer 의 Fast & Frugal

• 매 simple heuristic 의 complex model 의 outperform.
• 매 ecological rationality.
• 매 "less is more".

Take-The-Best

• 매 cue 의 importance order.
• 매 first discriminating cue 의 stop.

Recognition heuristic

• 매 "I recognize A but not B" → "A is bigger".
• 매 ignorance 의 leverage.

Tallying

• 매 매 cue 의 vote (no weight).
• 매 robust.

매 Tversky-Kahneman 의 heuristic + bias

• Availability: 매 recent / vivid 의 over-weight.
• Representativeness: 매 stereotype.
• Anchoring: 매 starting point.
• Affect: 매 emotion.

→ 매 Simon 과 의 different 측 (heuristic 의 mostly biased).

매 modern AI 의 적용

Anytime algorithm

• 매 매 시점 의 best-so-far.
• 매 interrupt OK.
• 매 더 길 → 매 better.

Iterative deepening

• 매 incremental search.
• 매 best within budget.

MCTS (Monte Carlo Tree Search)

• 매 simulation budget 의 increase 의 better.
• 매 AlphaGo 의 base.

Bounded planning (POMDP)

• 매 horizon 의 limit.
• 매 receding horizon control.

LLM agent

• 매 ReAct loop 의 step budget.
• 매 thought 의 brief.
• 매 tool 의 limited.

Risk management

• 매 satisficing on cost / quality / time.
• 매 Pareto front.

매 design principle

1. Aspiration level: 매 stopping criterion 의 explicit.
2. Heuristic 의 design: 매 ecological match.
3. Anytime: 매 interrupt 의 robust.
4. Default: 매 safe fallback.
5. Search depth: 매 budget 의 cap.

💻 패턴

Satisficing search

def satisficing_search(candidates, threshold, evaluator):
    """매 첫 매 threshold 의 candidate 의 return."""
    for c in candidates:
        if evaluator(c) >= threshold:
            return c
    return None  # 매 fallback to best-so-far OR raise

# 매 alternative: best-so-far with timeout
def best_so_far(candidates, timeout_sec, evaluator):
    best, best_score = None, float('-inf')
    deadline = time.time() + timeout_sec
    for c in candidates:
        if time.time() > deadline: break
        s = evaluator(c)
        if s > best_score: best, best_score = c, s
    return best

Take-The-Best (Gigerenzer)

def take_the_best(options, cue_validity_order):
    """매 cue 의 order 의 따라 의 first discriminating."""
    for cue in cue_validity_order:
        with_cue = [o for o in options if o[cue]]
        without_cue = [o for o in options if not o[cue]]
        if with_cue and without_cue:
            return random.choice(with_cue)  # 매 cue-positive 의 win
    return random.choice(options)  # 매 fallback

Anytime algorithm (MCTS-like)

class AnytimeMCTS:
    def __init__(self):
        self.root = Node()
    
    def search(self, deadline):
        while time.time() < deadline:
            self.simulate_one()
        return self.root.best_action()
    
    def simulate_one(self):
        # 매 select → expand → simulate → backprop
        ...

Aspiration level (negotiation)

class Negotiator:
    def __init__(self, aspiration=100, reservation=70):
        self.aspiration = aspiration  # 매 target
        self.reservation = reservation  # 매 walk-away
    
    def evaluate(self, offer):
        if offer >= self.aspiration: return 'accept'
        if offer >= self.reservation: return 'consider' 
        return 'reject'

LLM agent budget

class BoundedAgent:
    def __init__(self, max_steps=10, max_tools=5):
        self.max_steps = max_steps
        self.max_tools = max_tools
    
    async def run(self, query):
        for step in range(self.max_steps):
            thought = await self.llm.think(query, history)
            if thought.action == 'final': return thought.answer
            if thought.action == 'tool' and self.tool_count < self.max_tools:
                result = await self.execute_tool(thought)
                history.append(result)
                self.tool_count += 1
            else:
                # 매 satisfice with current
                return self.fallback(query, history)
        return self.fallback(query, history)

→ 매 unbounded thinking 의 X.

Default action (safe fallback)

def safe_action(state):
    """매 unsure 시 의 default."""
    if state.confidence < 0.5: return 'do_nothing'
    if state.risk > 0.8: return 'ask_human'
    return state.best_action

Recognition heuristic (info gap)

def recognition_heuristic(a, b, recognized_set):
    """매 "I recognize A but not B" → A is bigger."""
    in_a, in_b = a in recognized_set, b in recognized_set
    if in_a and not in_b: return a
    if in_b and not in_a: return b
    return None  # 매 둘 다 / 둘 다 X — 매 다른 cue 필요

🤔 결정 기준

상황	Approach
Limited time	Satisficing + aspiration
Limited info	Heuristic (Take-The-Best)
Continuous decision	Anytime
Game / search	MCTS
LLM agent	Step budget + fallback
Critical	Default safe + escalate
Unknown environment	Tallying (robust)

기본값: 매 aspiration level + 매 anytime + 매 default fallback.

🔗 Graph

• 부모: Decision-Theory · Behavioral-Economics · Cognitive-Science
• 변형: Satisficing · Heuristic · Fast-and-Frugal · Ecological-Rationality
• 사상가: Herbert-Simon · Gigerenzer · Tversky-Kahneman
• 응용: MCTS · Anytime-Algorithm · POMDP · Receding-Horizon-Control
• Adjacent: Antifragility · Beliefs · Bayesian-Brain-Hypothesis · Articulateness

🤖 LLM 활용

언제: 매 agent design (budget). 매 search algorithm. 매 negotiation. 매 risk management. 매 fallback design. 언제 X: 매 closed-form optimization (math). 매 critical safety (no satisfice).

❌ 안티패턴

• Optimize 의 unbounded: 매 무한 search.
• No fallback: 매 budget exhausted 시 의 crash.
• Heuristic 의 bias 의 conflate: 매 mostly different.
• 모든 problem 의 satisfice: 매 critical 의 X.
• Anytime 없 의 long-running: 매 interruption 의 lose.
• Aspiration 의 too high: 매 reject only.

🧪 검증 / 중복

• Verified (Simon Nobel lecture, Gigerenzer Simple Heuristics, Kahneman Thinking).
• 신뢰도 A.
• Related: Antifragility · Heuristic · MCTS · Decision-Theory · Beliefs.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Simon + Gigerenzer + 매 satisficing / Take-The-Best / agent budget code