Randomization Adaptive Self-Stabilization

We present a scheme to convert self-stabilizing algorithms that use randomization during and following convergence to self-stabilizing algorithms that use randomization only during convergence. We thus reduce the number of random bits from an infinite number to a bounded number. The scheme is applicable to the cases in which there exits a local predicate for each node, such that global consistency is implied by the union of the local predicates. We demonstrate our scheme over the token circulation algorithm of Herman and the recent constant time Byzantine self-stabilizing clock synchronization algorithm by Ben-Or, Dolev and Hoch. The application of our scheme results in the first constant time Byzantine self-stabilizing clock synchronization algorithm that uses a bounded number of random bits.

💡 Research Summary

**
The paper addresses a fundamental limitation of many randomized self‑stabilizing distributed algorithms: they continue to consume random bits even after the system has converged to a correct configuration. Generating true randomness is costly, especially in resource‑constrained or security‑sensitive environments, and it is unnecessary once the algorithm has stabilized. To overcome this, the authors introduce the notion of randomization‑adaptive self‑stabilization. An algorithm is randomization‑adaptive if, after reaching a safe configuration, all subsequent suffixes of any execution are legal without any further reliance on randomness.

The core contribution is a generic transformation scheme that converts any adaptable randomized self‑stabilizing algorithm into a randomization‑adaptive one that uses only a bounded number of random bits. The scheme relies on two building blocks: (1) a history‑collection protocol that, in a synchronous network of diameter d, lets every node obtain an exact snapshot of the global state d rounds ago; and (2) a detector that examines this snapshot to decide whether the system is currently in a safe configuration. If the detector reports “unsafe”, the node invokes a random‑bits production protocol and feeds the freshly generated bits to the original algorithm. If the detector reports “safe”, the node supplies a deterministic dummy value (e.g., a vector of ones) instead of random bits. Because the detector eventually returns true forever after convergence, the random‑bits protocol is invoked only a finite number of times, guaranteeing a bounded total random‑bit consumption.

The authors formalize this intuition with lemmas and theorems. Lemma 3.1 shows that once an adaptable algorithm starts from a safe configuration, any random input still leads to a legal execution. Lemma 3.2 proves that, after a finite suffix where all detectors output true, no node uses random bits. Theorem 3.1 then combines these results to establish that the transformed algorithm is indeed randomization‑adaptive and bounded‑random.

To handle Byzantine faults, the paper extends the scheme with an unreliable detector and an atomic random‑bit surrogate. The unreliable detector may temporarily give wrong answers, but once the system stabilizes it eventually notifies all correct nodes that safety has been achieved. When a node’s detector signals “non‑converged”, the surrogate forces every correct node to exchange their locally generated random bits and combine them (e.g., via XOR) into a common random value. This exchange is performed atomically, preventing Byzantine nodes from biasing the result. The surrogate thus supplies randomness only while the system is still unsafe, and ceases once safety is globally recognized.

The paper validates the framework through two case studies.

1. Token Circulation on an Odd Ring (Herman’s Algorithm).
   Herman’s classic randomized token‑circulation protocol ensures that eventually exactly one token (a node holding bit 1) exists and moves around the ring. The authors treat this algorithm as adaptable, apply the history‑based detector, and obtain a deterministic version: after convergence, the token circulates without any further random choices. By interpreting the token holder as a leader, the same transformation yields a deterministic leader‑election algorithm on an odd ring.

2. Constant‑Time Byzantine Clock Synchronization (Ben‑Or, Dolev, Hoch).
   The referenced Byzantine clock‑synchronization algorithm achieves synchronization in constant time but relies on an unbounded stream of random bits. By integrating the Byzantine‑aware transformation (unreliable detector + atomic surrogate), the authors produce the first constant‑time Byzantine self‑stabilizing clock‑synchronization algorithm that uses only a bounded number of random bits. After the clocks are synchronized, the system proceeds deterministically, eliminating the need for further randomness.

The authors compare their work with Rao’s “eventual determinism” approach, noting that Rao’s techniques are problem‑specific, do not address Byzantine settings, and lack a generic transformation framework. In contrast, this paper provides a universal method applicable to any adaptable randomized self‑stabilizing algorithm, together with a robust Byzantine extension.

In summary, the paper delivers a powerful, general-purpose methodology for reducing the randomness requirements of self‑stabilizing distributed algorithms. By coupling precise global‑state snapshots with a simple safety detector, it guarantees that randomness is used only during the convergence phase, after which the algorithm behaves deterministically. The Byzantine extension further ensures that even in the presence of malicious nodes, the system can safely stop consuming random bits once it has stabilized. This advancement opens the door to more efficient, secure, and practical self‑stabilizing protocols across a wide range of distributed computing problems.