Leader Election Requires Logarithmic Time in Population Protocols

Proceedings of the 2013 ACM symposium on Principles of distributed computing, 2013

Electing a leader is a fundamental task in distributed computing. In its implicit version, only the leader must know who is the elected leader. This paper focuses on studying the message and time complexity of randomized implicit leader election in synchronous distributed networks. Surprisingly, the most "obvious" complexity bounds have not been proven for randomized algorithms. In particular, the seemingly obvious lower bounds of Ω(m) messages, where m is the number of edges in the network, and Ω(D) time, where D is the network diameter, are non-trivial to show for randomized (Monte Carlo) algorithms. (Recent results, showing that even Ω(n), where n is the number of nodes in the network, is not a lower bound on the messages in complete networks, make the above bounds somewhat less obvious). To the best of our knowledge, these basic lower bounds have not been established even for deterministic algorithms, except for the restricted case of comparison algorithms, where it was also required that nodes may not wake up spontaneously and that D and n were not known. We establish these fundamental lower bounds in this paper for the general case, even for randomized Monte Carlo algorithms. Our lower bounds are universal in the sense that they hold for all universal algorithms (namely, algorithms that work for all graphs), apply to every D, m, and n, and hold even if D, m, and n are known, all the nodes wake up simultaneously, and the algorithms can make any use of node's identities. To show that these bounds are tight, we present an O(m) messages algorithm. An O(D) time leader election algorithm is known. A slight adaptation of * A preliminary version of this article appeared in the proceedings of the 32nd ACM Symposium on Principles of Distributed Computing (PODC) 2013, pages 100-109.

Lecture Notes in Computer Science, 2016

This paper presents a distributed algorithm, called ST T , for electing deterministically a leader in an arbitrary network, assuming processors have unique identifiers of size O(log n), where n is the number of processors. It elects a leader in O(D + log n) rounds, where D is the diameter of the network, with messages of size O(1). Thus it has a bit round complexity of O(D + log n). This substantially improves upon the best known algorithm whose bit round complexity is O(D log n). In fact, using the lower bound by Kutten et al. [13] and a result of Dinitz and Solomon [8], we show that the bit round complexity of ST T is optimal (up to a constant factor), which is a step forward in understanding the interplay between time and message optimality for the election problem. Our algorithm requires no knowledge on the graph such as n or D.

Lecture Notes in Computer Science, 2013

This paper focuses on compact deterministic self-stabilizing solutions for the leader election problem. When the solution is required to be silent (i.e., when the state of each process remains fixed from some point in time during any execution), there exists a lower bound of Ω(log n) bits of memory per participating node , where n denotes the number of nodes in the system. This lower bound holds even in rings. We present a new deterministic (nonsilent) self-stabilizing protocol for n-node rings that uses only O(log log n) memory bits per node, and stabilizes in O(n log 2 n) rounds. Our protocol has several attractive features that make it suitable for practical purposes. First, it assumes an execution model that is used by existing compilers for real networks. Second, the size of the ring (or any upper bound on this size) does not need to be known by any node. Third, the node identifiers can be of various sizes. Finally, no synchrony assumption, besides weak fairness, is assumed. Our result shows that, perhaps surprisingly, silence can be traded for an exponential decrease in memory space without significantly increasing stabilization time or introducing restrictive assumptions.

We consider the problem of electing a leader among nodes in a highly dynamic network where the adversary has unbounded capacity to insert and remove nodes (including the leader) from the network and change connectivity at will. We present a randomized algorithm that (re)elects a leader in O(D log n) rounds with high probability, where D is a bound on the dynamic diameter of the network and n is the maximum number of nodes in the network at any point in time. We assume a model of broadcast-based communication where a node can send only 1 message of O(log n) bits per round and is not aware of the receivers in advance. Thus, our results also apply to mobile wireless adhoc networks, improving over the optimal (for deterministic algorithms) O(Dn) solution presented at FOMC 2011. We show that our algorithm is optimal by proving that any randomized Las Vegas algorithm takes at least Ω(D log n) rounds to elect a leader with high probability, which shows that our algorithm yields the best possible (up to constants) termination time.

2020

e standard population protocol model assumes that when two agents interact, each observes the entire state of the other agent. We initiate the study of the message complexity for population protocols, where the state of an agent is divided into an externally-visible message and an internal component, where only the message can be observed by the other agent in an interaction. We consider the case of O (1) message complexity. When time is unrestricted, we obtain an exact characterization of the stably computable predicates based on the number of internal states s(n): If s(n) = o(n) then the protocol computes a semilinear predicate (unlike the original model, which can compute non-semilinear predicates with s(n) = O (log n)), and otherwise it computes a predicate decidable by a nondeterministic O (n log s(n))-space-bounded Turing machine. We then consider time complexity, introducing novel O (polylog(n)) expected time protocols for junta/leader election and general purpose broadcast correct with high probability, and approximate and exact population size counting correct with probability 1. Finally, we show that the main constraint on the power of bounded-message-size protocols is the size of the internal states: with unbounded internal states, any computable function can be computed with probability 1 in the limit by a protocol that uses only one-bit messages.

