Solving k-Set Agreement with Stable Skeleton Graphs

In this paper we consider the k-set agreement problem in distributed message-passing systems using a round-based approach: Both synchrony of communication and failures are captured just by means of the messages that arrive within a round, resulting in round-by-round communication graphs that can be characterized by simple communication predicates. We introduce the weak communication predicate PSources(k) and show that it is tight for k-set agreement, in the following sense: We (i) prove that there is no algorithm for solving (k-1)-set agreement in systems characterized by PSources(k), and (ii) present a novel distributed algorithm that achieves k-set agreement in runs where PSources(k) holds. Our algorithm uses local approximations of the stable skeleton graph, which reflects the underlying perpetual synchrony of a run. We prove that this approximation is correct in all runs, regardless of the communication predicate, and show that graph-theoretic properties of the stable skeleton graph can be used to solve k-set agreement if PSources(k) holds.

💡 Research Summary

This paper investigates the minimal synchrony requirements needed to solve the k‑set agreement problem in distributed message‑passing systems using a round‑based model. The authors adopt the classic Heard‑Of / round‑by‑round framework, where each round r is represented by a directed communication graph G_r: an edge (q→p) exists iff process p receives q’s message in that round. By intersecting the graphs of all rounds up to r they define the “round‑r skeleton” G∩r, and the “stable skeleton” G∞ = ⋂_{r≥1} G∩r, which captures the set of links that are timely in every round and thus reflects the permanent synchrony of a run.

The central contribution is the introduction of a weak communication predicate called PSources(k). For any set S of k+1 processes, PSources(k) requires the existence of two distinct processes q, q′∈S that both receive messages from a common process p in every round. In graph terms, every (k+1)-node induced subgraph of G∞ contains at least two nodes sharing a common predecessor (the “2‑source”). This condition is strictly weaker than classic partial synchrony assumptions yet still imposes a perpetual synchrony pattern.

The authors first prove that PSources(k) is insufficient for (k‑1)-set agreement. Theorem 1 shows that any run satisfying PSources(k) can have at most k root strongly‑connected components in its stable skeleton. Theorem 2 constructs a specific run where k processes form isolated root components while the remaining processes only hear from a single “hub” process. In this run each process must decide on its own input, leading to k distinct decision values, which violates (k‑1)-agreement. Hence (k‑1)-set agreement is impossible under PSources(k).

Next, they present Algorithm 1, a constructive solution for k‑set agreement when PSources(k) holds. Each process p maintains:

1. PT(p,r), the set of processes from which p has received messages in every round up to r.
2. A locally stored approximation graph G_p (denoted G^r_p for round r), which is a weighted digraph where an edge (q→p) is labeled with the round when it was first observed.

In every round, p broadcasts its current PT(p,r) and its approximation graph G^r_p. Upon receiving a graph from a neighbor q∈PT(p,r), p merges the received edges into its own approximation, discarding any edge whose label is older than n‑1 rounds (n being the total number of processes). Lemma 3 proves that PT(p,r) indeed matches the formal definition of timely neighbors and that the approximation converges to the true stable skeleton G∞ regardless of the underlying communication predicate.

After a sufficient number of rounds, each process computes the strongly‑connected components (SCCs) of its approximation. Because PSources(k) guarantees that G∞ contains at most k root SCCs, the algorithm selects the minimal identifier among the processes in its own SCC and adopts that process’s input value as its decision. This selection rule ensures that at most k distinct values are decided system‑wide, satisfying the k‑agreement property. Validity follows because the chosen value originates from some process’s proposal, and termination is guaranteed as the approximation stabilizes after a bounded number of rounds.

The paper therefore establishes a tight characterization: PSources(k) is exactly the weakest predicate that enables k‑set agreement—any weaker predicate cannot solve (k‑1)-set agreement, while PSources(k) itself suffices for k‑set agreement. The work bridges graph‑theoretic concepts with round‑based fault models, providing both impossibility results and a concrete algorithm that works under minimal, perpetual synchrony assumptions. The authors conclude with discussions on how their model relates to Heard‑Of and round‑by‑round failure detectors, and suggest future extensions to dynamic process sets, richer predicates, and empirical evaluation.