Failure Detectors in Homonymous Distributed Systems (with an Application to Consensus)

This paper addresses the consensus problem in homonymous distributed systems where processes are prone to crash failures and have no initial knowledge of the system membership (“homonymous” means that several processes may have the same identifier). New classes of failure detectors suited to these systems are first defined. Among them, the classes H\Omega\ and H\Sigma\ are introduced that are the homonymous counterparts of the classes \Omega\ and \Sigma, respectively. (Recall that the pair <\Omega,\Sigma> defines the weakest failure detector to solve consensus.) Then, the paper shows how H\Omega\ and H\Sigma\ can be implemented in homonymous systems without membership knowledge (under different synchrony requirements). Finally, two algorithms are presented that use these failure detectors to solve consensus in homonymous asynchronous systems where there is no initial knowledge of the membership. One algorithm solves consensus with <H\Omega,H\Sigma>, while the other uses only H\Omega, but needs a majority of correct processes. Observe that the systems with unique identifiers and anonymous systems are extreme cases of homonymous systems from which follows that all these results also apply to these systems. Interestingly, the new failure detector class H\Omega\ can be implemented with partial synchrony, while the analogous class A\Omega\ defined for anonymous systems can not be implemented (even in synchronous systems). Hence, the paper provides us with the first proof showing that consensus can be solved in anonymous systems with only partial synchrony (and a majority of correct processes).

💡 Research Summary

The paper studies consensus in homonymous distributed systems, a model where multiple processes may share the same identifier and no process initially knows the full membership, the total number of processes, or any bound on failures. This model generalizes both the classic setting with unique identifiers and the extreme case of anonymous systems (all processes have the same identifier). The authors first introduce two new failure‑detector classes tailored to homonymous environments: HΩ and HΣ. HΩ is the homonymous counterpart of the eventual leader detector Ω; it eventually and permanently selects a single identifier that belongs to at least one correct process, and all correct processes eventually trust that identifier as the leader. HΣ mirrors the quorum detector Σ: each process maintains a multiset of trusted identifiers, and the intersection of any two trusted sets is guaranteed to contain at least one correct identifier. Both detectors satisfy liveness (eventual correctness) and safety (no contradictory information).

The paper then investigates the implementability of these detectors under various synchrony assumptions. In a partially synchronous system (process step times are bounded by an unknown constant) with eventually timely links (after some unknown global stabilization time all messages are delivered within an unknown bounded delay), the authors construct a complementary detector ✸HP (the complement of the perfect detector ✸P). ✸HP provides an ever‑tightening upper bound on the number of alive processes. Using ✸HP, HΩ can be realized without any communication, showing that HΩ is a realistic detector that can be implemented under partial synchrony even without membership knowledge. Conversely, HΣ is shown to be implementable in a fully synchronous homonymous system where links are always timely, again without requiring knowledge of the membership.

With these detectors in hand, two consensus algorithms are presented. The first algorithm assumes the availability of both HΩ and HΣ. In each round, processes propagate the value proposed by the leader identified by HΩ and use HΣ to verify that the set of values they have seen intersect in at least one correct identifier. If a majority (> n/2) of processes are correct, the algorithm guarantees that all correct processes eventually decide on the same value. The second algorithm relies solely on HΩ and requires a majority of correct processes. Here the leader’s value is adopted by all processes once HΩ stabilizes, eliminating the need for HΣ and simplifying the protocol, at the cost of the majority assumption.

A crucial observation is that anonymous systems are a special case of homonymous systems (all identifiers are the same default value). Consequently, the results apply directly to anonymous settings. Prior work had shown that the anonymous counterpart of Ω, denoted AΩ, cannot be implemented even in fully synchronous anonymous systems. By contrast, the paper demonstrates that HΩ can be implemented with only partial synchrony, thereby providing the first proof that consensus is solvable in anonymous systems under partial synchrony provided a majority of correct processes exists.

The contributions can be summarized as follows: (1) definition of the homonymous failure detectors HΩ and HΣ, together with formal liveness and safety properties; (2) proof that HΩ is implementable under partial synchrony via ✸HP, and that HΣ is implementable under full synchrony without membership knowledge; (3) design of two consensus protocols—one using <HΩ, HΣ> and another using only HΩ with a majority assumption; (4) derivation of corollaries for both unique‑identifier and anonymous systems, showing that the weakest known failure detector for consensus in the classic model (Ω, Σ) can be effectively replaced by HΩ (and optionally HΣ) in homonymous settings. This work thus extends the theory of failure detectors, clarifies the minimal synchrony needed for consensus in systems with identifier ambiguity, and opens new avenues for building robust distributed services where privacy or naming constraints lead to homonymy.