Beeping a Deterministic TimeOptimal Leader Election
D I S C
Beeping a Deterministic TimeOptimal Leader Election
Fabien Dufoulon LRI 0 1
Universit? ParisSud 0 1
Universit? ParisSaclay 0 1
Orsay 0 1
France https://orcid.org/ 0 1
Janna Burman 0 1
0 LRI, Universite? ParisSud, CNRS, Universite? ParisSaclay , Orsay , France
1 Joffroy Beauquier LRI, Universite? ParisSud, CNRS, Universite? ParisSaclay , Orsay , France
The beeping model is an extremely restrictive broadcast communication model that relies only on carrier sensing. In this model, we solve the leader election problem with an asymptotically optimal round complexity of O(D+log n), for a network of unknown size n and unknown diameter D (but with unique identifiers). Contrary to the best previously known algorithms in the same setting, the proposed one is deterministic. The techniques we introduce give a new insight as to how local constraints on the exchangeable messages can result in efficient algorithms, when dealing with the beeping model. Using this deterministic leader election algorithm, we obtain a randomized leader election algorithm for anonymous networks with an asymptotically optimal round complexity of O(D + log n) w.h.p. In previous works this complexity was obtained in expectation only. Moreover, using deterministic leader election, we obtain efficient algorithms for symmetrybreaking and communication procedures: O(log n) time MIS and 5coloring for tree networks (which is timeoptimal), as well as ksource multibroadcast for general graphs in O(min{k, log n}? D + k log nkM ) rounds (for messages in {1, . . . , M }). This latter result improves on previous solutions when the number of sources k is sublogarithmic (k = o(log n)). 2012 ACM Subject Classification Theory of computation ? Distributed computing models, Theory of computation ? Distributed algorithms, Theory of computation ? Design and analysis of algorithms Related Version A full version is available at https://hal.archivesouvertes.fr/hal01794711.
and phrases distributed algorithms; leader election; beeping model; time complexity; deterministic algorithms; wireless networks