Journal of Computer and System Sciences, 2001

In the leader election problem, n players wish to elect a random leader. The difficulty is that some coalition of players may conspire to elect one of its own members. We adopt the perfect information model: all communication is by broadcast, and the bad players have unlimited computational power. Within a round, they may also wait to see the inputs of the good players. A protocol is called resilient if a good leader is elected with probability bounded away from 0. We give a simple, constructive leader election protocol that is resilient against coalitions of size βn, for any β < 1=2. Our protocol takes log n + O(1) rounds, each player sending at most log n bits per round. For any constant k, our protocol can be modified to take k rounds and be resilient against coalitions of size εn=(log (k) n) 3 , where ε is a small enough constant and log (k) denotes the logarithm iterated k times. This is constructive for k 3.

Theoretical Computer Science, 2006

Itai and Rodeh showed that, on the average, the communication of a leader election algorithm takes no more than LN bits, where L ≃ 2.441716 and N denotes the size of the ring. We give a precise asymptotic analysis of the average number of rounds M (n) required by the algorithm, proving for example that M (∞) := lim n→∞ M (n) = 2.441715879. . ., where n is the number of starting candidates in the election. Accurate asymptotic expressions of the second moment M (2) (n) of the discrete random variable at hand, its probability distribution, and the generalization to all moments are given. Corresponding asymptotic expansions (n → ∞) are provided for sufficiently large j, where j counts the number of rounds. Our numerical results show that all computations perfectly fit the observed values. Finally, we investigate the generalization to probability t/n, where t is a non negative real parameter. The real function M (∞, t) := lim n→∞ M (n, t) is shown to admit one unique minimum M (∞, t *) on the real segment (0, 2). Furthermore, the variations of M (∞, t) on the whole real line are also studied in detail.

2020

This paper presents a randomized self-stabilizing algorithm that elects a leader $r$ in a general $n$-node undirected graph and constructs a spanning tree $T$ rooted at $r$. The algorithm works under the synchronous message passing network model, assuming that the nodes know a linear upper bound on $n$ and that each edge has a unique ID known to both its endpoints (or, alternatively, assuming the $KT_{1}$ model). The highlight of this algorithm is its superior communication efficiency: It is guaranteed to send a total of $\tilde{O} (n)$ messages, each of constant size, till stabilization, while stabilizing in $\tilde{O} (n)$ rounds, in expectation and with high probability. After stabilization, the algorithm sends at most one constant size message per round while communicating only over the ($n - 1$) edges of $T$. In all these aspects, the communication overhead of the new algorithm is far smaller than that of the existing (mostly deterministic) self-stabilizing leader election algo...

2018

We study population protocols: networks of anonymous agents that interact under a scheduler that picks pairs of agents uniformly at random. The _size counting problem_ is that of calculating the exact number $n$ of agents in the population, assuming no leader (each agent starts in the same state). We give the first protocol that solves this problem in sublinear time. The protocol converges in $O(\log n \log \log n)$ time and uses $O(n^{60})$ states ($O(1) + 60 \log n$ bits of memory per agent) with probability $1-O(\frac{\log \log n}{n})$. The time complexity is also $O(\log n \log \log n)$ in expectation. The time to converge is also $O(\log n \log \log n)$ in expectation. Crucially, unlike most published protocols with $\omega(1)$ states, our protocol is _uniform_: it uses the same transition algorithm for any population size, so does not need an estimate of the population size to be embedded into the algorithm. A sub-protocol is the first uniform sublinear-time leader election po...

2020

Leader election is, together with consensus, one of the most central problems in distributed computing. This paper presents a distributed algorithm, called ST T , for electing deterministically a leader in an arbitrary network, assuming processors have unique identifiers of size O(logn), where n is the number of processors. It elects a leader in O(D + logn) rounds, where D is the diameter of the network, with messages of size O(1). Thus it has a bit round complexity of O(D + logn). This substantially improves upon the best known algorithm whose bit round complexity is O(D logn). In fact, using the lower bound by Kutten et al. (2015) and a result of Dinitz and Solomon (2007), we show that the bit round complexity of ST T is optimal (up to a constant factor), which is a significant step forward in understanding the interplay between time and message optimality for the election problem. Our algorithm requires no knowledge on the graph such as n or D, and the pipelining technique we int...

