echd — Echo on Encore · E0.2

The Impossibility, Owned

The theorem is short, the proof is two writes a partition makes indistinguishable — and owning it means reading it as a price list, not a wall.

Vision · real substrate

echd speaks in the present tense over a build ladder. Every module, verb, key, and port named on this page is real; the composition into one standing platform is the vision the ladder builds.

§1

The module

echd.course.md §2–§3 · Gilbert & Lynch

Two words carry the theorem. Consistency is a safety property — nothing bad ever happens; every response sent to a client is correct. Availability is a liveness property — eventually something good happens; every request eventually receives a response. The CAP theorem is one instance of the oldest fact in distributed computing: in an unreliable system, safety and liveness cannot both be guaranteed. The service under proof is deliberately small — one atomic read/write register — because if the impossibility holds for a register, it holds for everything richer built above one.

The proof fits in a paragraph. Partition the servers into {p1} and {p2 … pn} and lose every message between the halves. A client writes v1 to p1; p1 acknowledges. In a second execution the client writes v2 instead; p1 acknowledges. Now a client reads from p2 — and from p2's side of the partition the two executions are byte-for-byte identical. Wait forever and availability is gone; answer and the answer risks being wrong. The paper sharpens it further: with asynchronous delivery, a long-enough delay is indistinguishable from a partition, so consistency cannot be rescued even on a network that never actually parts. Owned, the theorem stops forbidding and starts pricing: every tier of this platform pays on one side or the other, on purpose, and the next module is the price list.

§2

The proof

hover a step

Two writes, one partition · the whole proof in one frame · hover to read

Two writes — the setup. In execution A the client writes v1 to p1 and is acknowledged; in execution B it writes v2. Both are legitimate histories of a correct register — the trap is that only p1's side knows which one happened.

The partition — and its ghost. Every message between the halves is lost. The sharper clause: under asynchrony a sufficiently late message is indistinguishable from a lost one — so the dilemma arrives even on networks that never actually part. Delay is a partition you cannot rule out.

The read — indistinguishability. A client asks p2 for the register. From p2's side of the cut, execution A and execution B are byte-for-byte the same world. No amount of waiting changes that; the information needed to answer correctly is on the far side of the partition.

The choice — the menu begins. Wait forever and the register is consistent but not available; answer and it is available but possibly wrong. The theorem prices these two seats — and the platform of this course buys both, tier by tier: the ledger sits down on the left, the cache on the right, each on purpose.

Hover or focus a step to read it; click to pin. Without scripting, all four read in sequence.

§3