The leader election (LE) problem, where a single (leader) node is given a distinguished
role in the network, is a fundamental building block in algorithm design. This is because a
leader can initiate and coordinate behaviors in the network, often making leader election a
crucial first step in applications requiring communication and agreement on a global scale.
For example, more advanced communication primitives such as broadcast, gossiping and
multibroadcast, rely on a leader to coordinate transmissions [10] (see also Sect. 4.3).
Wireless networks with severe restrictions on communication capabilities are an
increasingly prevalent subject of study, e.g., [6, 20, 7, 13, 14, 8]. In order to model these networks,
Cornejo and Kuhn [7] introduced a convenient formal framework: the discrete beeping model
(BEEP). In this model, time is divided into synchronous rounds, and in each round, a node
can either listen or transmit a unary signal (beep) to all its neighbors. The possibility to
directly transmit a beep to a node is defined by a static communication graph, and nodes
have no knowledge of this graph. As a beep is merely a detectable burst of energy, a listening
node does not receive the identifiers (ids) of its beeping neighbors. Even more critically, a
beeping node receives no feedback, while a silent (listening) one can only detect that either
at least one of its neighbors beeped or that all of them were silent. Although algorithms can
take advantage of the synchronous nature of the rounds to transmit information using beeps,
doing so impacts the time complexity in a quantifiable manner. This work studies how this
impact can be minimized.
The beeping model has also been justified by its possible applications to biological networks
[19], which are reliant on primitive communications. Fireflies communicate through flashes
of light [2, 15] and cells through the diffusion of specific chemical markers [1, 22].
Beeps are an extremely limited form of communication, making it difficult to coordinate
nodes. Being a fundamental coordination problem, leader election has received a lot of
attention (see Sect. 1.1). Probabilistic and deterministic solutions were proposed for general
graphs, and a time complexity lower bound of ?(D + log n) was established (D is the diameter
of the network, and n its size). A prime concern is the design of timeefficient uniform
solutions, that is, not requiring any knowledge on the graph topology or on the parameters n
and D (or even on their upper bounds). Indeed, it is unrealistic to assume that upper bounds
on these parameters are always available, especially when considering dynamic networks.
Amongst existing works on LE in BEEP, the more difficult (for design) deterministic case
has received less attention. However, this case is useful whenever random behavior is
inappropriate or deterministic guarantees are required. We show in this work that an
asymptotically timeoptimal deterministic algorithm can be designed. This algorithm gives
rise to an anonymous (not using ids) randomized algorithm that also matches the lower
bound.
1.1
Related Work
Leader election (LE), being a fundamental problem in distributed computing, has been
studied in various models. In each newly introduced model, an efficient leader election
algorithm is a foremost concern, since it is frequently used as a building block in more
complex algorithms. In particular, recent models designed for wireless networks assume that
simultaneous communications interfere with each other. Consequently, leader coordination is
even more important in these models, though LE is harder to solve efficiently.
Even though computational complexities (in particular time complexity) for LE are key
aspects in the algorithmic design, additional properties are also of concern: for example,
one might want nodes to detect termination, or to ensure that there is never more than one
leader node during any execution (safety property).
Ghaffari and Haeupler [13] present the first LE algorithm for BEEP, which elects a
leader in O(D + log n) ? O(log2 log n) rounds with high probability (w.h.p.: with probability
1 ? n??(1)). [13] also gives a lower bound of ?(D + log n) rounds for LE, applicable both to
Round complexity
O(D + log n log log n) ? min{log log n, log Dn } w.h.p.
O(D ? log n) deterministic time
O(D + log n) expected time
O(D + log n) deterministic time
O(D + log n) w.h.p.
Safety
w.h.p.
Deterministic
w.h.p.
Deterministic
w.h.p.
Knowledge
N = nc
None
N = nc
None
N = nc
deterministic and randomized (w.h.p. time) algorithms. This bound can be compared to the
?(D) lower bound in the E CON GE ST model [16]. E CON GE ST differs from BE E P in that
any given node can send (different) messages of O(log n) bits to each of its neighbors during
a round. When nodes receive messages, there are no collisions and they can distinguish from
which edge they received a particular message. Intuitively, since a beep can convey at most
one bit, additional ?(log n) rounds are necessary [18, 5, 11]. Following the result from [13],
Czumaj and Davies [8, 9] presented a randomized LE algorithm with O(D + log n) expected
time in BE E P. In both randomized algorithms, the safety property is guaranteed w.h.p., but
some upper bound N on the number of nodes n is required. As for deterministic LE, F?rster
et al. [12] give the first algorithm in BE E P, with an O(D ? log n) round complexity. This
algorithm is uniform in both n and D. The round complexities of different LE algorithms,
including those presented in this work, are compared below (see Table 1).
It is mentioned in [13, 9] that upper bounds in BE E P apply to the wellknown radio
networks with collision detection (RN CD). In RN CD, nodes can send messages of O(log n)
bits (instead of beeps) and listening nodes receive a ?collision? message if more than two
neighbors communicate at the same time. For both models, previous results are not tight,
especially for deterministic leader election.
[13, 8, 9, 12] concentrate on improving the time complexity of LE in general graphs, in BE E P.
A different focus is presented in [14], where the goal is to minimize the size of the state
machine representation of an algorithm solving randomized LE in singlehop networks.
Amongst the extensive leader election literature in other models, Casteigts et al. [5]
is particularly relevant to this work. [5] proposes an O(D + log n) time deterministic LE
algorithm in the constantsize E CON GE ST model, where the algorithm is uniform in both
the number of nodes n and the diameter D. This model is much stronger than BE E P, in
that a node can easily learn its local topology and has direct links to communicate with its
neighbors, whereas the absence of such links in the beeping model causes interference and
makes directed messages (with known sender and receiver) unachievable or plainly inefficient.
Notice that by using a 2hop coloring and by separating in time the transmission of messages,
according to the colors of both the sender and receiver, the constantsize E CON GE ST model
can be simulated, but with a prohibitive multiplicative factor of O(?4) [3] (where ? is the
maximum degree).
Nevertheless, one of the main contributions of [5] is a rooted (in the maximum id node)
spanning tree construction and an information diffusion algorithm, designed to spread the
maximum identifier efficiently, in a pipelinelike manner (rather than performing consecutive
local comparisons on complete identifiers). This latter shift is crucial to the timeoptimality
of their algorithm, and is used here to improve on the O(D ? log n) result from [12].
1.2
Contributions
We propose a deterministic and completely uniform (in n and D) leader election algorithm
with an O(D + log n) asymptotically optimal round complexity. By independently sampling
?(log n) bits to create unique identifiers w.h.p. and using this algorithm, we obtain a uniform
(in D only) randomized leader election algorithm which takes O(D + log n) rounds w.h.p.
and works in anonymous networks. Both solutions are the first to achieve timeoptimality
for these guarantees in both BE E P and RN CD, outperforming all previous deterministic
and randomized results. This work closes the gap between upper and lower bounds for LE.
Furthermore, using the proposed deterministic LE algorithm, we propose the first
asymptotically timeoptimal (in O(log n) rounds) Maximal Independent Set (MIS) and 5coloring
algorithms for trees in BE E P (leveraging the fact that given a leader in a tree network, it
is simple to compute a 2coloring). The MIS and coloring algorithms can be considered as
essential symmetrybreaking procedures, and designing optimaltime solutions (even limited
to tree networks) might be crucial for other applications in BE E P .
Then, we give an O(min{k, log n} ? D + k log nkM ) time ksource multibroadcast (with
provenance) algorithm (for messages in {1, . . . , M }). This latter algorithm improves a previous result
by Czumaj and Davies [8], when the number of sources k is sublogarithmic (k = o(log n)), by
executing k consecutive leader elections. Communication primitives are especially important
in BE E P , as they allow to deal with the interferences caused by simultaneous communications,
and thus to design complex algorithms.
2
2.1
Model and Definitions
Preliminaries
The communication network is represented by a simple connected undirected graph G =
(V, E), where V is the node set and E the edge set. The network size V  is also denoted by
n, and the diameter by D. Nodes have unique identifiers (ids). This property is essential in
order to break symmetry in deterministic algorithms. The identifier of a node u ? V , id(u),
is an integer from {1, . . . , U } where U is some upper bound unknown to nodes. Then, the
maximum length over all identifiers in G is O(log U ) (also unknown). For simplicity, we make
the common assumption that identifiers have logarithmic (in n) length, i.e., the id space is
{1, . . . , N } where N = nc for some unknown constant c > 1. In Sect. 3.3, we explain how
the results of the paper apply to an arbitrary id space setting.
Now, we give definitions pertaining to (binary) words. The empty word is denoted by .
The operator k is for the word concatenation. The length of a word x is denoted by x. For
any word x and integer j ? {1, . . . , x}, x[j] denotes the jth most significant bit of x. Let x
and y be two words (of possibly different lengths), x is said to be the prefix (resp., proper
prefix) of y if there exists a word (resp., non empty word) z such that x k z = y. Moreover,
x is said to be higher than y, denoted by x y, if y is a proper prefix of x, or if x[j] > y[j]
for the first differing bit j (even if x < y).
The ?encoding [5] of an integer i ? N>0 is a word obtained from the binary representation
bin of i. By definition, ?(i) = 1bin k 0 k bin. In the proposed LE algorithm (Sect. 3),
instead of ids, nodes compare their ?encodings (?ids). Finding the highest ?id is equivalent
to finding the maximum id, and can be performed uniformly (without padding the binary
representations of ids) using bitwise comparisons. A word x is wellformed if there exists an
integer i such that x = ?(i). It is simple to prove that for every word x, there is at most one
such integer i. Thus the ??1 function (??s ?inverse?) is defined on wellformed words.
2.2
Model Definitions
In the beeping model (BEEP), an execution proceeds in synchronous rounds, i.e., there are
synchronized local clocks and all nodes start at the same time, in a synchronous start. In each
round, nodes synchronously execute the following steps. First, each node beeps (instruction
BEEP in algorithms) or listens (LIST EN in algorithms). Beeps are transmitted to all
neighbors of the beeping node. Then, if a node beeped (in the previous step of the same
round), it learns no information from its neighbors. Otherwise, it knows whether or not at
least one of its neighbors beeped (during the previous step of the same round). Finally, each
node performs local computations. The synchronous start assumption can be replaced by a
slightly weaker variant called wakeonbeep [1], for a constant multiplicative overhead (and
an additive factor of O(D) rounds). In this variant, a node starts spontaneously either at
an arbitrary time, or at one of its neighbors? beep, whichever happens first. Upon waking
up, a node beeps immediately, to wake up its neighbors. As a result, the local clocks of two
neighboring nodes differ by at most 1. Therefore, nodes can use phases of 3 rounds [1] (in
which the node can beep or listen in the central round, and listens in both other rounds) to
simulate rounds of a synchronous start execution.
We adopt the usual definitions for the system/algorithm: state of a node (values of
its variables), configuration (a vector of all the nodes? states), execution (a sequence of
configurations at consecutive rounds? ends), terminal configuration (a configuration repeated
indefinitely), termination (when a terminal configuration has been reached), round complexity
(number of rounds needed until a terminal configuration satisfying the problem conditions is
reached, in the worst case). A variable var of a node v is explicitly associated to v using a
subscript varv. An algorithm is said to be uniform1 in a parameter p if the algorithm is not
given p (and is unable to infer it from the information it receives). For example, in a uniform
(in n) algorithm, nodes do not know the size n of the network, neither can they deduce it
from their identifier. Notice that the variable size of the identifiers gives an unusable upper
bound on the network size, as it leads to an excessive and unrealistic time complexity.
2.3
Leader Election
In the leader election (LE) problem, each node has a boolean variable, indicating a leader or a
nonleader state. During an execution, there is never more than one leader (safety property).
Initially, all nodes are nonleaders. Every execution terminates, and at the termination there
is exactly one leader.
Now we give auxiliary definitions. First, we define eventual leader election, where the
algorithm terminates but no node can detect this. Then, we define terminating leader
election, where the algorithm terminates and all nodes detect when there remains a single
candidate node (the leader). We solve explicit leader election (when nodes have unique
identifiers): a terminating leader election in which all nodes know the elected leader?s identifier
at the termination.
1 It is known that termination detection is easy in a synchronous setting whenever particular parameters
related to the size of the communication graph are known, i.e., nonuniform terminating algorithms are
easier to construct than the uniform ones.
Algorithm 1 Uniform Eventual Leader Election Algorithm.
1: IN: id: identifier ; OUT: leader: boolean, leaderId: identifier
2: candidate := true, pref ix := , suspicious := f alse . is the empty word
3: leaderId := 0, leader := f alse . id and leaderId are ids, from {1, . . . , N }
4: for diffusion phase p := 1 ; p++ do
5: // First, a communication phase with c rounds.
6: Communicate (pref ix, suspicious) to all neighboring nodes.
7: // Then, apply predicates of rules 1 to 5 on received (pref ix, suspicious) pairs.
8: Use received (pref ix, suspicious) pairs to update pref ix, candidate and suspicious
9: if not candidate then leader := f alse
10: else if pref ix = ?(id) then leader := true
11: if pref ix is wellformed then leaderId := ??1(pref ix)
3
Leader Election Algorithms
Classical approaches used to solve leader election in CON GE ST models do not directly apply
to BE E P . Although they can be adapted using a transformer, doing so is too costly in most
communication graph topologies (see discussion in the related work section: Sect. 1.1).
To solve the strongest version of LE, the explicit leader election, we proceed in two main
steps. First, we design a uniform algorithm for eventual leader election, in Sect. 3.1. Then, in
Sect. 3.2, we combine this algorithm with a specially designed uniform termination detection
component to obtain a uniform explicit leader election algorithm. Finally, in Sect. 3.3,
we discuss how the presented algorithm can be applied to other settings (e.g., arbitrary id
range).
3.1
Uniform Eventual Leader Election
The algorithm (Algorithm 1) is described first (Sect. 3.1.1). Then, in Sect. 3.1.2, kbalanced
messages are presented. They are used to allow constantsize communication phases composed
of rounds and dedicated to the communication of (large) messages respecting local constraints.
Using the kbalanced message technique, a detailed description of the communication phases
(appearing in Algorithm 1) is given in Sect. 3.1.3. Finally, in Sect. 3.1.4, we relate the
presented techniques to existing works in CON GE ST models.
3.1.1
Description
All nodes aim to spread their ?identifiers (?(id) in Alg. 1) to the whole network (information
diffusion algorithm). They execute loosely synchronized bitwise comparisons and propagate
the bits of the highest detected prefix (of ?id). All nodes start out as candidates, with two
variables: pref ix and suspicious. The binary word pref ix is initialized to the empty word
and represents the prefix of an ?id. Most of the time, it represents the highest prefix
of which the node is aware. Each node adapts its pref ix by adding or removing the less
significant bits, depending on the information gathered. The boolean suspicious is initialized
to f alse and indicates whether the node removed bits from pref ix in the last phase.
Nodes execute diffusion phases (of c rounds each) synchronously. A diffusion phase
consists of one communication phase of c = O(1) rounds (line 6), used to send pref ix and
suspicious to all neighbors, followed by a (limited) modification of pref ix.
The communication phase is described in detail in Sect. 3.1.3. In the same phase, each node
receives (pref ix, suspicious) pairs from its neighbors, but does not know which node sent
which message, nor how many nodes sent any of these messages (multiplicity).
After the communication phase, any node v checks if pref ixv is a locally higher prefix, using
the received pairs (see details below) and the previously gathered information. If this is the
case, it appends a bit from its ?id to pref ixv (if pref ixv is a proper prefix of ?(idv)), or
does nothing (if pref ixv = ?(idv)). Otherwise, it modifies pref ixv depending on the highest
detected pref ix value, and becomes a follower. It can no longer become a leader. If that
modification removes bits from pref ixv, node v is said to be suspicious for the following
phase, and suspiciousv is assigned to true for one phase.
The five rules below associate conditions (predicates) to actions. A predicate evaluated
to true triggers the associated action. In line 8, these predicates are evaluated (by some
node v) on the set of the received (pref ix, suspicious) pairs, in the given order of priority,
and the first triggered action is performed.
1. If there exists a suspicious neighbor u, such that pref ixu is a proper prefix of pref ixv,
remove min{pref ixv ? pref ixu, 3} letters from the end of pref ixv.
2. If pref ixv = (z k 0 k w) with w 6= and there exists a neighbor u with pref ixu = (z k
1 k y), delete w letters from the end of pref ixv.
3. If pref ixv = (z k 0) and there exists a neighbor u with pref ixu = (z k 1 k y), then
change pref ixv to (z k 1).
4. If there exists a neighbor u with pref ixu = (pref ixv k 1 k w) then append 1 to pref ixv.
5. If there exists a neighbor u with pref ixu = (pref ixv k 0 k w) then append 0 to pref ixv.
If any of the predicates (of the rules 15) is true, pref ixv is not a locally higher prefix.
Indeed, if a neighbor u (of v) is suspicious and pref ixu is a proper prefix of pref ixv, then a
neighbor of u has a higher prefix than pref ixv, or is changing its pref ix according to rule 1
above. By deleting the last bits of pref ixv, node v is matching pref ixv to an unknown but
higher pref ix. In all 4 other cases, pref ixu is clearly a higher prefix than pref ixv, therefore
pref ixv modifies (a limited amount of) its last bits to more closely match pref ixu.
Additional local computations in lines 911 conclude a diffusion phase. Once a candidate?s
pref ix variable is wellformed (i.e., once idv = ??1(pref ixv)), this node becomes a leader.
If in later rounds it becomes a follower, then it withdraws from the leader role. Although
this process violates the safety property, it is necessary in order to elect a leader, as the
last remaining candidate cannot detect that it is the last, due to the lack of termination
detection in this preliminary eventual LE version.
The 5 rules described above are an idea adopted from [5]. Thus the described information
diffusion process satisfies Lemma 1 and Theorem 2 below, adopted from the results of [5]
and adapted here to our beeping algorithm (see Sect. 3.1.4 for more details).
I Lemma 1 (Beeping version of Lemma 8 in [5]). Let u and v be two neighboring nodes.
Then, pref ixu and pref ixv are identical, except in at most 6 (least significant) bits: without
loss of generality, from the pref ixuth bit (possibly included) to the pref ixvth bit.
Note that if the pref ixuth bit differs in pref ixu and pref ixv, then pref ixu?pref ixv < 6
I Theorem 2 (Beeping version of Theorem 10 in [5]). Let X be the maximum identifier. After
?(X) + 6r phases of the information diffusion algorithm, all nodes within distance r (for
any r ? 0) from the node with id X have pref ix = ?(X). Thus, after at most ?(X) + 6D
phases, for each node v, pref ixv = ?(X), and there is a unique candidate node.
Proof. Let l be the maximum id node. We prove the theorem by induction on r.
Node l has the maximum identifier X, thus it appends a bit from ?(X) in each diffusion
phase. After ?(X) phases, pref ixl = ?(X). This concludes the case when r = 0.
For the induction step (r > 0), consider any given node u at distance r + 1 of node l, and
one of its neighbors v at distance r from l. By Lemma 1, pref ixu and pref ixv differ in less
than 6 bits. After ?(X) + 6r phases, since pref ixv = ?(X) (induction hypothesis), node v
does not modify pref ixv and node u necessarily corrects (removes, changes or adds) at least
one of pref ixu?s bits in each of the 6 following phases, until pref ixu = ?(X). J
Recall that a communication phase is composed of c = O(1) rounds (c is defined in Sect.
3.1.3). This implies the following theorem.
I Theorem 3. Uniform Eventual Leader Election is solved by Algorithm 1 in O(D + log n)
rounds (in the beeping model).
Proof. Let v be any given node and X the maximum identifier in the network. From Theorem
2, pref ixv = ?(X) after O(D + log n) phases. Nodes have the leader?s identifier by applying
the ??1 function. Moreover, the maximum id node is wellformed after ?(X) = O(log n)
phases, thus after O(log n) rounds. As a result, the maximum id node is, and remains, a
leader henceforth. J
3.1.2
Balanced messages
A basic design technique called multislot design pattern [4], allows to communicate
constantsize messages without the sender?s id nor multiplicity, given a synchronous start. It works
in communication phases of M rounds, if at most M different messages (in {1, . . . , M }) are
allowed. Beeping in the jth round of a phase is equivalent to sending the message j. However,
receivers cannot detect which (and how many) nodes sent that message. Thus, due to the
beeping model?s restrictions, if a node sends a message m, it receives no information about
whether any of its neighbors also did.
Clearly, this design technique cannot be used to directly send pref ix values, as these
values are in {1, . . . , N }, and communication phases would be O(N ) rounds long. But this
technique can be adapted to send the values of a locally constrained (kbalanced) variable.
A variable var is said to be kbalanced if it satisfies the kbalancing property, that is, if the
difference between neighboring var values is at most k (for every node v and neighboring
node u, varu ? varv ? k).
If one wishes to communicate kbalanced messages, then it is enough to transmit, for a
message m, the remainder r = m mod(1 + 2k), using the previous technique, with phases of
M = 1 + 2k rounds (where k is known a priori to all nodes). Then, the receiver knowing at
the same time its own remainder, the sender?s remainder and the fact that the messages are
kbalanced, can deduce the originally sent message (but does not know if multiple nodes have
sent this message). Specifically, let v be the receiver and u the sender. Node v deduces the
original message mu from the received remainder message ru: mu = mv + ru ? rv ? b ruk?+1rv cM .
Consider the example depicted in Table 2 for k = 4. For a given node v, any message mu
sent by a neighboring node u is in {mv ? k, . . . , mv + k}. By transmitting the remainder
ru = mu mod(1 + 2k), node u indicates whether its message mu is in the next 4 values or in
the previous 4, respectively to mv, and the exact position amongst the 4 possibilities (more
precisely, through ru ? rv). The remaining ?b ruk?+1rv cM factor deals with the fact that some
lower (than mv) messages mu result in a high remainder ru, and some higher messages mu
in a low remainder ru, due to the modulo operation. Node v can deduce the message mu by
using all of this information, along with its own message mv.
The kbalanced message technique is of independent interest, and allows efficient algorithm
design when nodes communicate locallysimilar values.
Designing constantsize communication phases
In this section, we show that by applying the balanced messages approach, using only O(1)
beeping rounds, a node can deduce its neighbors? pref ix values (and whether some of them
are suspicious), even though there are O(N ) different possible values of pref ix.
From Lemma 1, we know that pref ix is a 6balanced variable. Moreover, two neighboring
nodes have similar pref ix values, which differ only in (at most 6 of) the last bits. Therefore,
if a node can learn the last 6 bits of a neighboring pref ix, and their exact positions, then
it can fill up the empty bits (in more significant positions) using the bits from its own
pref ix. To learn that, one could use two consecutive communication subphases: the first
communicates the position of the last bit (which is pref ix, a 6balanced variable) in a
subphase with 13 rounds, and the second communicates an ending message with the last
6 bits (using a message from {1, . . . , 26}, encoding all possible 6 letters combinations), in
a subphase with 64 rounds. However, this does not work in BE E P because one needs to
know, for every different ending message sent by neighbors, the corresponding position of the
last bit (thus the corresponding position message). Although this is trivial in E CON GE ST ,
because messages from different neighbors are received on different edge ports, it is too costly
to simulate this functionality in BE E P (see Sect. 1.1). Fortunately, as the message space
is constantsize in both of these communication subphases, the Cartesian product of both
message spaces is also constantsize. This allows to associate position and ending messages,
using O(1) rounds, even in BE E P . Consequently, communication phases with 832 rounds
(for messages in {1, .., 13} ? {1, . . . , 26}) are needed to communicate enough information for
a node to deduce all neighboring pref ix values.
On top of that, the nodes also need to communicate the boolean suspicious. For this
reason, the message space is adapted to {1, .., 13} ? {1, . . . , 26} ? {f alse, true}. This results
in communication phases (introduced in Algorithm 1, Sect. 3.1.1) of length c = 1664 rounds,
which although large, is still O(1) size.
3.1.4
Remarks on the eventual leader election algorithm
As mentioned in the related work (Sect. 1.1), [5] is particularly relevant to our work. In this
section, we discuss this in detail.
The structure of the information diffusion algorithm is essentially the same. The algorithm
progresses in diffusion phases, consisting of a communication phase (corresponding to a single
round in the considered E CON GE ST model) where nodes send their (pref ix, suspicious)
values, after which nodes change their pref ix variable depending on the (pref ix, suspicious)
pairs received. Recall the 5 rules presented in Sect. 3.1.1: the set of the different possible
changes for the pref ix variable is of a constant size, and these changes are meant to affect at
most a constant number of (the last) bits of pref ix. An important point in [5] is the proof
that this set of changes allows the maximum identifier to spread over the network, in an
optimal O(D + log n) number of phases. We use the same constantsize set of changes (for
pref ix). That is why Lemma 1 also applies to our algorithm.
However, the other core element of their information diffusion algorithm, the
communication phase, cannot be used in BEEP. In [5], nodes maintain uptodate copies of the
pref ix variables of their neighbors to circumvent the limited message size and can keep
these copies uptodate in a single communication phase of O(1) rounds. In such a phase,
nodes communicate what change was carried out (and which neighbor sent which message):
sending the type of change is equivalent to sending the complete pref ix value in this situation.
In BEEP, nodes are unable to know which neighbor sent which message. Although this
capability can be simulated, it is unlikely that it can be done without increasing the time
complexity of [5]. Current methods result in a O(?4) multiplicative factor (see discussion in
Sect. 1.1).
One of the main contributions of this work is the introduction of the kbalanced message
method to leverage the local constraints between (unbounded) values, which allows to
communicate in O(1) rounds. With the kbalanced message technique, a node can transmit a
value of pref ix to its neighbors in O(1) rounds (of BEEP) only. This communication process
differs greatly from that of [5].
3.2
Uniform Terminating Leader Election (Explicit LE)
Being often used as a primitive, the LE algorithm must be uniform and detect termination
(e.g., so that it can be composed with other algorithms). Since classical approaches are not
suited to BEEP, we propose an explicit leader election algorithm using a different termination
detection approach. Notice that, as mentioned previously, it is simple (in a synchronous
setting) to transform the uniform eventual leader election algorithm, Algorithm 1, into a
nonuniform one using knowledge of D and N , and thus of the time complexity expressed in
terms of these parameters. Then, candidates can wait until the algorithm terminates, by
counting rounds corresponding to the evaluated time complexity. However, this technique
cannot be used here.
Instead, we use a primitive called overlay networks. We briefly describe it in Sect. 3.2.1.
Then, in Sect. 3.2.2, an adapted version of this primitive is used to create a uniform
termination detection component. This component is combined with the previously presented
eventual leader election algorithm to obtain uniform explicit leader election.
3.2.1
Overlay network
The overlay network approach, in the context of leader election, was first used for BEEP in
[12]. Such an overlay has a designated root, and consists of layers centered around the root.
Nodes at a distance d from that root (level d), have up links (resp. down links) towards
all neighboring nodes (of the overlay) at distance d ? 1 (resp. at distance d + 1) from the
root. Using these (virtual) links, the root can gather information about the network and
disseminate it. The default behavior for nonroot overlay nodes is to relay any beep received
over an up (resp. down) link in some phase p, to all down (resp. up) links in phase p + 1.
Algorithm 2 Uniform Terminating Leader Election Algorithm.
1: IN: id: identifier ; OUT: leader: boolean, leaderId: identifier
2: candidate := true, pref ix := , suspicious := f alse . is the empty word
3: leaderId := 0, leader := f alse
4: for diffusion phase p := 1 ; p++ do
5: // First, a communication phase with c = O(1) rounds.
6: Communicate (pref ix, suspicious) to all neighboring nodes.
7: // Then, apply predicates of rules 1 to 5 on received (pref ix, suspicious) pairs.
8: Use received (pref ix, suspicious) values to update pref ix, candidate and suspicious.
9: // Finally, termination detection phase with s = O(1) rounds.
10: Execute a termination detection phase.
11: if candidate and pref ix = ?(id) then
12: If no beep is heard in down links, exit the loop.
13: else
14: If a beep is heard in up links, exit the loop.
15: leaderId := ??1(pref ix)
16: if candidate then leader := true . Last candidate becomes the leader
In more detail, overlays work in the following way. Time is divided into overlay phases of
9 rounds, where each phase consists of 3 subphases of 3 rounds each. The first 3 rounds are
called control rounds, the next 3  up rounds and the last 3  down rounds. Each set of 3
rounds is numbered from 0 to 2.
When nodes join the overlay, they initialize a depth variable (in {0, 1, 2}), through which
they know some information about their layer (and thus how to communicate with the
other layers). The root node joins the overlay at a given time, and assigns itself depth := 0.
The other nodes willing to join the overlay listen in all control rounds. Since overlay nodes
beep in the control round depth (in all overlay phases), the joining nodes assign themselves
depth = beepHeard + 1 (mod 3), where beepHeard is the smallest control round in which a
beep was heard.
It is important that the depth variable satisfies some local constraints, to be guaranteed
by the joining process. More specifically, for any distance d and for any given (overlay) node
v in level d, all neighboring (overlay) nodes u in level d ? 1 (resp. in level d + 1) must have
depthu = depthv ? 1 (mod 3) (resp. depthu = depthv + 1 (mod 3)), where ?1 (mod 3) = 2.
With this property, nodes can listen over an up link (resp. down link) by listening in up
(resp. down) round depth ? 1 (mod 3) (resp. depth + 1 (mod 3)). Moreover, nodes beep over
an up link (resp. down link) by beeping in up (resp. down) round depth (mod 3). In other
words, communication through up and down links is the same as sending, or listening for, a
depth message (using the multislot design pattern from [4], described in Sect. 3.1.2) using
the corresponding subphase (a message from Mdepth = {0, 1, 2}).
3.2.2
Termination detection component for explicit leader election
We describe the proposed termination detection component and its interactions with the
eventual leader election algorithm (Algorithm 1). The termination detection component is
meant to gather information from the whole network, on whether there are any candidates
with a higher ?id. If there are none, the last candidate terminates and becomes leader. The
combined final algorithm structure is given in Algorithm 2.
As in Algorithm 1, time is divided into diffusion phases, but these phases now include an
additional termination detection phase. A termination detection phase consists of a border
detection phase followed by an adapted overlay phase. The border detection phase is a
communication phase for messages in Mprefix = {1, .., 13} ? {1, . . . , 26}, where nodes can
detect if any of their neighbors has a different pref ix value (similar to the communication
in Sect. 3.1.3). If that is the case for an overlay node (even the root) which has been part
of the overlay for more than 6 phases, this node becomes a border node (i.e., there exists a
neighbor with a different pref ix value). The adapted overlay phase is a communication phase
with 3 subphases, each for messages in Mdepth ? Mprefix. Each adapted overlay network is
associated to a specific pref ix (i.e., that of the overlay?s root, necessarily a candidate node).
This prefix is used (communicated) so that nodes can detect whether the other endpoint of a
down link or up link, is part of the same overlay (i.e., has the same pref ix). Consequently,
different overlay networks do not interfere with each other. A border detection phase has
Mprefix rounds and an adapted overlay phase has 9Mprefix rounds, thus a termination
detection phase has s = 10Mprefix rounds.
Upon having a wellformed pref ix, each candidate designates itself as root and starts
constructing an overlay network by using the termination detection phase. Nodes which have
just joined the overlay and border nodes beep in their up links (relayed all the way back to
the root) using the adapted overlay phase. As a result, the root hears beeps in its down
links in each (termination detection) phase, until the overlay network covers the whole graph
(Lemma 5). Moreover, the only overlay that can cover the whole graph is the overlay of the
highest ?id node (because this node never changes pref ix depending on another node?s
?id, and consequently never joins another candidate?s overlay). Therefore, when the root
hears no beeps in its down links (and is not a border node), it knows that its overlay covers
the whole graph, and that it is the highest ?id node (thus the maximum id node). All other
roots hear beeps in down links (or become border nodes), until their pref ix is changed.
In more detail, the construction of the adapted overlay networks is done as follows. Once
a candidate node has a wellformed pref ix (after exactly ?(id) diffusion phases), it sets
itself up as an overlay?s root (in phase p = ?(id)), but it stays silent for 6 termination
detection phases (from phase p to phase p + 5) before beeping in the control rounds of phase
p + 6 (and only in this phase). On the other hand, follower nodes with a wellformed pref ix
attempt to join the overlay corresponding to pref ix right away. Once a follower node joins an
overlay (in phase p0), it also stays silent for 6 termination detection phases before beeping in
the control rounds of phase p0 + 6. For any given node v that joins an overlay in termination
detection phase p0, its neighbors know if they join v?s overlay or not, by phase p0 + 6 at the
latest (by Theorem 2). By staying silent for 6 termination detection phases upon joining, v
ensures that all of its neighbors join the overlay at the same time (if they choose to join).
Consequently, two nodes u and v, at the same distance d from an overlay?s root r, never join
r?s overlay in different termination detection phases, and depthu = depthv. Otherwise, we
could have depthu 6= depthv, which means a common neighbor of u and v at distance d ? 1
from r would not have properly defined down links.
I Lemma 4. Let r be the root of an overlay network. This overlay is properly constructed,
that is, nodes at level d have the same depth value.
Proof. Let us prove by induction that if a node at distance d from r joins r?s overlay, then
it is in phase ?(idr) + 6d. Let us first consider a node v at distance 1 from r. For node
v to join r?s overlay, another overlay node must beep in the control rounds and pref ixv
must be equal to ?(idr), in the same phase. Notice that for any given two neighbors u
and v, which are in different overlays, both nodes beep in different control rounds, because
pref ixu 6= pref ixv.
In phase ?(idr) + 6, r beeps in the control rounds, and thus v can join in that phase (if
pref ixv = ?(idr)). In addition, if pref ixv 6= ?(idr) in phase ?(idr) + 6, then by Theorem
2, node v does not consider ?(idr) as the highest pref ix value it has encountered. As a
result, it is impossible that pref ixv = ?(idr) after phase ?(idr) + 6, and that v joins r?s
overlay after phase ?(idr) + 6. The induction step (d > 1) is similar, starting from a node
v at distance d from r. J
Because the adapted overlay networks are properly constructed, we can prove that as
long as an overlay has not covered the whole network, follower nodes beep in their up links,
stopping the root from becoming a leader. In more detail, after a candidate node beeps in
the control rounds, it listens to its down links in every termination detection phase. As long
as it hears a beep in these links, or is a border node, it does not become leader. Once no
beep is heard, it becomes leader, sends a beep in its down links and terminates. On the other
hand, after a follower node joins the overlay (in phase p), its beeps in its up links in the first
7 termination detection phases (from phase p to phase p + 6). It also beeps in the up links if
it is a border node (and relays any beep heard through a down link). Finally, when a follower
node hears a beep in its up links, it terminates. Consequently, before an overlay network
covers the whole network, the root receives beeps in every (termination detection) phase.
I Lemma 5. Let r be the root of an overlay network. Then from diffusion phase ?(idr) + 6
onwards, node r hears beeps in its down links every phase, until it becomes a border node
itself, or until its overlay covers the whole network.
Proof. Let r be the root of an overlay network. From Lem. 4, r?s overlay network is properly
constructed, therefore the virtual links can be used. We define a (overlay) downwards path
from node v to node u, as a sequence of down links starting in v and ending in u. A node u
is downwards reachable from node v if there is an overlay downwards path from v to u.
Consider a follower node v, having just joined r?s overlay (in phase p). Node v beeps in
its up links for 7 termination detection phases after it joins (from phase p to phase p + 6).
For each additional level in the overlay with nodes downwards reachable from v, v beeps in
its up links during 7 additional termination detection phases (by relaying beeps heard in its
down links, to its up links). Although the next layer (node u) is one further hop away from
the root, and starts beeping in phase p + 6, v beeps during phase p + 6 (7th termination
detection phase after it joins) and relays u?s first beep in phase p + 7. Consequently, there
is no interruption in beeps sent through the up links. If an overlay node becomes a border
node (some of its neighbors do not join in phase p + 6), then it beeps in up links in all phases
p0 > p + 6. If it exits the overlay, then its neighbors closer to the root become border nodes
and beep in their up links. Therefore, the root keeps hearing beeps in its down links while
levels are added to its overlay, but also if one of its overlay nodes becomes a border node. In
that latter case, the root does not have the maximum id, and hears beeps in its down links
until it becomes a border node itself. J
I Theorem 6. Explicit Leader Election is solved (uniformly) in O(D + log n) rounds in the
beeping model.
Proof. The maximum identifier node v starts to construct its overlay network in phase
?(idv) + 6, which is O(log n). For any given node u 6= v, pref ixv never modifies its bits to
match pref ixu. Consequently, v never joins u?s overlay and v?s overlay is the only one to
grow until it covers the whole network, at a rate of adding a level every 6 diffusion phases.
Thus, v?s overlay covers the whole network after an additional O(D) diffusion phases. Node
v hears beeps in its down links for another additional O(D) phases, since beeps from the
last nodes to join the overlay take O(D) rounds to reach v. After that, node v no longer
hears beeps in its down links (Lemma 5) and is the only node in the network to terminate as
leader. Then, it beeps in its down links, so that all nodes can terminate. J
3.3
Discussion and Perspectives
The deterministic LE algorithm presented in this section works without any change with an
arbitrary (unbounded) id space {1, . . . , U }. In this case, its time complexity is O(D + log U ).
For an unbounded id space, a known result from distributed bit complexity [11] gives a lower
bound of ?(log U ) for a network with two nodes. This implies a lower bound of ?(D + log U )
for multihop networks. Consequently, the presented algorithm is asymptotically timeoptimal
even with an unbounded id space.
Furthermore, the algorithm can be modified to work if it starts with only a subset of
nodes as candidates, or if the ids are not unique (as long as the highest idencoding is still
unique). Since a set of (nonunique) ids with a unique maximum can be generated without
knowing n or N [17], this last variant can then be applied to obtain a randomized uniform
(in both n and D) leader election algorithm.
4
Additional Results
LE is an important and oftenused primitive when designing distributed algorithms. Thus, it
makes sense that improving the time complexity of LE results in improved time complexities
for other tasks. We propose improved algorithms for leader election in anonymous networks,
MIS and coloring (in trees), and multibroadcast.
4.1
Randomized Leader Election
When dealing with communicationrestrictive models such as BEEP, anonymity is especially
important from an application viewpoint. Indeed, when considering large scale dynamic
wireless networks, it might not be economically feasible to equip all nodes with unique
identifiers. Additionally, nodes might be prevented from revealing their unique ids (explicitly
or through their actions), due to privacy or security concerns [23]. For this case, a deterministic
algorithm assuming unique identifiers can be adapted into a randomized one (w.h.p. time
and safety guarantees) for anonymous networks, as stated in [13]. Indeed, one can generate
a unique id w.h.p. by independently sampling ?(log n) bits. But in return the knowledge of
the network size n or at least some polynomial upper bound N = O(nc), is required.
4.2
MIS and 5coloring for Trees
Symmetry breaking procedures such as maximal independent set (MIS) and coloring are
important building blocks, especially in the communicationrestrictive beeping model.
Specifically, the MIS problem consists of choosing a set of nodes (local leaders) so that there are
no two neighbors in the set (independence), and such that no other node of the network can
be added to the set without causing the loss of the independence property. On the other
hand, the ccoloring problem consists of assigning colors in {1, . . . , c} to the nodes of the
network, such that neighboring nodes have different colors.
It is wellknown that given a leader in tree networks (elected using O(D + log n) rounds), it
is simple to 2color the tree in O(D) supplementary rounds. However, MIS and coloring have
an ?(log n) lower bound (even in tree networks, as the bound from [21] holds for a graph
of disconnected pair of nodes), so this O(D + log n) 2coloring algorithm is non optimal for
most communication graphs. Still, using the proposed uniform leader election algorithm,
we design uniform, asymptotically timeoptimal O(log n) MIS and 5coloring algorithms in
BEEP, for tree networks.
We first give the algorithmic description of the 5coloring algorithm. Roughly, low degree
nodes are colored first using 3 colors, and the remaining nodes form a subgraph where
the connected components have at most a logarithmic diameter. Using the LE algorithm,
these connected components can be 2colored in a logarithmic number of rounds. Now, we
give more details as to how these steps are achieved. First, the LimitedDegreeColoring
algorithm from [3] is used to 3color all nodes v with deg(v) ? 2, in O(log n) rounds. Then,
since all remaining nodes have a degree of at least 3, every remaining (noncolored) connected
component (a tree) has a diameter of at most log n. Thus, electing a leader for each such
connected component requires O(log n) rounds. It is wellknown that, in trees, coloring nodes
according to their distance to the root can be done using 2 colors. This distance can be learnt
by all nodes in O(log n) rounds. Specifically, nodes are synchronized after the leader election,
and the leader broadcasts a beep, using a beep wave [13, 10] or reusing the overlay network
from the leader election. The phase in which a node receives the broadcasted beep indicates
its distance to the leader. Therefore the remaining noncolored nodes can be colored with
another 2 colors, resulting in a 5coloring for the communication graph.
From this 5coloring, it is simple to compute an MIS in 5 additional rounds. Nodes with
the same color form an independent set. Adding iteratively (at each round) nodes from
each such set to a common independent set results in an MIS. Consequently, an MIS on the
communication graph can also be computed in O(log n) rounds.
Notice that since all parts of the uniform 5coloring algorithm are themselves uniform, it is
a bit tricky to force nodes to resynchronize during the sequential execution. For this purpose,
we use the EBET technique [3], to provide synchronization points in a uniform fashion  that
is possible because, for every component of the proposed algorithm, the terminal state at a
node can be detected locally  and thus solve the issue.
4.3
MultiBroadcast with Provenance
Efficient communication primitives are fundamental building blocks in distributed computing,
both for obtaining efficient algorithms and providing convenient abstractions of the actual
communication mechanisms. These primitives are of even greater importance in BEEP.
When compared to other messagepassing models, it is far more difficult to communicate
messages throughout the network with beeps.
Now, consider the multibroadcast problem. Multiple sources (k sources) have each a
message they have to broadcast to all other nodes in the network. All messages are in
{1, . . . , M }. In multibroadcast with provenance, the k sources need to communicate their
message, associated with their id, to all nodes in the network. In [10], an O(D?log n+k log nkM )
round algorithm is given and the authors conjecture that the D ? log n term might be a lower
bound. By presenting an O(D + log n) deterministic LE algorithm, this work shows that
leader election is not a bottleneck for the multibroadcast problem (whereas the previous
deterministic LE algorithm required O(D ? log n) rounds). This suggests that D ? log n might
be reducible to D in both the deterministic and randomized cases.
The multibroadcast with provenance algorithm in [10] can be divided into three core
components: leader election, communicating the ids of all k sources and finally using the
order of these ids to communicate all messages properly to the leader (which then broadcasts
the information to the network). In [10], the second component relies on the leader and
10
1
01
10
010
performs k simultaneous binary searches, in O(D ? log n + k log n ) rounds. Our contribution
k
for this problem lies in improving the time complexities of the first and second components.
The previous section (Sect. 3) improves the first component ([10] uses the leader election
from [12]). More precisely, we use the leader election variant mentioned in Sect. 3.3, where
the candidates can be a subset of all nodes. Here, only sources are candidates and the elected
leader is the source with the maximum id. As for the second component, it is improved
(whenever the number of sources k is sublogarithmic) by executing k ? 1 consecutive (variant)
leader elections, where each leader election selects the source with the maximum id amongst
the remaining nonelected sources. Notice that if nodes use their complete id for all k ? 1
consecutive leader elections, the time complexity is O(k ? (D + log n)) rounds. By being more
efficient and leveraging the information communicated through the previous leader elections,
k ? 1 consecutive leader elections are executed in O(k ? D + k log n ) rounds only.
k
This result hinges on a compact manner of representing k unique values, which compresses
the k log n bits required to communicate k identifiers consecutively, into k log nk bits. As
shown in Figure 1, after communicating id1 (6 bits), communicating id2 only takes one
bit, and after that communicating id3 takes an additional 3 bits. Thus, with this compact
representation, after the first leader is elected (amongst sources), subsequent leader elections
are more efficient as candidates for subsequent leader elections (nonelected sources) are
not required to communicate their whole id. For this reason, we introduce the ?encoding:
?(i) = 0bin k 1 k bin for an integer i and its binary representation bin. Contrary to
?encodings, the highest ?encoding is produced by integers with the shortest but highest
binary representations.
Assume that all candidates for leader election (sources which have not yet been
elected) are given an identifier greaterID, greater than their own. They compute a reduced
identifier reducedID, consisting of all bits from the first difference with greaterID onwards.
Communicating reducedID to other nodes is, in this setting, the same as communicating id
since these other nodes have knowledge of greaterID and thus deduce id from reducedID.
Now, if candidates use the proposed deterministic LE algorithm with ?(reducedID), then
the algorithm elects the node with the next maximum id value. Using this, the ids of all k
sources are communicated to all nodes in O(k ? D + k log n ) rounds.
k
Thus, executing both k ? 1 consecutive leader elections and k binary searches in parallel,
the k ids (of the sources) are communicated to all nodes in O(min{k, log n} ? D + k log n )
k
rounds. Then, the messages are gathered and broadcast using the leader, in a further
O(D + k log M ) rounds, resulting in a O(min{k, log n} ? D + k log nkM ) algorithm for
multibroadcast with provenance.
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Y. Afek , N. Alon , Z. BarJoseph , A. Cornejo , B. Haeupler , and F. Kuhn . Beeping a maximal independent set . Distributed Computing , 26 ( 4 ): 195  208 , Aug 2013 .
D. Alistarh , A. Cornejo , M. Ghaffari , and N. Lynch . Firefly synchronization with asynchronous wakeup . In Workshop on Biological Distributed Algorithms , 2014 .
J. Beauquier , J. Burman , F. Dufoulon , and S. Kutten . Fast Beeping Protocols for Deterministic MIS and (?+1)Coloring in Sparse Graphs . In IEEE INFOCOM , 2018 , to appear.
A. Casteigts , Y. M?tivier , J. M. Robson , and A. Zemmari . Design Patterns in Beeping Algorithms . In OPODIS, pages 15 : 1  15 : 16 , 2016 .
A. Casteigts , Y. M?tivier , J.M. Robson , and A. Zemmari . Deterministic leader election in O(D + log n) time with messages of size O(1) . In DISC , pages 16  28 , 2016 .
I. Chlamtac and S. Kutten . On broadcasting in radio networks  problem analysis and protocol design . IEEE Transactions on Communications , 33 ( 12 ): 1240  1246 , 1985 .
A. Cornejo and F. Kuhn . Deploying wireless networks with beeps . In DISC , pages 148  162 , 2010 .
A. Czumaj and P. Davies . Optimal leader election in multihop radio networks . ArXiv eprints, 2015 . arXiv: 1505 . 06149 .
A. Czumaj and P. Davies . Brief announcement: Optimal leader election in multihop radio networks . In PODC , pages 47  49 , 2016 .
A. Czumaj and P. Davies . Communicating with Beeps . In OPODIS , pages 1  16 , 2016 .
Y. Dinitz and N. Solomon . Two absolute bounds for distributed bit complexity . In Structural Information and Communication Complexity , pages 115  126 , 2005 .
K.T. F?rster , J. Seidel , and R. Wattenhofer . Deterministic leader election in multihop beeping networks . In DISC , pages 212  226 , 2014 .
M. Ghaffari and B. Haeupler . Near optimal leader election in multihop radio networks . In SODA , pages 748  766 , 2013 .
S. Gilbert and C. Newport . The computational power of beeps . In DISC , pages 31  46 , 2015 .
R. Guerraoui and A. Maurer . Byzantine fireflies . In DISC , pages 47  59 , 2015 .
S. Kutten , G. Pandurangan , D. Peleg , P. Robinson , and A. Trehan . On the complexity of universal leader election . In PODC , pages 100  109 , 2013 .
Y. M?tivier , J.M. Robson , and A. Zemmari . Analysis of fully distributed splitting and naming probabilistic procedures and applications . Theoretical Computer Science , 584 : 115  130 , 2015 . Special Issue on Structural Information and Communication Complexity .
K. Nakano and S. Olariu . Randomized o(log log n)round leader election protocols in packet radio networks . In Algorithms and Computation , pages 210  219 , 1998 .
S. Navlakha and Z. BarJoseph . Distributed information processing in biological and computational systems . Commun. ACM , 58 ( 1 ): 94  102 , 2014 .
D. Peleg . Timeefficient broadcasting in radio networks: A review . In Distributed Computing and Internet Technology , pages 1  18 , Berlin, Heidelberg, 2007 . Springer Berlin Heidelberg.
J. Schneider and R. Wattenhofer . What is the use of collision detection (in wireless networks)? In DISC , pages 133  147 , 2010 .
A. Scott , P. Jeavons, and L. Xu . Feedback from nature: An optimal distributed algorithm for maximal independent set selection . In PODC , pages 147  156 , 2013 .
J. Seidel . Anonymous distributed computing: computability, randomization and checkability . PhD thesis , ETH Zurich, Z?rich, Switzerland, 2015 . URL: http://dnb. info/ 1080812695.