---
id: wiki-2026-0508-economics-of-information
title: Economics of Information
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [information economics, asymmetric information, signaling, screening, market for lemons]
duplicate_of: none
source_trust_level: A
confidence_score: 0.93
verification_status: applied
tags: [economics, information, asymmetric, signaling, screening, akerlof, mechanism-design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Economics / Game Theory
  applicable_to: [Mechanism Design, ML Markets, Pricing, Insurance]
---

# Economics of Information

## 매 한 줄
> **"매 information 의 asymmetric 가 의 market 의 fail"**. Akerlof 'Market for Lemons' (1970), Spence signaling, Stiglitz screening — 2001 Nobel. 매 modern: 매 platform economics + 매 ML markets + 매 LLM trust.

## 매 핵심

### 매 information asymmetry
- **Adverse selection**: 매 hidden type (insurance).
- **Moral hazard**: 매 hidden action.
- **Signaling** (Spence): 매 informed party 의 reveal.
- **Screening** (Stiglitz): 매 uninformed party 의 elicit.

### 매 famous
- **Akerlof Lemons**: 매 used car.
- **Spence Education**: 매 degree as signal.
- **Rothschild-Stiglitz Insurance**.
- **Mechanism Design** (Hurwicz, Maskin, Myerson).

### 매 응용
1. **Insurance**: 매 deductible (screen).
2. **Job market**: 매 degree, certification.
3. **Online review**: 매 reputation.
4. **E-commerce**: 매 warranty, return.
5. **Search ad**: 매 quality score.
6. **Auction**: 매 VCG.
7. **ML / LLM**: 매 calibration as signal.

### 매 modern AI implication
- **LLM trust**: 매 source attribution = signal.
- **Output verification**: 매 buyer of AI = lemon problem.
- **AI labor market**: 매 model card = certificate.
- **Data markets**: 매 quality opacity.

## 💻 패턴

### Adverse selection (Lemons model)
```python
import numpy as np

def lemons_market(qualities, buyer_willingness_factor=1.5):
    """매 Akerlof. 매 quality 의 sellers 의 sort."""
    avg_q = qualities.mean()
    buyer_p = buyer_willingness_factor * avg_q
    sellers_in_market = qualities[qualities * 1.0 <= buyer_p]
    
    if len(sellers_in_market) < len(qualities):
        return lemons_market(sellers_in_market, buyer_willingness_factor)
    return sellers_in_market, buyer_p
```

### Spence signaling (education)
```python
def signaling_equilibrium(types, signal_cost_high, signal_cost_low, wage_high, wage_low):
    """매 high type 의 separate?"""
    # 매 high type signal: 매 wage_high - signal_cost_high > wage_low
    high_signals = wage_high - signal_cost_high > wage_low
    # 매 low type 의 NOT signal: 매 wage_high - signal_cost_low < wage_low
    low_doesnt = wage_high - signal_cost_low < wage_low
    return high_signals and low_doesnt
```

### Screening (insurance contract)
```python
def screen_high_low(premium_high, deductible_high, premium_low, deductible_low,
                    p_loss_high, p_loss_low, loss):
    """매 high-risk 매 contract 1, low-risk 매 contract 2 의 prefer?"""
    # 매 high-risk utility 의 contract 1: -premium - p * deductible
    u_high_1 = -premium_high - p_loss_high * deductible_high
    u_high_2 = -premium_low - p_loss_high * deductible_low
    u_low_1 = -premium_high - p_loss_low * deductible_high
    u_low_2 = -premium_low - p_loss_low * deductible_low
    return u_high_1 > u_high_2 and u_low_2 > u_low_1
```

### Vickrey (second-price) auction
```python
def vickrey_auction(bids):
    """매 truthful — 매 dominant strategy."""
    sorted_bids = sorted(bids.items(), key=lambda x: -x[1])
    winner = sorted_bids[0][0]
    price = sorted_bids[1][1]  # 매 second highest
    return winner, price
```

### VCG mechanism (multi-item)
```python
def vcg(bids, allocation_fn):
    """매 generalized truthful auction."""
    welfare_with = allocation_fn(bids)
    payments = {}
    for bidder in bids:
        bids_without = {k: v for k, v in bids.items() if k != bidder}
        welfare_without = allocation_fn(bids_without)
        # 매 externality
        payments[bidder] = welfare_without - (welfare_with - bids[bidder])
    return payments
```

### Reputation system (eBay-style)
```python
class Reputation:
    def __init__(self):
        self.history = []
    
    def add_review(self, score, weight=1):
        self.history.append((score, weight, datetime.now()))
    
    def score(self, decay_days=365):
        weighted = []
        for s, w, t in self.history:
            age = (datetime.now() - t).days
            decay = 0.5 ** (age / decay_days)
            weighted.append((s * w * decay, w * decay))
        if not weighted: return None
        return sum(s for s, _ in weighted) / sum(w for _, w in weighted)
```

### Quality score (search ad)
```python
def ad_rank(bid, expected_ctr, ad_quality, landing_quality):
    """매 Google AdWords-style."""
    return bid * (expected_ctr * ad_quality * landing_quality)
```

### Moral hazard (deductible)
```python
def optimal_deductible(p_loss, loss, risk_aversion, monitoring_cost):
    """매 trade-off: 매 risk-share vs incentive."""
    # 매 higher deductible → 매 less moral hazard
    return min(loss, monitoring_cost / risk_aversion / p_loss)
```

### Cheap talk (Crawford-Sobel)
```python
def cheap_talk_eq(preferences_aligned):
    """매 sender / receiver 의 align 매 babbling X."""
    if preferences_aligned > 0.7:
        return 'full_revelation'
    if preferences_aligned > 0.3:
        return 'partial_pooling'
    return 'babbling_eq'
```

### LLM as expert with skin in game
```python
def llm_with_skin(llm, claim, stakes):
    """매 hallucination cost 의 internalize."""
    confidence = llm.estimate_confidence(claim)
    if confidence * stakes > THRESHOLD:
        return claim
    return f"I'm not confident enough — uncertainty {1 - confidence:.2f}"
```

### Information cascade (herd)
```python
def cascade_decision(public_signals, private_signal):
    """매 Bikhchandani 1992."""
    public_majority = sum(public_signals) / len(public_signals) > 0.5
    if abs(sum(public_signals) - len(public_signals) / 2) > 2:
        return public_majority  # 매 follow herd
    return private_signal  # 매 own info dominates
```

### Provenance / certificate (C2PA economics)
```python
def value_of_provenance(verified_chain, market_premium=0.1):
    """매 verified content 의 market premium."""
    if verified_chain.is_complete():
        return market_premium
    return 0
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Hidden type | Screening menu |
| Hidden action | Incentive / monitor |
| Multi-bidder | VCG / Vickrey |
| Reputation matters | Persistent ID + reviews |
| Cheap talk | Verifiable claim |
| AI output trust | Source attribution + cert |

**기본값**: 매 mechanism design 의 incentive-compatible + 매 truthful elicitation + 매 reputation persistence + 매 verifiable signal.

## 🔗 Graph
- 변형: [[Signaling]]
- Adjacent: [[Behavioral-Economics]] · [[Information_Theory|Information-Theory]]

## 🤖 LLM 활용
**언제**: 매 marketplace design. 매 incentive system. 매 AI trust.
**언제 X**: 매 perfect-info commodity.

## ❌ 안티패턴
- **Ignore information asymmetry**: 매 lemons collapse.
- **Untruthful auction (1st price hide info)**: 매 strategic gaming.
- **No reputation persistence**: 매 short-term cheating.
- **Cheap talk 의 trust**: 매 babbling.
- **No skin-in-game for AI**: 매 hallucinate freely.

## 🧪 검증 / 중복
- Verified (Akerlof 1970, Spence 1973, Stiglitz 1976, Myerson Mechanism Design).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-04-20 | Auto-reinforced |
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — asymmetric + 매 lemons / signaling / VCG / reputation / cheap talk code |