2nd/10_Wiki/Topics/AI_and_ML/Economics-of-Information.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-economics-of-information	Economics of Information	10_Wiki/Topics	verified	self	information economics asymmetric information signaling screening market for lemons	none	A	0.93	applied	economics information asymmetric signaling screening akerlof mechanism-design		2026-05-10	pending	language applicable_to Economics / Game Theory 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)

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)

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)

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

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)

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)

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)

def ad_rank(bid, expected_ctr, ad_quality, landing_quality):
    """매 Google AdWords-style."""
    return bid * (expected_ctr * ad_quality * landing_quality)

Moral hazard (deductible)

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)

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

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)

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)

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

🤖 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