2nd/10_Wiki/Topics/AI_and_ML/CAP-Theorem.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-cap-theorem	CAP Theorem & PACELC	10_Wiki/Topics	verified	self	CAP Brewer's theorem PACELC eventual consistency distributed consensus BASE	none	A	0.95	applied	distributed-systems cap-theorem pacelc consistency availability partition-tolerance database raft paxos		2026-05-10	pending	language framework distributed systems theory any

CAP Theorem & PACELC

📌 한 줄 통찰

"매 distributed 의 매 3 중 매 2 만" — Eric Brewer (2000). Consistency + Availability + Partition tolerance — 매 partition 가 inevitable → 매 CP / AP 의 trade-off. 매 modern 의 PACELC 의 보완 — 매 partition 외 의 latency-consistency.

📖 핵심

매 3 property

1. Consistency (C): 매 모든 node 의 같은 data.
2. Availability (A): 매 모든 request 의 매 response.
3. Partition tolerance (P): 매 network split 시 매 동작.

Brewer's theorem

• 매 distributed system 의 매 partition 의 inevitable.
• 매 P 의 force.
• 매 실제 선택 = CP or AP.

CP vs AP

CP (Consistency + Partition tolerance)

• 매 partition 시 매 일부 의 unavailable.
• 매 stale data 의 reject.
• 매 financial / lock / counter.
• 예: HBase, MongoDB (default), Etcd, Zookeeper, Postgres.

AP (Availability + Partition tolerance)

• 매 partition 시 매 stale OK.
• 매 eventual consistency.
• 매 social feed / cart / cache.
• 예: Cassandra, DynamoDB, CouchDB.

매 PACELC (Daniel Abadi 2010)

Partition → A or C; Else → L (latency) or C (consistency).

System	PA / PC	EL / EC
MongoDB	PC (default)	EL
DynamoDB	PA	EL
Cassandra	PA	EL
HBase	PC	EC
Spanner	PC	EC
Postgres (sync replica)	PC	EC
Postgres (async)	PA	EL

Consistency level

Strict / Linearizability

• 매 like 매 single machine.
• 매 expensive (cross-region 의 round trip).

Sequential

• 매 program order.

Causal

• 매 cause-effect 만.

Read-your-writes

• 매 own write 의 read OK.

Eventual

• 매 결국 의 converge.
• 매 weakest 가 매 fastest.

매 BASE (vs ACID)

• BASE = Basically Available, Soft state, Eventual consistency.
• 매 NoSQL 의 paradigm.
• 매 ACID 의 strong vs BASE 의 loose.

매 modern reality

• 매 hybrid: 매 region 별 의 다른 model.
• 매 Spanner: 매 global linearizable (TrueTime API).
• 매 CRDTs: 매 commutative 의 eventual consistency 의 conflict-free.
• 매 Raft / Paxos: 매 majority quorum 의 CP.

매 응용 의 결정

CP 선호

• 매 financial transaction.
• 매 distributed lock.
• 매 counter (unique).
• 매 schema migration.

AP 선호

• 매 social feed.
• 매 product catalog (cache).
• 매 shopping cart.
• 매 click tracking.

매 misconception

• "CP = always consistent": 매 partition 시 의 unavailable.
• "AP = always available": 매 partition 시 만 의 stale.
• "Eventual = OK": 매 conflict resolution 의 critical.
• "P 의 optional": 매 X — 매 distributed 의 P 의 inevitable.

💻 패턴

Eventual consistency (Cassandra)

from cassandra.cluster import Cluster
from cassandra import ConsistencyLevel

session = Cluster(['127.0.0.1']).connect('mykeyspace')

# 매 write — 매 ANY (가장 weak)
write_stmt = session.prepare("INSERT INTO users (id, name) VALUES (?, ?)")
write_stmt.consistency_level = ConsistencyLevel.LOCAL_ONE
session.execute(write_stmt, [user_id, name])

# 매 read — 매 strong consistency 가 필요 시 의 QUORUM
read_stmt = session.prepare("SELECT * FROM users WHERE id = ?")
read_stmt.consistency_level = ConsistencyLevel.LOCAL_QUORUM
result = session.execute(read_stmt, [user_id])

# 매 quorum write + quorum read = 매 strong consistency.

Raft consensus (etcd)

import etcd3

client = etcd3.client(host='localhost', port=2379)

# 매 strong consistency 의 write
client.put('/config/feature_flag', 'true')

# 매 read (sequential)
value, _ = client.get('/config/feature_flag')

