Linearizable Implementations Do Not Suffice for Randomized Distributed Computation

Linearizability is the gold standard among algorithm designers for deducing the correctness of a distributed algorithm using implemented shared objects from the correctness of the corresponding algorithm using atomic versions of the same objects. We show that linearizability does not suffice for this purpose when processes can exploit randomization, and we discuss the existence of alternative correctness conditions.

💡 Research Summary

The paper challenges a long‑standing assumption in distributed computing: that linearizability of shared‑object implementations is sufficient to transfer correctness proofs from an algorithm that uses atomic objects to one that uses their linearizable implementations. While this transfer works flawlessly for deterministic algorithms, the authors demonstrate that it breaks down when processes employ randomization.

The authors begin by recalling the definition of linearizability – each operation must appear to take effect instantaneously at some point between its invocation and response, preserving the real‑time order of non‑overlapping operations. This property allows designers to reason about a system as if all shared objects were truly atomic, even though the underlying implementation may involve multiple low‑level steps.

The crux of the paper is a constructive counter‑example. They consider a simple randomized protocol in which two processes each generate a local random bit and then insert that bit into a shared queue. The queue is implemented using a linearizable algorithm that internally performs a read‑modify‑write sequence. Because each low‑level step is visible to the scheduler, an adversarial (or even merely “unlucky”) scheduler can decide when each process’s enqueue operation takes effect. By carefully ordering these internal steps, the scheduler can bias which random bit becomes the first element of the queue, thereby altering the probability distribution of the protocol’s final outcome. In the abstract atomic‑queue model, the two bits would be equally likely to appear first, but under the linearizable implementation the adversary can force a deterministic outcome with non‑negligible probability. This shows that linearizability does not preserve the probabilistic behavior of randomized algorithms.

To address this gap, the paper introduces strong linearizability, a stricter correctness condition originally proposed for deterministic settings but here shown to be sufficient for randomized computation as well. Strong linearizability requires that there exists a single linearization order that is consistent across all possible executions, regardless of the scheduler’s choices, and that this order respects the original random choices of the processes. In other words, the implementation must not expose internal timing information that could be used to correlate or manipulate the random bits. The authors prove that any strongly linearizable implementation guarantees that the distribution of outcomes of the randomized algorithm is identical to that obtained with truly atomic objects.

The authors also survey alternative notions that have appeared in the literature, such as sequential linearizability and probabilistic linearizability. Sequential linearizability, while preserving a global order, still allows the scheduler to influence the timing of internal steps and thus can be subverted by randomization. Probabilistic linearizability attempts to reason about expected values but fails to protect against worst‑case adversarial schedules, which are precisely the threat model considered in many distributed systems (e.g., Byzantine or crash‑fault tolerant environments). Consequently, the paper argues that strong linearizability is the most robust and practically relevant condition for randomized distributed algorithms.

Finally, the paper discusses the implications for real‑world systems. Many randomized protocols—randomized consensus (e.g., Randomized Paxos), lock‑free data structures, and sharding mechanisms that rely on random hash functions—assume that the underlying shared objects behave atomically. If those objects are only linearizable, an adversarial network delay or scheduler could skew the randomness, leading to degraded performance, loss of liveness guarantees, or even safety violations. The authors recommend that system designers either (1) verify strong linearizability of the primitives they employ, (2) use cryptographic techniques (e.g., secret sharing of random bits) to hide randomness from the scheduler, or (3) redesign protocols to be tolerant of the weaker guarantees.

In summary, the paper establishes that linearizability alone is insufficient for preserving the correctness of randomized distributed computations, introduces strong linearizability as a sufficient alternative, evaluates other proposed relaxations, and outlines concrete design guidelines for building robust randomized systems.