Fault-Tolerant Consensus in Unknown and Anonymous Networks

This paper investigates under which conditions information can be reliably shared and consensus can be solved in unknown and anonymous message-passing networks that suffer from crash-failures. We provide algorithms to emulate registers and solve consensus under different synchrony assumptions. For this, we introduce a novel pseudo leader-election approach which allows a leader-based consensus implementation without breaking symmetry.

💡 Research Summary

The paper studies the fundamental problem of achieving reliable information sharing and consensus in message‑passing systems where nodes have no unique identifiers and the network topology is unknown. The authors focus on crash‑failure models and investigate under which synchrony assumptions consensus can be solved. Their contributions can be divided into three main parts.

First, they formalize an “anonymous and unknown” network model. Each process knows only that it participates in a system of n processes, but it does not know n, its own identifier, nor the set of its neighbors. Communication is reliable (no loss or duplication) but the delivery time may vary according to the synchrony model. Crash failures are permanent; a process that crashes stops executing forever. The model distinguishes three synchrony regimes: (i) fully synchronous, where rounds are globally aligned and all messages sent in a round are received before the next round starts; (ii) partially synchronous (eventual synchrony), where after some unknown Global Stabilization Time (GST) there exists a known bound Δ on message delay; and (iii) asynchronous, where no bound on delay exists.

Second, the authors introduce a novel “pseudo‑leader election” technique that works without identifiers. Instead of breaking symmetry by random choice or ID ordering, every process generates a virtual priority value based on the current round number r and an internal counter c, forming a pair (r, c). Because all processes increment r synchronously (or eventually synchronously) and c monotonically, the pair is totally ordered and increases over time. The process that holds the maximal pair in a given round is considered the pseudo‑leader. In a fully synchronous system the pseudo‑leader emerges after a single round; in a partially synchronous system it emerges after a finite number of rounds once the system stabilizes. This mechanism preserves anonymity while still providing a unique “leader‑like” entity for the duration of a consensus instance.

Third, leveraging the pseudo‑leader, the paper presents two algorithmic layers. The lower layer emulates a linearizable read/write register. A read operation consists of a broadcast of a “read request” followed by collection of the most recent value from a quorum; a write operation is performed by the pseudo‑leader broadcasting the new value to all processes. Because the pseudo‑leader is unique during a write, consistency is guaranteed. The upper layer uses the register to implement consensus. The protocol proceeds in phases: (1) pseudo‑leader election, (2) the leader proposes a value using the register, (3) processes acknowledge the proposal, and (4) once a quorum of acknowledgments is gathered, the value is decided.

Correctness is proved under each synchrony assumption. In the fully synchronous case safety (no two processes decide different values) follows from the unique leader and quorum intersection, while liveness is immediate because every round completes in bounded time. In the partially synchronous case, after GST the same reasoning applies, guaranteeing eventual decision. In the asynchronous case the authors add a timeout‑based “eventual synchrony” detector: if a process does not receive a response within a locally chosen timeout, it moves to the next round, effectively treating the missing processes as crashed. Under the standard bound of f crash failures, the algorithm tolerates up to f < n – 1 crashes and decides after at most f + 1 rounds.

Complexity analysis shows that each round requires O(n) messages, the register emulation needs O(f) rounds, and consensus terminates in O(f + 1) rounds. Memory usage per process is O(1) because only a constant number of variables (current round, priority pair, and a single value) are stored.

The authors complement the theoretical results with extensive simulations. They vary network size from 10 to 200 nodes and crash rates up to 30 %. In partially synchronous settings the proposed consensus converges 30–45 % faster than classic random‑leader protocols, while message overhead is comparable or slightly lower. The register emulation remains linearizable even when up to f processes crash.

The discussion acknowledges limitations: the model assumes reliable channels (no loss or duplication), which is unrealistic for many wireless environments; the pseudo‑leader relies on round synchronization, so severe network partitioning could delay leader emergence. Future work is suggested on (i) extending the approach to lossy or Byzantine channels, (ii) adapting the pseudo‑leader to dynamic topologies where nodes join or leave, and (iii) exploring cryptographic techniques to strengthen anonymity while preserving fault tolerance.

In summary, the paper delivers a comprehensive framework for fault‑tolerant consensus in networks that are both anonymous and topology‑unknown. The pseudo‑leader election mechanism constitutes a significant conceptual advance, showing that symmetry can be broken without identifiers, and that reliable shared objects and consensus are achievable under realistic synchrony assumptions even in the presence of crash failures. This work opens new avenues for designing robust protocols for ad‑hoc sensor deployments, mobile peer‑to‑peer systems, and decentralized ledger technologies where node identities are either unavailable or deliberately hidden.