CAP e PACELC: o teorema que define toda arquitetura distribuída

Fintech típica (AI-native, 2026):

┌─────────────────────┐  ┌─────────────────────┐
│  Saldo / Transações │  │  Perfil / Prefs     │
│  Postgres + WAL     │  │  DynamoDB           │
│  sync replica       │  │  eventual           │
│  (CP / EC)          │  │  (AP / EL)          │
└─────────────────────┘  └─────────────────────┘

┌─────────────────────┐  ┌─────────────────────┐
│  Analytics event    │  │  Rate limit counter │
│  Kafka → Clickhouse │  │  Redis (AP)         │
│  (AP / EL)          │  │  sliding window     │
└─────────────────────┘  └─────────────────────┘

┌─────────────────────┐  ┌─────────────────────┐
│  Config / Coord.    │  │  Search / Embeddings│
│  etcd (Raft, CP)    │  │  OpenSearch + vector│
│  (PC / EC)          │  │  (AP / EL)          │
└─────────────────────┘  └─────────────────────┘

# Simulação didática: 2 réplicas, partição, CP vs AP
from dataclasses import dataclass
from typing import Literal

@dataclass
class Replica:
    name: str
    data: dict[str, str]
    partitioned_from: set[str]
    mode: Literal["CP", "AP"]

    def write(self, peers: list["Replica"], key: str, value: str) -> bool:
        if self.mode == "CP":
            reachable = [p for p in peers if p.name not in self.partitioned_from]
            # CP: precisa de maioria (quorum)
            needed = (len(peers) + 1) // 2 + 1
            if len(reachable) + 1 < needed:
                return False                 # indisponível
            self.data[key] = value
            for p in reachable:
                p.data[key] = value
            return True
        else:                                # AP
            self.data[key] = value            # commit local sempre
            for p in peers:
                if p.name not in self.partitioned_from:
                    p.data[key] = value
            return True

a = Replica("A", {}, set(), "CP")
b = Replica("B", {}, set(), "CP")
c = Replica("C", {}, set(), "CP")

# Sem partição — escrita funciona
print(a.write([b, c], "x", "1"))    # True

# Partição: A isolado de B e C
a.partitioned_from = {"B", "C"}
b.partitioned_from = {"A"}
c.partitioned_from = {"A"}

# CP: A isolado não tem quorum → escrita falha
print(a.write([b, c], "x", "2"))    # False (esperado)

# Já em AP, A aceitaria e divergiria; depois resolve (LWW/CRDT/etc)