We present an efficient randomized algorithm for leader election in large-scale distributed systems. The proposed algorithm is optimal in message complexity (O(n) for a set of n total processes), has round complexity logarithmic in the number of processes in the system, and provides high probabilistic guarantees on the election of a unique leader. The algorithm relies on a balls and bins abstraction and works in two phases. The main novelty of the work is in the first phase where the number of contending processes is reduced in a controlled manner. Probabilistic quorums are used to determine a winner in the second phase. We discuss, in detail, the synchronous version of the algorithm, provide extensions to an asynchronous version and examine the impact of failures.

Proceedings of the 2021 ACM Symposium on Principles of Distributed Computing, 2021

We study population protocols, a model of distributed computing where agents exchange information in pairwise interactions, but have no control over their schedule of interaction partners. The well-studied majority problem is that of determining in an initial population of n agents, each with one of two opinions A or B, whether there are more A, more B, or a tie. A stable protocol solves this problem with probability 1 by eventually entering a configuration in which all agents agree on a correct consensus decision of A, B, or T, from which the consensus cannot change. We describe a protocol that solves this problem using O(log n) states (log log n + O(1) bits of memory) and optimal expected time O(log n). The number of states O(log n) is known to be optimal for the class of polylogarithmic time stable protocols that are &quot;output dominant&#39;&#39; and &quot;monotone&#39;&#39;. These are two natural constraints satisfied by our protocol, making it simultaneously time- and state-o...

We start with a set of n players. With some probability $P(n, k)$, we kill $n−k$ players; the other ones stay alive, and we repeat with them. What is the distribution of the number $X_n$ of phases (or rounds) before getting only one player? We present a probabilistic analysis of this algorithm under some conditions on the probability distributions $P(n, k)$, including stochastic monotonicity and the assumption that roughly a fixed proportion $\alpha$ of the players survive in each round. We prove a kind of convergence in distribution for $\lceilX_n−\log_{1/\alpha}(n)\rceil$; as in many other similar problems there are oscillations and no true limit distribution, but suitable subsequences converge, and there is an absolutely continuous random variable $Z$ such that $d(Xn, \lceilZ+\log_{1/\alpha}(n)\rceil) \to 0$, where d is either the total variation distance or the Wasserstein distance. Applications of the general result include the leader election algorithm where players are elimin...

Algorithmica

Leader election is, together with consensus, one of the most central problems in distributed computing. This paper presents a distributed algorithm, called ST T , for electing deterministically a leader in an arbitrary network, assuming processors have unique identifiers of size O(log n), where n is the number of processors. It elects a leader in O(D + log n) rounds, where D is the diameter of the network, with messages of size O(1). Thus it has a bit round complexity of O(D + log n). This substantially improves upon the best known algorithm whose bit round complexity is O(D log n). In fact, using the lower bound by Kutten et al. (2015) and a result of Dinitz and Solomon (2007), we show that the bit round complexity of ST T is optimal (up to a constant factor), which is a significant step forward in understanding the interplay between time and message optimality for the election problem. Our algorithm requires no knowledge on the graph such as n or D, and the pipelining technique we introduce to break the O(D log n) barrier is general. This research has been partially supported by ANR projects DESCARTES and ESTATE (resp. ANR-16-CE40-0023 and ANR-16-CE25-0009-03). A preliminary subset of this work appeared in the proceedings of DISC 2016 [12].

Distributed Computing, 2019

This paper focuses on studying the message complexity of implicit leader election in synchronous distributed networks of diameter two. Kutten et al. (J ACM 62(1):7:1-7:27, 2015) showed a fundamental lower bound of Ω(m) (m is the number of edges in the network) on the message complexity of (implicit) leader election that applied also to Monte Carlo randomized algorithms with constant success probability; this lower bound applies for graphs that have diameter at least three. On the other hand, for complete graphs (i.e., graphs with diameter one), Kutten et al. (Theor Comput Sci 561(Part B):134-143, 2015) established a tight bound ofΘ(√ n) on the message complexity of randomized leader election (n is the number of nodes in the network). For graphs of diameter two, the complexity was not known. In this paper, we settle this complexity by showing a tight bound ofΘ(n) on the message complexity of leader election in diameter-two networks. We first give a simple randomized Monte-Carlo leader election algorithm that with high probability (i.e., probability at least 1 − n −c , for some fixed positive constant c) succeeds and uses O(n log 3 n) messages and runs in O(1) rounds; this algorithm works without knowledge of n (and hence needs no global knowledge). We then show that any algorithm (even Monte Carlo randomized algorithms with large enough constant success probability) needs Ω(n) messages (even when n is known), regardless of the number of rounds. We also present an O(n log n) message deterministic algorithm that takes O(log n) rounds (but needs knowledge of n); we show that this message complexity is tight for deterministic algorithms. Together with the two previous results of Kutten et al., our results fully characterize the message complexity of leader election vis-à-vis the graph diameter.