Distributed system models & failure modes

Six messages, all sent at slightly different times, all arriving with genuinely different delays. Drag Δ down and watch some of them start to "exceed the bound" — the same six messages, but now they no longer fit any single promise about how long you might have to wait.

A system model is an assumption about message delay, not a fact about the network. The synchronous model assumes a known bound $\Delta$ on every message's delay; the asynchronous model assumes no such bound exists at all.

• $m$ — a single message, with a known send time and delivery time.
• $\text{delay}(m)$ — how long $m$ took to arrive: delivered time minus sent time.
• $\Delta$ — the bound the synchronous model promises no message will exceed.

A node failure is a separate axis entirely — not about timing, but about what a node does when it's supposed to speak:

1. Crash

   The node sends nothing further to anyone — total silence, forever.
2. Omission

   The node sends the correct value to some peers, but silently drops it for others.
3. Byzantine

   The node sends different peers conflicting values (or lies to everyone consistently) — behavior that can't be explained by silence or a dropped packet alone.

4. Correct

   Anything reachable that isn't one of the above: every peer got exactly what was expected.

The top readout tracks $\Delta_{\min} = \max_m \text{delay}(m)$ — the smallest bound that actually makes this round synchronous. Below it, step through each node's round log and watch classifyFailure name exactly what went wrong, straight from what it was expected to send versus what it actually sent.

The six messages have delays 2, 9, 3, 3, 5, 3 (in MESSAGES order).

1. Find the bottleneck

   The largest delay is 9 (A → C). No bound smaller than 9 can call this round synchronous — one message alone would violate it.

2. Confirm the minimum bound

   $$\Delta_{\min} = \max(2, 9, 3, 3, 5, 3) = 9$$

   At $\Delta = 9$, every message qualifies. At $\Delta = 8$, A → C alone breaks the promise.

3. Now the four round logs

   • A sent every peer exactly what was expected → correct
   • B sent nothing at all → crash
   • C sent the right value to A and B but never reached D → omission
   • D told B a different value (5) than it told A and C (4) → byzantine, even though D never went silent