The Queue Was Never Empty
Shortest-seek disk scheduling has a clean optimality proof. Given the head's current position and a pending request, moving to the nearest one first minimizes total travel. The proof is correct. It is also almost never the situation the algorithm actually runs in.
The proof works because it treats the request as isolated: one head, one target, nothing else pending. Extend it to a real disk under real load and the picture changes. Requests keep arriving while the head is moving. If the scheduler always jumps to whatever's nearest, a request sitting far from the current position can lose out over and over to newer requests that happen to land closer. Nothing about the algorithm changed. The condition its optimality depended on, a queue you can treat as fixed and small, stopped holding.
The elevator algorithm, the boring one that just sweeps a direction and reverses at the end, doesn't try to be locally optimal at all. It picks up whatever's on the way and refuses to backtrack for something closer. Against a single request it's obviously worse than always taking the shortest seek. Against a saturated system it wins, because it bounds the worst case: nothing waits longer than one full sweep. It gives up cleverness and buys a guarantee instead, and under sustained load the guarantee is worth more than the marginal savings the clever version was proven to deliver.
Nobody re-derives the optimality proof for the busy case, because the busy case is exactly where you stop having room to prove things and start needing things that fail predictably instead of optimally. The theorem doesn't get retracted. It just stops describing the situation anyone is in, and the label "optimal" keeps riding along on a result that only holds in a state the system no longer visits.
The same swap happens with latency, at the metric level instead of the algorithm level. A system tuned against mean latency is provably, measurably faster on average, and the tuning is real. Mean latency is also, structurally, the empty-queue proof again: it treats every request as an independent draw, worth the same as every other, with no memory of what happened just before it. Nobody experiences the mean. Each person experiences their own draw, one time, and the traffic producing that draw never stops arriving.
Under load, a slow request doesn't stay isolated the way the mean assumes it does. It holds a connection, a lock, a thread pulled from a fixed pool, and whatever queues up behind it inherits the delay before it even starts. The tail isn't noise scattered around the average, it's backlog with a memory of what caused it. Averaging over requests erases exactly the correlation that produced the backlog, the same way the shortest-seek proof erases the arrivals that would have made greediness a liability.
You can optimize the mean for a long time without noticing, because the mean keeps going down and the dashboard keeps looking fine. The people stuck in the tail are not a rounding error the average failed to smooth out. They're the group the optimization was never actually about, because the model it was proven against didn't have a queue in it at all.
A theorem is a claim about a world that holds still long enough to check it. Production doesn't hold still, mostly because the theorem's own success is what fills the queue back up.