# 매 distributed lock (CP)
lock = client.lock('my-resource', ttl=10)
if lock.acquire():
    try: do_critical_section()
    finally: lock.release()

CRDT (eventual + conflict-free)

class LWWRegister:
    """매 Last-Write-Wins Register."""
    def __init__(self):
        self.value = None
        self.timestamp = 0
    
    def set(self, value, timestamp):
        if timestamp > self.timestamp:
            self.value = value
            self.timestamp = timestamp
    
    def merge(self, other):
        if other.timestamp > self.timestamp:
            self.value = other.value
            self.timestamp = other.timestamp

class GCounter:
    """매 Grow-only counter."""
    def __init__(self, node_id):
        self.node_id = node_id
        self.counts = {}
    
    def increment(self):
        self.counts[self.node_id] = self.counts.get(self.node_id, 0) + 1
    
    def value(self):
        return sum(self.counts.values())
    
    def merge(self, other):
        for nid, cnt in other.counts.items():
            self.counts[nid] = max(self.counts.get(nid, 0), cnt)

Read-your-writes (sticky session)

class StickyClient:
    def __init__(self, replica_pool):
        self.pool = replica_pool
        self.last_write_replica = None
    
    def write(self, key, value):
        # 매 write 의 leader
        leader = self.pool.leader()
        leader.write(key, value)
        self.last_write_replica = leader
    
    def read(self, key):
        # 매 own write 의 read 시 matched replica
        if self.last_write_replica:
            return self.last_write_replica.read(key)
        # 매 else any
        return self.pool.any().read(key)

Quorum (Cassandra 식)

# 매 R + W > N → 매 strong consistency
N = 3  # 매 replica
W = 2  # 매 write quorum
R = 2  # 매 read quorum

# 매 R + W = 4 > N = 3 → 매 latest 의 read 보장.

Multi-region with Spanner-like

-- 매 Spanner: 매 global strong consistency
BEGIN TRANSACTION;
INSERT INTO orders (id, user_id, total) VALUES (uuid(), 123, 100);
UPDATE inventory SET count = count - 1 WHERE id = 'item-456';
COMMIT;

-- 매 TrueTime 의 timestamp 의 ordering 의 보장.

Hybrid: CP critical + AP rest

class HybridStore:
    def __init__(self):
        self.cp_store = etcd3.client()      # 매 CP
        self.ap_store = redis.Redis()       # 매 AP cache
    
    def get(self, key, strict=False):
        if strict: return self.cp_store.get(key)[0]
        cached = self.ap_store.get(key)
        if cached: return cached
        value = self.cp_store.get(key)[0]
        self.ap_store.set(key, value, ex=60)
        return value
    
    def set(self, key, value):
        self.cp_store.put(key, value)
        self.ap_store.delete(key)  # 매 invalidate

🤔 결정 기준

상황	Choice
Money / lock	CP (Spanner, etcd, Postgres)
Social feed	AP (Cassandra, DynamoDB)
Cart	AP + CRDT
Counter	CP (Spanner) or CRDT
Search	AP + eventual
Config	CP (etcd, Zookeeper)
Cache	AP + TTL
Multi-region linear	Spanner / FoundationDB

기본값: CP for state-of-record, AP for derived / cache.

🔗 Graph

• 부모: Distributed-Systems · Database-Theory
• 변형: PACELC · BASE · ACID
• 응용: Raft · Paxos · CRDT · Quorum · Spanner
• DB: Cassandra · DynamoDB · MongoDB · Postgres · Etcd
• Adjacent: Availability-and-Persistence · Eventual-Consistency · Linearizability

🤖 LLM 활용

언제: 매 distributed system design. 매 database choice. 매 multi-region architecture. 매 consistency model decision. 언제 X: 매 single-server (no partition).

❌ 안티패턴

• "매 모든 의 want": 매 impossible — 매 trade-off 의 필요.
• AP 의 financial: 매 lost update / double spend.
• CP 의 social feed: 매 partition 시 의 user-facing fail.
• Strict 의 default: 매 unnecessary expensive.
• No conflict resolution (eventual): 매 silent loss.
• PACELC 무시: 매 happy path latency 의 ignore.
• Cross-region sync replication: 매 latency 의 disaster.

🧪 검증 / 중복

• Verified (Brewer 2000, Gilbert-Lynch 2002 proof, Abadi PACELC).
• 신뢰도 A.
• Related: Availability-and-Persistence · Database-Theory · Raft · CRDT · Architecture-Styles.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — CP/AP + PACELC + 매 Cassandra / etcd / CRDT / hybrid code