Leader Election in Well-Connected Graphs

TL;DR

This paper introduces an efficient randomized leader election algorithm for well-connected networks, achieving sublinear message complexity and time, and establishes lower bounds linking graph conductance to the problem's complexity.

Contribution

It presents the first algorithm with explicit message and time bounds based on network mixing time and conductance, and provides matching lower bounds for leader election complexity.

Findings

Algorithm achieves $O(\sqrt{n} \log^{7/2} n _{mix})$ messages and $O(t_{mix}\log^2 n)$ time.

Lower bounds show $\Omega(\sqrt{n}/\phi^{3/4})$ messages are necessary, linking connectivity to complexity.

Results apply to well-connected networks like expanders and hypercubes.

Abstract

In this paper, we look at the problem of randomized leader election in synchronous distributed networks with a special focus on the message complexity. We provide an algorithm that solves the implicit version of leader election (where non-leader nodes need not be aware of the identity of the leader) in any general network with $O(\sqrt{n} \log^{7/2} n \cdot t_{mix})$ messages and in $O(t_{mix}\log^2 n)$ time, where $n$ is the number of nodes and $t_{mix}$ refers to the mixing time of a random walk in the network graph $G$. For several classes of well-connected networks (that have a large conductance or alternatively small mixing times e.g. expanders, hypercubes, etc), the above result implies extremely efficient (sublinear running time and messages) leader election algorithms. Correspondingly, we show that any substantial improvement is not possible over our algorithm, by presenting an almost matching lower bound for randomized leader election. We show that $\Omega(\sqrt{n}/\phi^{3/4})$ messages are needed for any leader election algorithm that succeeds with probability at least $1-o(1)$, where $\phi$ refers to the conductance of a graph. To the best of our knowledge, this is the first work that shows a dependence between the time and message complexity to solve leader election and the connectivity of the graph $G$, which is often characterized by the graph's conductance $\phi$. Apart from the $\Omega(m)$ bound in [Kutten et al., J.ACM 2015] (where $m$ denotes the number of edges of the graph), this work also provides one of the first non-trivial lower bounds for leader election in general networks.

Equations

$$\Theta (1/\varphi )⩽t_{mix}⩽\Theta (1/{\varphi }^2)$$

$$\mathrm{Pr}\mathopen{}\mathclose{{}\left[w_{i}\text{ has a distinct proxy}}\right]\geqslant\mathopen{}\mathclose{{}\left(1-\frac{1}{n}}\right)^{c_{2}\sqrt{n\log n}}\geqslant\exp\mathopen{}\mathclose{{}\left(-c_{2}\sqrt{\frac{\log n}{n}}}\right)\geqslant 1-c_{2}\sqrt{\frac{\log n}{n}}$$

$$\mathbb{E}\mathopen{}\mathclose{{}\left[\sum_{i=0}^{c_{2}\sqrt{n\log n}}Y_{i}}\right]=c_{2}\sqrt{\frac{\log n}{n}}\cdot c_{2}\sqrt{n\log n}={c_{2}}^{2}\log n$$

$$\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{i=0}^{c_{2}\sqrt{n\log n}}Y_{i}\geqslant\mathopen{}\mathclose{{}\left(1-\frac{1}{2}}\right){c_{2}}^{2}\log n}\right]\leqslant\exp\mathopen{}\mathclose{{}\left(-{c_{2}}^{2}\log(n)/2}\right)\leqslant\frac{1}{n^{({c_{2}}^{2}/2)}}$$

$$\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{i=0}^{c_{2}\sqrt{n\log n}}X_{i}\geqslant\mathopen{}\mathclose{{}\left(1-\frac{1}{2}}\right){c_{2}}^{2}\log n}\right]\leqslant\exp\mathopen{}\mathclose{{}\left(-{c_{2}}^{2}\log(n)/2}\right)\leqslant\frac{1}{n^{({c_{2}}^{2}/2)}}$$

$${\varphi }_{new}=\frac{C-(k(n^{ϵ}-k)-k_2)}{V-k{n}^{ϵ}}⩽\frac{C-k{n}^{ϵ}+k^2+4}{V-k{n}^{ϵ}}<\frac{C-k{n}^{ϵ}+k{n}^{ϵ}/2+k{n}^{ϵ}/3}{V-k{n}^{ϵ}}=\frac{C-k{n}^{ϵ}/6}{V-k{n}^{ϵ}}$$

$${\varphi }_{\mathcal{K}}-{\varphi }_{new}⩾\frac{C}{V}-\frac{C-k{n}^{ϵ}/6}{V-k{n}^{ϵ}}=\frac{k{n}^{ϵ}(V/6-C)}{V(V-k{n}^{ϵ})}=\frac{Vk{n}^{ϵ}(1/6-{\varphi }_{\mathcal{K}})}{V(V-k{n}^{ϵ})}$$

$${\varphi }_{new}=\frac{C-k(n^{ϵ}-k)+k_2}{V+k{n}^{ϵ}}⩽\frac{C-k{n}^{ϵ}+k^2+4}{V+k{n}^{ϵ}}<\frac{C-k{n}^{ϵ}+k{n}^{ϵ}/2+k{n}^{ϵ}/3}{V+k{n}^{ϵ}}=\frac{C-k{n}^{ϵ}/6}{V+k{n}^{ϵ}}$$

$${\varphi }_{new}=\frac{C-k(n^{ϵ}-k)+k_2}{V_{total}-V-k{n}^{ϵ}}⩽\frac{C-k{n}^{ϵ}+k^2+4}{V_{total}-V-k{n}^{ϵ}}<\frac{C-k{n}^{ϵ}+k{n}^{ϵ}/2+k{n}^{ϵ}/3}{V_{total}-V-k{n}^{ϵ}}=\frac{C-k{n}^{ϵ}/6}{V_{total}-V-k{n}^{ϵ}}$$

$$\phi_{\mathcal{K}}-\phi_{new}\geqslant\frac{\mathopen{}\mathclose{{}\left(CV_{total}-2CV}\right)+\mathopen{}\mathclose{{}\left(Vkn^{\epsilon}/6-Ckn^{\epsilon}}\right)}{V(V_{total}-V-kn^{\epsilon})}=\frac{C\mathopen{}\mathclose{{}\left(V_{total}-2V}\right)+Vkn^{\epsilon}\mathopen{}\mathclose{{}\left(1/6-\phi_{\mathcal{K}}}\right)}{V(V_{total}-V-kn^{\epsilon})}$$

$${\varphi }_{new}=\frac{C-k(n^{ϵ}-k)+k_2}{V+n^{ϵ}(n^{ϵ}-k)}⩽\frac{C-k{n}^{ϵ}+k^2+4}{V+n^{ϵ}(n^{ϵ}-k)}<\frac{C-k{n}^{ϵ}+k{n}^{ϵ}/2+k{n}^{ϵ}/3}{V+n^{ϵ}(n^{ϵ}-k)}=\frac{C-k{n}^{ϵ}/6}{V+n^{ϵ}(n^{ϵ}-k)}$$

$$\displaystyle\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}}\right]$$

$$\displaystyle\geqslant\gamma\cdot\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}\mid\text{$|F|\geqslant B/4$ edges}}\right]$$

$$\displaystyle\geqslant\gamma\sum_{C\in F}\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}(C)\mid\text{$|F|\geqslant B/4$ edges}}\right]$$

$$\sum_{C\in F}\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}(C)\mid\text{$|F|\geqslant B/4$ edges}}\right]=\sum_{C\in F}\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}(C)}\right].$$

$$\mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}}\right]=\Omega\mathopen{}\mathclose{{}\left(\gamma n^{2\epsilon}B/4}\right)=c\gamma Mn^{2\epsilon}/4.$$

$$\mathrm{Pr}{[P\rightarrow Q]}\leqslant\frac{k}{N-j}=O\mathopen{}\mathclose{{}\left(\frac{M}{N-M}}\right)=o\mathopen{}\mathclose{{}\left(1/\sqrt{N}}\right),$$

$$\displaystyle\mathrm{Pr}\mathopen{}\mathclose{{}\left[S(t)=\kappa}\right]\geqslant\prod_{C\in\mathcal{CG}}\mathrm{Pr}\mathopen{}\mathclose{{}\left[S(C,t)=\kappa(C)}\right].$$

$$\mathrm{Pr}[S(t)=\kappa ]$$

$$⩾\sum _{\text{states }{\kappa }^{\prime }}\mathrm{Pr}[\text{ step }t\text{ transitions from }{\kappa }^{\prime }\text{ to }\kappa ]\prod _{C^{\prime }\in \mathcal{C}\mathcal{G}}\mathrm{Pr}[S(C^{\prime },t-1)={\kappa }^{\prime }(C^{\prime })],$$

$$\mathrm{Pr}[\text{ step }t\text{ transitions from }{\kappa }^{\prime }\text{ to }\kappa ]=\mathrm{Pr}[\text{C takes step: κ′→tκ}].$$

$$\mathrm{Pr}[S(t)=\kappa ]$$

$$=\prod _{C^{\prime }\ne C}\mathrm{Pr}[S(C^{\prime },t)=\kappa (C^{\prime })]\cdot \sum _{\text{κ′}}\mathrm{Pr}[\text{C takes step: κ′→tκ}]\cdot \mathrm{Pr}[S(C,t-1)={\kappa }^{\prime }(C)],$$

$$\mathrm{Pr}[\text{C takes step: κ′→tκ}]⩾\mathrm{Pr}[S(C,t)=\kappa (C)].$$

$$\mathrm{Pr}[S(t)=\kappa ]$$

$$\displaystyle\mathrm{Pr}\mathopen{}\mathclose{{}\left[F\in L}\right]$$

$$\displaystyle\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=l}\right]$$

$$\displaystyle\geqslant\sum_{Z\in\mathcal{Z}}\prod_{C}\mathrm{Pr}\mathopen{}\mathclose{{}\left[Y(C)=Z_{C}}\right]\hskip 28.45274pt\text{(by Lemma \ref{lem:addup})}$$

$$\displaystyle=\sum_{Z\in\mathcal{Z}}\prod_{C}\mathrm{Pr}\mathopen{}\mathclose{{}\left[X(C)=Z_{C}}\right]\hskip 28.45274pt\text{(by def.\ of $X(C)$)}$$

$$\displaystyle=\sum_{Z\in\mathcal{Z}}\mathrm{Pr}\mathopen{}\mathclose{{}\left[X=Z}\right]$$

$$\displaystyle\geqslant\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}X(C)=l}\right]$$

$$\displaystyle\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)>k}\right]=\sum_{l=k+1}^{N}\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=l}\right]\geqslant\sum_{l=k+1}^{N}\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}X(C)=l}\right]=\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}X(C)>k}\right].$$

$$\displaystyle\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=0}\right]$$

$$⩾$$

$$(1-sp{)}^{n^{1-ϵ}}⩽(1-1/n^{1-ϵ}{)}^{n^{1-ϵ}}⩽1/e.$$

Full text

1 Introduction

Leader election is one of the most classical and fundamental problem in the field of distributed computing having applications in numerous problems relating to synchronization, resource allocation, reliable replication, load balancing, job scheduling (in master slave environment), crash recovery, membership maintenance etc. Computing a leader can be thought of as a form of symmetry breaking, where exactly one special node or process (denoted as leader) is chosen to take some critical decisions.

Loosely speaking, the problem of leader election requires a set of nodes in a distributed network to elect a unique leader among themselves, i.e., exactly one node must output the decision that it is the leader. There are two well known variants of this problem (cf. [3, 27]), the explicit variant where at the end of the election process all the nodes are required to be aware of the identity of the leader and the implicit variant where the non-leader nodes need not be aware of the identity of the leader.

Often, the implicit variant is sufficient for many practical applications, e.g. its original application for token generation in token ring environments [26] etc. This variant also allows us to clearly distinguish between the two aspects of explicit leader election and costs associated to each of them, i.e. electing a leader (implicitly) as compared to broadcasting the unique id of the leader to all the other nodes. Clearly, any solution for the explicit variant of leader election also solves the implicit variant. However, it is to be noted that any solution for the implicit leader election could solve explicit leader election by broadcasting the identity of the leader to all the nodes. In this paper, we mainly focus on the implicit variant of leader election on a network without edge or link failures.

Compared to deterministic solutions that provide absolute guarantees for the election of a unique leader, randomized solutions guarantees unique leader election with high probability. However, this weakened assumption is still sufficient for many practical applications. With an acceptable error probability, randomization can result in a significant reduction in time and message complexities. This is highly advantageous for large scale distributed systems (e.g. P2P systems, overlay and sensor networks [35, 36, 40]), where scalability is an important issue. Furthermore, in anonymous networks, a randomized solution is often possible by randomly assigning unique identifiers to nodes (as done herein) whereas a corresponding deterministic solution is impossible (see [2]).

This paper focuses on studying the message complexity of implicit leader election in synchronous distributed networks. Here, we show the relationship between the graph connectivity (which is characterized by the graph’s conductance $\phi$) with the time and number of messages required for leader election. We provide an algorithm that solves implicit leader election in any general network with $\tilde{O}(\sqrt{n}\cdot t_{mix})$ messages and in $\tilde{O}(t_{mix})$ time, where $n$ is the number of nodes and $t_{mix}$ refers to the mixing time of a random walk in the network graph $G$.111Throughout the paper, we use the $\tilde{O}$ notation to hide $\log n$ factors. Correspondingly, we show that $\Omega(\sqrt{n}/(\phi)^{3/4})$ messages are needed for any leader election algorithm that succeeds with high probability, where $\phi$ refers to the graph’s conductance. We also show that the knowledge of the network size $n$ is critical to achieve the said message and time complexities, but surprisingly, knowledge of other graph properties, such as the conductance, mixing time, or diameter is not needed.

Computing Model.  We model the network as a connected, undirected graph $G=(V,E)$ with $|V|=n$ nodes and $|E|=m$ edges where nodes communicate over the graph edges. We assume synchronous communication that follows the standard $\mathcal{CONGEST}$ model [32]. In each round, each node can perform some local computation which can involve accessing a private source of randomness. Additionally, each node $u$ is allowed to send a message of size $O(\log n)$ bits through each edge $(u,v)$ incident on $u$. Nodes do not have predefined ids and there are no node or link failures.

Port Numbering Model.  We assume that the nodes know the network size $n$ and wake up simultaneously at the beginning of the execution. Also, nodes are anonymous in the sense that they do not have unique IDs.222Our lower bound holds even if nodes start with unique IDs. Each node chooses an id uniformly at random from within the range $[1,n^{4}]$.333This range guarantees that the chosen values are unique with high probability [27] (Chapter 4, page 72). Each node $u$ with degree $|d_{u}|$ has ports $1,\dots,d_{u}$, over which it can send messages across undirected links to its neighbors; that is, each neighbor of $u$ is the endpoint of exactly $1$ of $u$’s ports. Nodes only know the port numbers of connections and are unaware of their neighbors’ identities. We do not assume these mappings to be symmetric: in particular, it can happen that $u$ is connected to $v$ via port number $i$, whereas $v$ is connected to $u$ via port number $j\neq i$.

Randomized Implicit Leader Election.  Every node of a given distributed network has a flag variable (or a boolean variable) initialized to [math] and, after the process of election, with high probability (w.h.p), only one node, called the leader, raises its flag by setting the flag variable to $1$. An algorithm $\mathcal{A}$ is said to solve leader election in $T$ rounds, if within $T$ rounds nodes elect a unique leader w.h.p., and none of the nodes send any more messages after $T$ rounds.

Results.  In this paper, we present both upper and lower bounds for the problem of implicit leader election in general networks. We provide an algorithm that solves implicit leader election in any general network with $O(\sqrt{n}\log^{7/2}n\cdot t_{mix})$ messages and in $O(t_{mix}\log^{2}n)$ time, where $n$ is the number of nodes and $t_{mix}$ refers to the mixing time of a random walk in the network graph $G$. If larger message sizes of $O(\log^{3}n)$ is allowed, the message and time complexity reduces to $O(\sqrt{n}\log^{3/2}n\cdot t_{mix})$ and $O(t_{mix})$ respectively. This implies significantly faster and efficient solutions (that are sub-linear in terms of message complexity) for leader election in several important classes of well-connected graphs that have a large conductance or alternatively a small mixing time. For example, to solve implicit leader election, in expander graphs (see [20] for applications) that have a mixing time of $O(\log n)$, it takes only $O(\log^{3}n)$ time and $O(\sqrt{n}\log^{9/2}n)$ messages; in hypercube graphs, that have a mixing time of $O(\log n\log\log n)$, it takes only $O(\log^{3}n\log\log n)$ time and $O(\sqrt{n}\log^{9/2}n\log\log n)$ messages. The algorithm can also be used for solving the explicit variant of leader election by adding a broadcasting procedure, wherein the leader broadcasts its identity to all other nodes. For well connected graphs, this breaks the $\Omega(m)$ lower bound given in [24] (where $m$ denotes the number of edges of the graph) and nearly matches the $\Omega(\sqrt{n})$ lower bound for clique graphs [25] (as cliques have constant conductance).

We show that a dependence on the graph conductance is unavoidable, by presenting a message complexity lower bound of $\Omega(\sqrt{n}/\phi^{3/4})$ messages that holds for any leader election algorithm that succeeds with probability at least $1-o(1)$. This nearly matches the upper bound since we know that $\Theta(1/\phi)\leqslant t_{mix}\leqslant\Theta(1/{\phi}^{2})$ from [37].

By a similar analysis, we also provide lower bounds for other graph problems like broadcast and spanning tree construction in terms of the graph’s conductance. Our lower bounds also apply for the $\mathcal{LOCAL}$ model [32], where there are no restrictions on the message size. Other than the $\Omega(m)$ bound in [24], to the best of our knowledge, this is the first non-trivial lower bound for randomized leader election in general networks. Also, ours is one of the first results to show the dependence of the time and message complexity to solve leader election on the connectivity of the graph $G$, which is often characterized by the graph’s conductance $\phi$.

Additionally, we show that the knowledge of the network size $n$ is critical for our algorithm to succeed by giving a lower bound of $\Omega(m)$ for all graphs if $n$ is not known. However surprisingly, the knowledge of other graph properties, like the conductance, mixing time, or diameter is not needed.

Prior Works.  Leader election, being one of the fundamental paradigms in the theory of distributed computing has been widely studied. The problem was first stated by Gérard Le Lann in [26] in the context of token ring networks, and thereafter has been extensively studied for various types of networks, scenarios and communication models. For particular types of networks topologies like token rings, mesh, torus, hypercubes and cliques the problem of leader election has been well-studied resulting in specialized algorithms and lower bounds in terms of both, time and message complexities (e.g. [10, 12, 39, 32, 27, 14, 1, 23, 25, 34] and references therein). In a seminal paper Gallager, Humblet and Spira [16], provided a deterministic solution for general graphs by finding the minimum spanning tree of the graph in $O(n\log n)$ time and exchanging a total of $O(m\log n)$ messages. Thereafter, Awerbuch [5] provided an $O(n)$ round deterministic algorithm with a message complexity of $O(m+n\log n)$ messages, where $m$ refers to the total number of edges in the graph. Peleg [33] provided an $O(D)$ time optimal algorithm for leader election with a message complexity of $O(mD)$, where $D$ the diameter of the graph. More recently, in [24], the authors provide an algorithm that requires only $O(m)$ messages though it could take arbitrary (albeit finite) time. There also exists significant amount of literature (see [19, 13, 38, 9] and references therein) that provides a solution for leader election on fault prone networks, with possible node or link failures.

The best known bounds for general graphs are as follows. In [24] Kutten et al. show that $\Omega(m)$ is the lower bound on messages and $\Omega(D)$ is the lower bound on time for any implicit leader election algorithm. They compare and contrast the deterministic algorithms to randomized algorithms while trying to simultaneously achieve optimal time and message complexity for leader election. Unlike the deterministic case where an algorithm cannot be simultaneously time and message optimal (e.g. in a cycle any $O(n)$ time deterministic algorithm requires at least $\Omega(n\log n)$ messages even when nodes know $n$ [15]), they show that for the randomized case simultaneous optimality can be achieved in certain cases. In particular, to show the bounds are tight they give an algorithm that takes $O(m)$ messages (not time optimal), an algorithm that takes $O(m\log\log n)$ messages and $O(D)$ time (almost simultaneously optimal).

In [25], Kutten et al. show that in terms of message complexity, there exists a gap between the implicit and the explicit variants of leader election. For the explicit variant, all nodes needs to be informed of the identity of the leader, and as such $\Omega(n)$ messages is the obvious lower bound for all graphs. However, for the implicit version the authors by provide a sub-linear bound algorithm on complete networks that runs in $O(1)$ rounds and (w.h.p.) uses only $O(\sqrt{n}\log^{3/2}n)$ messages to elect a unique leader (w.h.p.). Thereafter, they extend this algorithm to solve leader election on any connected graph $G$ in $O(t_{mix})$ time and $O(t_{mix}\cdot\sqrt{n}\log^{3/2}n)$ messages, where $t_{mix}$ is the mixing time of a random walk on $G$.

A key difference, however, was that they assume that every node in the graph knows the mixing time of the graph, which significantly simplifies the problem. An important challenge addressed by our algorithm is (effectively) estimating when a collection of random walks is well-enough mixed. While there is a recent result in [29] that shows how nodes can quickly estimate the mixing time of the graph, their algorithm requires $\Omega(m)$ messages and hence cannot be used for the purpose of achieving a small message complexity, where $m$ is the total number of edges in the graph.

In the context of using random sampling for leader election, the work of [4] uses random walks to limit the impact of Byzantine nodes on electing an honest leader in dynamic networks.

2 Preliminaries

In this section, we describe some basic definitions and concepts that we make use of throughout the paper. First, we give a brief overview and the definition of graph conductance. Next, we describe some basic notation for random walks on a graph $G$ including its mixing time, and state the relationship between the mixing time and the conductance of $G$.

Conductance, in general, is a characterization of the bottleneck in communication of a graph. The notion of graph conductance was introduced by Sinclair [21]. For a given graph $G=(V,E)$, a subset of nodes $U\subseteq V$ and cut $\mathcal{K}=(U,V\setminus U)$, we define $E_{\mathcal{K}}$ to be the subset of edges across the cut $\mathcal{K}$, and the volume $\mathsf{Vol}(U)=\sum_{v\in U}d_{v}$, where $d_{v}$ refers to the degree of node $v$. The cut-conductance is defined as $\phi_{\mathcal{K}}={|E_{\mathcal{K}}|}/{\min\{\mathsf{Vol}(U),\mathsf{Vol}(V\setminus U)\}}$. The conductance of the graph $G$ is defined as the minimum of the cut-conductance across all possible cuts $\tilde{\mathcal{K}}$, i.e., $\phi(G)=\min\{\phi_{\mathcal{K}}\mid{\mathcal{K}\in\tilde{\mathcal{K}}}\}$. We simply write $\phi$ instead of $\phi(G)$, when graph $G$ is clear from the context.

For a random walk on $G(V,E)$, we define a node set $V=\{v_{1},\dots,v_{n}\}$ and an $n\times n$ transition matrix $P$ of $G$. Each position of the form $P[i,i]$ in the transition matrix has an entry $p_{v_{i},v_{i}}=1/2$, else if $i\neq j$ then $P[i,j]$ has an entry $p_{v_{i},v_{j}}=1/2d_{v_{i}}$ if there is an edge $(v_{i},v_{j})\in E$, otherwise $p_{v_{i},v_{j}}=0$. At a particular step, the entry $p_{v_{i},v_{j}}$ gives the probability of a random walk moving from node $v_{i}$ to node $v_{j}$. This exactly corresponds to a lazy random walk wherein a random walk either stays in the current node with probability $1/2$; otherwise moves to a neighbor with probability $1/2d_{v_{i}}$. The probability distribution $\pi_{t}$ determined by $P$ represents the position of a random walk after $t$ steps. If some node $v_{i}$ starts a random walk, the initial distribution $\pi_{0}$ of the walk is an $n$-dimensional vector having all zeros except at index $i$ where it is $1$. After the node $v_{i}$ has chosen to forward the random walk token, either to itself or to a random neighbor, the distribution of the walk (after $1$ step) is given by $\pi_{1}=P\pi_{0}$ and in general we have $\pi_{t}=P^{t}\pi_{0}$. For any connected graph $G$, the distribution will eventually converge to the stationary distribution $\pi_{*}=(q_{1},\dots,q_{n})$, which has entries $q_{i}=d_{v_{i}}/(2|E|)$ and satisfies $\pi_{*}=P\pi_{*}$. The mixing time of an $n$-node graph $G$, $t_{mix}(G)$ is defined as the minimum $t$ such that, for each starting distribution $\pi_{0}$, $\parallel P\pi_{t}-\pi_{*}\parallel_{\infty}\hskip 2.84526pt\leqslant\frac{1}{2n}$, where $\parallel\cdot\parallel_{\infty}$ denotes the usual maximum norm on a vector. We simply write $t_{mix}$ instead of $t_{mix}(G)$, when graph $G$ is clear from the context.

Note that, the connectedness of a graph $G$ (determined by its conductance $\phi$) and the mixing time of a random walk on $G$ are closely related. Better connectivity implies fast mixing and vice versa. There is a well known result that formally relates the graph conductance $\phi$ to the mixing time (see [37]) as follows

[TABLE]

3 A Leader Election Algorithm for Well-Connected Networks

In this section, we provide an algorithm that solves implicit leader election for any given graph $G$ with time complexity of $\tilde{O}(t_{mix})$ and more importantly, with $\tilde{O}(\sqrt{n}t_{mix})$ message complexity, where $t_{mix}$ refers to the mixing time of a random walk on the graph $G$.

The proposed algorithm, in its initial phase is similar to the algorithms given in [18, 25] where the initial objective is to reduce the number of competing nodes (contenders), while also ensuring that there exists at least one contender (w.h.p.). For this purpose, each node $v$ in the network graph $G$, elects itself as a contender with a probability of $c_{1}\log(n)/n$, where $c_{1}$ is a sufficiently large constant. As such, the probability of no node electing itself as a contender is $(1-\frac{c_{1}\log n}{n})^{n}\approx\exp(-c_{1}\log n)=n^{-c_{1}}$ ; thus, implying that w.h.p. the number of contenders is nonzero.

Now, imagine a scenario in which each of these contenders contacts a set of nodes, which we refer to as the contender’s target set. If the target set is large enough (say, $n/2+1$), then for any two contenders we can say that there would be common/intersecting node that would have communicated with both contenders. Thereafter, the contenders can communicate via this intersecting node. If all contenders have a sufficiently large target set then all contenders would be able to communicate with one another. We design our algorithm based on this idea.

First, we determine the minimum size of the target set needed to guarantee an intersection w.h.p. between the target sets of any two contenders. It can be easily shown with the birthday paradox argument that if any two contender nodes $u$ and $v$ contact $O(\sqrt{n\log n})$ random nodes, then w.h.p. there is at least one node $w$ that was chosen by both $u$ and $v$. By the definition of mixing time, if a random walk has taken at least $t_{mix}$ steps, then (for all practical purposes) its end point can be considered as a random node. Therefore, each contender node can find $O(\sqrt{n\log n})$ random nodes by performing $O(\sqrt{n\log n})$ independent random walks in parallel. The random walks essentially function as mechanisms for selecting/sampling “random” nodes, where the guarantee is if the length of the walk is long enough, the choice is close to uniform. We might as well think of the random walks as a black box that return a collection of random nodes. However, as nodes are not aware of the mixing time of the graph, this technique cannot be used directly to obtain random nodes.

Without knowledge of the mixing time, it is difficult (if not impossible) to obtain a set of nodes that are chosen uniformly at random by using random walks. Therefore, the major challenge reduces to correctly obtaining a set of possibly non-random nodes (as random walks might be of length less than the mixing time) that satisfy the required properties that we had hoped to achieve from a uniformly random chosen target set. One difficulty here lies is in determining the ideal length of the random walks of each contender without the knowledge of the mixing time. To deal with this, in our algorithm, we use a guess and double strategy where in each iteration nodes guess a length for the random walk, perform random walks of the chosen length, determine based on some criteria if the length is sufficient; if not the next iteration begins with double the previous estimate.

The critical part is to determine the criterion for which we can consider the length of the random walks to be sufficient. A natural solution would be to check if there are enough intersections in the target set (with target sets of other contenders). For example, if the target set of each contender had an intersection with target sets of all other contenders, all of them can communicate via the intersecting node(s). However, then we would require the knowledge of the exact number of contenders to determine termination, which is difficult to obtain with certainty. In fact, we show that an intersection with greater than half of the contenders is sufficient and obtainable.

Given such a criterion, it creates another challenge, as it might be the case that all the random walks do not terminate in the same round. For example, consider the case where a large number of contenders belong to the same locality of the graph and as a result they contact each other quickly, via their random walks. However, a few of the contenders do not belong to this neighborhood and are slightly far off from this locality. In this case, the target set of the locally placed contenders would belong to the same locality (and not be nearly randomly spread). As such, it would be difficult for the far flung contenders to make contact with any of the locally placed contender’s target sets, requiring much longer lengths of random walks than the mixing time. For this case, we would also need to guarantee that the random walks that terminate early are still easily discoverable.

To deal with the above challenges, we provide a twofold stopping criterion: first, we want to ensure that the end points of the random walks of a contender intersect with the random walks of at least half of the total number of contenders; second, we would also like to ensure that the end points of these random walks are sufficiently spread out, such that other random walks do not spend too much time discovering them. Another crucial part to consider is dealing with the congestion that might be caused by the information carried along the random walks.

Basically, the given randomized leader election algorithm can be divided into three major parts. First, a node makes a probabilistic decision determining its candidature, i.e., whether or not it becomes a contender. Then, in the second part, contenders guess and double length of random walks until it satisfies some required properties. Lastly, based on information retrieved from random walks, a node elects itself as the leader if it satisfies a certain winning condition.

We provide the following contender lemma which restricts the total number of possible contenders.

Lemma 1**.**

(Contender Lemma) With high probability the number of contenders is in the range $[\frac{3}{4}c_{1}\log n,\frac{5}{4}c_{1}\log n]$, where $c_{1}$ is a sufficiently large constant.

Proof.

Since each node becomes contender independently with probability $(c_{1}\log n)/{n}$, we can apply two tail bounds to show concentration around the expected number of contenders ${c_{1}\log n}$. Let $X$ be the number of contenders. By standard Chernoff Bounds (Theorems 4.4 and 4.5 in [28]), we know that \mathrm{Pr}\mathopen{}\mathclose{{}\left[X\geqslant\mathopen{}\mathclose{{}\left(1+{1}/{4}}\right)c_{1}\log n}\right]\leqslant\exp\mathopen{}\mathclose{{}\left(-\mathopen{}\mathclose{{}\left({1}/{4}}\right)^{2}c_{1}\log(n)/3}\right) and, similarly, \mathrm{Pr}\mathopen{}\mathclose{{}\left[X\leqslant\mathopen{}\mathclose{{}\left(1-{1}/{4}}\right)c_{1}\log n}\right]\leqslant\exp\mathopen{}\mathclose{{}\left(-\mathopen{}\mathclose{{}\left({1}/{4}}\right)^{2}c_{1}\log(n)/2}\right). For sufficiently large $c_{1}$, both of these bounds can be shown to hold with high probability and hence the lemma follows by a simple union bound. ∎

Each contender node $u$ creates $c_{2}\sqrt{n\log n}$ tokens and starts $c_{2}\sqrt{n\log n}$ random walks of length $t_{u}$ in parallel, where $c_{2}$ is a constant $>2$. Each random walk is represented by a token $\langle u,t_{u}\rangle$ (of $O(\log n)$ bits), where $u$ represents the node’s id, and $t_{u}$ represents the length of the random walk. At each step of the random walk $t_{u}$ is decremented by 1, until it finally becomes 0. We define proxies of node $u$ as the nodes where the random walks generated by $u$ complete $t_{u}$ steps, where $t_{u}$ is either $u$’s current or final guess of the length of the random walk. Two contender nodes are said to be adjacent if they share at least one proxy.

The algorithm guarantees the following properties at the end of the execution:

• •

Intersection Property: A contender $u$ satisfies the intersection property iff $u$ is adjacent to at least $\geqslant\frac{3}{4}c_{1}\log n$ of the other contender nodes. Using Lemma 1, we see that any node which satisfies the intersection property is adjacent to greater than half of the total number of contenders (as \frac{3}{4}c_{1}\log n\geqslant\frac{1}{2}\mathopen{}\mathclose{{}\left(\frac{5}{4}c_{1}\log n}\right)) w.h.p.

• •

Distinctness Property: A contender node $u$ satisfies the distinctness property if $\geqslant\tfrac{c_{2}}{2}\sqrt{n\log n}$ of its proxies are distinct. For a particular guess of $t_{u}$, a proxy $p_{u}$ of a random walk belonging to $u$ is called a distinct proxy only if $p_{u}$ is the end node of exactly one random walk belonging to $u$ (from among the $c_{2}\sqrt{n\log n}$ many random walks belonging to $u$) i.e. no other random walks belonging to $u$ ends at $p_{u}$. For any contender node, the spreading out of its random walks is characterized by the number of distinct proxies.

In the $\mathcal{CONGEST}$ model, due to the restriction on the message size, it is impossible to perform too many walks in parallel along an edge. We solve this issue by sending only one token and the count of tokens that need to be sent by a particular contender which is still $O(\log n)$, and not all the tokens themselves. Similarly, our algorithm also requires some id information (set of ids of other contenders) to be sent along the random walk. We note that the maximum possible number of contenders is $\leqslant\frac{5}{4}c_{1}\log n$ w.h.p. (c.f. Lemma 1). In the worst case, an intermediate node might have to deal with $O(\log n)$ messages of $O(\log^{2}n)$ size each, introducing a maximum possible delay of $O(\log^{2}n)$ rounds. To account for this delay, in the algorithm, we define $T=\frac{25}{16}c_{1}t_{u}\log^{2}n$, and use this upper bound estimate to keep the execution of the algorithm in synchrony. We relegate the formal details of handling congestion to the proof of Lemma 12.

Consider contender nodes that are yet to satisfy the intersection and distinctness properties as active nodes; consequently nodes that have already satisfied the said properties are considered inactive. That is, all nodes that will not double their estimate of $t_{u}$ are considered as inactive. It is to be noted that all the active nodes are synchronous and for all inactive nodes, the distance to their respective proxies is less than the current estimate of $T$ (of the active nodes).

Observation 2**.**

All inactive contender nodes satisfy both the intersection and the distinctness properties.

Lemma 3**.**

For any active contender node $y$, after the iteration where $t_{y}=c_{3}t_{mix}$ $(c_{3}\geqslant 1)$, w.h.p. $y$ satisfies both the intersection and distinctness properties. In fact, $y$ has intersecting proxies with all of the other contenders (both active and inactive).

Proof.

Consider a set $Y$ consisting of all active contenders and a set $X$ of all the inactive contenders (contenders that decide not to double their estimate after some previous epoch). We prove the lemma using the following claims.

Claim 4**.**

Each contender node in $Y$ is adjacent to (has intersecting proxies with) all the other contender nodes, w.h.p.

Proof.

For a contender node $y\in Y$, when $t_{y}=c_{3}t_{mix}$ $(c_{3}\geqslant 1)$, $y$ has $c_{2}\sqrt{n\log n}$ random proxies by running $c_{2}\sqrt{n\log n}$ independent random walks of length $=c_{3}t_{mix}$ (proxies are random by the definition of mixing time). For any contender node $x\in X$, since $x$ satisfies the distinctness property, it has at least $\frac{c_{2}}{2}\sqrt{n\log n}$ distinct proxies. The probability of non-intersection between this set of $\frac{c_{2}}{2}\sqrt{n\log n}$ distinct proxies and the set $c_{2}\sqrt{n\log n}$ random proxies is given by a birthday-paradox style argument to be $(1-\frac{(c_{2}/2)\sqrt{n\log n}}{n})^{c_{2}\sqrt{n\log n}}=\exp(-\frac{(c_{2})^{2}}{2}\log n)=O(\frac{1}{n})$. The statement is true for all pair of nodes by taking a simple union bound. Thus, with high probability, each contender node in $Y$ has at least one common/intersecting proxy with any contender node in $X$.

Now, consider two different contenders $y_{1},y_{2}\in Y$, each of which has a set of $c_{2}\sqrt{n\log n}$ random proxies. Using similar arguments as above it can be easily shown that each contender node in $Y$ has at least one common/intersecting proxy with every other contender node in $Y$, w.h.p.

This implies that each contender in $Y$ has intersecting proxies with all the other contenders, both in $X$ and $Y$, and thus is adjacent to all the other contenders. ∎

Claim 5**.**

Each contender node $y$ in $Y$ satisfies the distinctness property, w.h.p., when $t_{y}=c_{3}t_{mix}$, where $c_{3}$ is a constant $\geqslant 1$.

Proof.

To show the number of distinct proxies, we name the $c_{2}\sqrt{n\log n}$ independent random walks of any contender $y\in Y$ as $w_{1},w_{2},\dots,w_{c_{2}\sqrt{n\log n}}$. After the random walks have taken $c_{3}t_{mix}$ $(c_{3}\geqslant 1)$ number of steps, the probability that two of these random walks $w_{i}$ and $w_{j}$ do not share a proxy is $\approx 1-\tfrac{1}{n}$ (by the definition of mixing time). The probability that no other the random walks of node $u$ ends up at the same node as $w_{i}$ is obtained by taking an union bound.

[TABLE]

The above equation holds as \mathopen{}\mathclose{{}\left(1-\frac{1}{x}}\right)=\exp(-1) and $\exp(x)\geqslant 1+x$.

Let $X$ be a binary random variable such that $X_{i}=0$ when $w_{i}$ has a distinct proxy (no other $w_{j}$ ends at the proxy of $w_{i}$), and $X_{i}=1$ when it does not. This implies (from above) that \mathrm{Pr}\mathopen{}\mathclose{{}\left[X_{i}=0}\right]\geqslant 1-c_{2}\sqrt{\frac{\log n}{n}} and \mathrm{Pr}\mathopen{}\mathclose{{}\left[X_{i}=1}\right]\leqslant c_{2}\sqrt{\frac{\log n}{n}}. We define another binary random variable $Y$ such that $Y_{i}=1$ with probability $c_{2}\sqrt{\frac{\log n}{n}}$, otherwise [math]. Clearly, \mathrm{Pr}\mathopen{}\mathclose{{}\left[Y_{i}=1}\right] is always \geqslant\mathrm{Pr}\mathopen{}\mathclose{{}\left[X_{i}=1}\right]. Since each $Y_{i}$ is independent of one another,

[TABLE]

Thereafter, using a standard chernoff’s bound we show a bound on the summation over $Y_{i}$.

[TABLE]

Since each $Y_{i}$ stochastically dominates over the corresponding $X_{i}$, it implies

[TABLE]

Therefore, we can say that with high probability \sum_{i=0}^{c_{2}\sqrt{n\log n}}X_{i}\leqslant\mathopen{}\mathclose{{}\left(\frac{1}{2}}\right){c_{2}}^{2}\log n. This means that the number of non-distinct proxies of the contender $y$ is \leqslant\mathopen{}\mathclose{{}\left(\frac{1}{2}}\right){c_{2}}^{2}\log n, w.h.p. The statement holds over all contender nodes at the same time by taking a simple union bound.

Thus, when $t_{y}=c_{3}t_{mix}$, each contender $y\in Y$ would have found at least $\frac{c_{2}}{2}\sqrt{n\log n}$ (which is $<c_{2}\sqrt{n\log n}-({c_{2}}^{2}\log n)/2$) distinct proxies and therefore satisfying the distinctness property. ∎

∎

The time complexity of the algorithm, is determined by the following lemma.

Lemma 6** (Safety Lemma).**

In $O(t_{mix}\log^{2}n)$ time, w.h.p. all contender nodes satisfy both the intersection and the distinctness properties. Consequently, for the given algorithm, every node eventually stops, no later than $O(t_{mix}\log^{2}n)$ time.

Proof.

Each contender $u$ in parallel, runs several random walks till it satisfies the intersection and distinctness properties. $u$ begins with an initial estimate of $1$ and doubles each time till the above condition is not satisfied. This is the standard guess and double strategy and this does not increase the overall complexity by more than a constant factor of the maximum estimate. From Observation 2 and Lemma 3, we see that all contender nodes satisfy both the conditions w.h.p. when $t_{u}=c_{3}t_{mix}$ $(c_{3}\geqslant 1)$. Since the algorithm runs an upper-bound of $t_{u}$, i.e. $T=O(t_{u}\log^{2}n)$ to avoid congestion, the time required to satisfy both the intersection and distinctness property is $O(T)=O(t_{mix}\log^{2}n)$. ∎

Lemma 7** (At least one leader).**

After the iteration where the active nodes estimate $t_{u}=c_{3}t_{mix}$, where $c_{3}$ is a constant $\geqslant 1$, if no node had elected itself as leader in any of the earlier rounds, at least one contender node elects itself as the leader.

Proof.

Consider the iteration $i$, where the active nodes estimate $t_{u}=c_{3}t_{mix}$ $(c_{3}\geqslant 1)$. We look at the contender node with the highest id, say $v_{h}$. In iteration $i$, $v_{h}$ can either be inactive or active depending on whether it has stopped. (If $v_{h}$ is inactive, we look at the iteration $j$ $(j<i)$ in which $v_{h}$ became inactive). We show that for either case, if no other node has elected itself as the leader in any of the earlier rounds then $v_{h}$ becomes leader.

Suppose that $v_{h}$ becomes inactive in iteration $j$ where $(j<i)$ and no other node has elected itself as the leader in any of the earlier iterations. By Observation 2, $v_{h}$ satisfies both the intersection and the distinctness properties. Alternatively, it could be that $v_{h}$ is active until iteration $i$, where the active nodes estimate $t_{u}=c_{3}t_{mix}$. Also in that case, Lemma 3 says that $v_{h}$ satisfies the intersection and the distinctness properties. For either case, since $v_{h}$ has the highest id among the contender nodes, satisfies both the distinctness and the intersection properties and none of the other nodes has elected itself as the leader in any of the earlier rounds (implying that $v_{h}$ has not received a winner message), $v_{h}$ satisfies all the required conditions and becomes leader. ∎

Lemma 8** (At most one leader).**

After the completion of the algorithm, at most one contender node elects itself as the leader.

Proof.

We prove the lemma by combining the following two claims:

Claim 9**.**

Two different nodes cannot elect themselves as the leader in an iteration of the algorithm.

Proof.

Suppose two nodes $u$ and $v$ elect themselves as the leader in the same iteration of the algorithm. We know by the description of the algorithm that any node that becomes the leader would first need to satisfy both the intersection and the distinctness properties. Therefore, both contenders $u$ and $v$ would have at least $\tfrac{c_{2}}{2}\sqrt{n\log n}$ distinct proxies and would be adjacent to $>\frac{3}{4}c_{1}\log n$, i.e., more than half of the contenders. Recall that the sets $I_{2}$ of $u$ and $v$ (denoted by $I_{2}(u)$ resp. $I_{2}(v)$) contain the ids of their adjacent contenders. Let $w$ be a contender whose id is in the intersection of $I_{2}(u)$ and $I_{2}(v)$. As both $u$ and $v$ are adjacent to more than half of the contenders, there must be at least one such node $w$.

Without loss of generality, assume that the id of $u$ is larger than the id of $w$. Since $w\in ID_{2}(u)$, some proxy $p_{1}$ of $u$ must have also been a proxy of $w$ in this iteration. Similarly, since $w\in ID_{2}(v)$, some proxy $p_{2}$ of $v$ must have also been a proxy of $w$ in this iteration. Then, by the description of the algorithm $w$ would obtain the ids of both $u$ and $v$ in the set $I_{2}(w)$, which it then disseminated to all its proxies. The proxies $p_{1}$ and $p_{2}$ both get this information $I_{2}(w)$ (of ids of $u$ and $v$) which is then forwarded to $u$ and $v$ respectively as sets $I_{3}(p_{1})$ and $I_{3}(p_{2})$ respectively. This means that $v$ must have known about $u$ while checking the winning condition and hence it knows that its id was not maximal, a contradiction. ∎

Claim 10**.**

If a node elects itself as the leader in some iteration $i$, no other node can elect itself as the leader in any subsequent iteration.

Proof.

Suppose two nodes $u$ and $v$ elect themselves as the leader and suppose that $u$ does so in iteration $i$ whereas $v$ does so in iteration $j>i$. For this case we show that when iteration $i+1$ begins, more than half of the contender nodes are aware that some node $u$ has become the leader. If any other contender node $v$ satisfies both, the intersection and the distinctness properties, then it must have interacted with at least one of the nodes that is aware of the existence of a leader and thereby also becomes aware of the leader. This means that $v$ must have known about the existence of a leader by receiving a winner message (either directly or indirectly), leading to a contradiction.

If $u$ becomes leader in iteration $i$, then it immediately sends a winner message to all its proxies, which is then immediately forwarded it to all the other adjacent contenders (see Algorithm 2). The winner message reaches all the adjacent contenders of $u$ before the next iteration begins (as active contenders wait for $2T$ time at the end of random walk phase). As $u$ has to satisfy both the intersection and the distinctness properties to satisfy the winning condition, the number of adjacent contenders of $u$ is $\geqslant\tfrac{3}{4}c_{1}\log n$, which in turn is greater than half of the total number of contenders. Any other contender node that also satisfies the intersection and the distinctness properties has to have at least one intersecting proxy with at least one of the adjacent contender nodes of $u$ (by the pigeon hole principle). Any interaction with adjacent contender nodes of $u$ is accompanied with an additional winner message notifying $v$ of the existence of a leader, and thus leading to a contradiction. ∎

This completes the proof of Lemma 8. ∎

Combining Lemma 7 and Lemma 8, we obtain the following lemma that determines the correctness of the algorithm.

Lemma 11** (Unique Leader Lemma).**

With high probability and in $O(t_{mix}\log^{2}n)$ time, exactly one contender becomes the leader.

Lemma 12** (Message Complexity Lemma).**

With high probability, the total number of messages sent by the above algorithm is at most $O(\sqrt{n}\log^{7/2}n\cdot t_{mix})$. If larger message size of $O(\log^{3}n)$ is allowed the total number of messages comes down to $O(\sqrt{n}\log^{3/2}n\cdot t_{mix})$.

Proof.

To calculate the message complexity, we look at the various messages that are sent by the algorithm. Considering Algorithm 2, we observe that all the information is sent only along the random walks. The messages that are sent include the random walk tokens, the sets $I_{1},I_{2}$ and $I_{3}$, the Boolean $d$ and the winner messages. In each phase (iteration), the maximum number of steps taken by any of these messages is proportional to the estimate of the length of the random walk $t_{u}$. The maximum possible estimate is $O(t_{mix})$ (c.f. Lemma 6) and as this estimate is chosen in a guess-and-double style which only increases the overall complexity to a constant factor of the maximum guess for a successful trial, the overall number of steps taken throughout the algorithm (without accounting for congestion) by any of these messages is $O(t_{mix})$ as well.

Individually, the Boolean $d$ and the winner messages are of $O(1)$ bits and the random walk tokens are of $O(\log n)$ bits. Since the ids of the contenders are of $O(\log n)$ bits and number of contenders is $\leqslant\tfrac{5}{4}c_{1}\log n$ (c.f. Lemma 1), the sets $I_{1},I_{2}$ and $I_{3}$ can be of size $O(\log^{2}n)$ as they can contain the ids of $O(\log n)$ other contenders. This implies that an intermediate node might receive up to $O(\log n)$ many $O(\log^{2}n)$ sized messages.

First, consider the case where $O(\log^{3}n)$ message sizes are allowed to be sent over an edge. Each contender node ($O(\log n)$ many) initiates a total of $O(\sqrt{n\log n})$ messages which backtracks after reaching the proxies taking a total of $O(t_{mix})$ steps. Additionally, the winner message also takes only $O(t_{mix})$ many steps. As there would be no congestion, the message complexity here would be $O(\log n)\times O(\sqrt{n\log n})\times O(t_{mix})$ w.h.p. , which equals $O(\sqrt{n}\log^{3/2}n\cdot t_{mix})$.

Now, we consider the standard $\mathcal{CONGEST}$ model where message sizes are restricted to $O(\log n)$. Firstly, during the execution of the random walk, a contender node $u$ does not send $O(\sqrt{n\log n})$ different tokens for each random walk, but rather sends only one token along with a count of tokens that need to be sent in a particular path. For multiple instances of the variable $d$ originating from different proxies of the same contender, only the summation value is sent (which is $O(\log n)$). Multiple messages coming from either the same or different nodes could possibly lead to congestion. For messages that have the same destination, we send only one distinct copy of id information over a particular edge (i.e. we use a filtering and forwarding technique wherein if an intermediate node has sent the information to a particular destination once it does not send the same information again to that destination). For messages having different destinations, there is a possibility that $O(\log n)$ many messages of $O(\log^{2}n)$ size could arrive at a particular intermediate node. Larger sized messages of $O(\log^{2}n)$ bits would have to be broken down into $O(\log n)$ sized messages, i.e. we can assume that each $O(\log n)$ sized message contains the information of the id of a node and some additional $O(1)$ bits. The maximum delay possible here an at intermediate node is $O(\log^{2}n)$. We note that we use the variable $T=O(t_{mix}\log^{2}n)$ in the algorithm to deal with this possible delay. Hence, the number of messages sent in the worst case is $O(\log n)\times c_{2}\sqrt{n\log n}\times t_{mix}\times O(\log^{2}n)$ w.h.p. , which equals $O(\sqrt{n}\log^{7/2}n\cdot t_{mix})$. ∎

We conclude with the following theorem that combines the results of all the previous lemmas.

Theorem 13**.**

For any given graph $G$ that has a mixing time of $t_{mix}$, there exists an implicit leader election algorithm that succeeds w.h.p. in $O(t_{mix}\log^{2}n)$ time and has a message complexity of $O(\sqrt{n}\log^{7/2}n\cdot t_{mix})$, assuming that nodes know $n$.

After finding the leader we can use the well known push-pull broadcast [22] to disseminate the id of the leader to all the other nodes to obtain a solution for the explicit variant of leader election.

Corollary 14**.**

For any graph $G$ that has a conductance of $\phi$ and a mixing time of $t_{mix}$, there exists an explicit leader election algorithm that succeeds w.h.p. in $O(t_{mix}\log^{2}n)$ time and has a message complexity of $O(\sqrt{n}\log^{7/2}n\cdot t_{mix}+n\frac{\log n}{\phi})$, assuming that nodes know $n$ and there are no failures.

Proof.

The corollary follows by appending a simple push-pull broadcast procedure [17] at the end of the implicit leader election algorithm. The push-pull broadcast takes $\tfrac{\log n}{\phi}$ time and $n\tfrac{\log n}{\phi}$ messages. From equation 1, we know that $\Theta(1/\phi)\leqslant t_{mix}\leqslant\Theta(1/{\phi}^{2})$, it implies $\tfrac{\log n}{\phi}\leqslant O(t_{mix}\log^{2}n)$. Therefore the running time of leader election dominates the running time for broadcast. ∎

4 Lower bounds

In this section, we show the lower bounds for implicit leader election by showing that there exists a class of graphs with conductance $\phi$ on which any leader election algorithm that succeeds with probability $1-o(1)$ requires \Omega\mathopen{}\mathclose{{}\left({\sqrt{n}}/{(\phi)^{3/4}}}\right) messages in expectation. We also obtain some corollaries that lower bound the total number of messages required by other graph problems like broadcast and spanning tree construction.

Theorem 15**.**

Suppose there is a randomized leader election algorithm that succeeds with probability $1-o(1)$ in $n$-node networks where each node has a unique ID and knows the network size $n$. Then, for every $\alpha$, where $\tfrac{1}{n^{2}}<\alpha<\tfrac{1}{12^{2}}$, there exists a graph $G$ of $\Theta(n)$ nodes and conductance $\phi=\Theta(\alpha)$ such that the algorithm requires \Omega\mathopen{}\mathclose{{}\left({\sqrt{n}}/{\phi^{3/4}}}\right) messages in expectation.

We prove the above theorem through a contradiction. Given a particular $n$ and a value of $\alpha$ (within a specified range), we first construct a lower bound graph with $n$ nodes and conductance $\phi=\Theta(\alpha)$. Then, we assume towards a contradiction that there exists an algorithm that solves implicit leader election on the graph $G$ by sending at most $o({n^{(1-\epsilon)/2}})$ messages in expectation. The key intuition of the proof is to show that given this message budget, different distinct parts of the network are unable to communicate with one another. This lack in communication ensures that either all symmetric parts elect a leader or they do not. If all of the distinct parts do elect a leader it would imply more than one leaders, and if none of them elect a leader it implies zero leaders. Thus, leading to a contradiction. In the final step of the proof, we leverage the assumed upper bound on the expected message complexity, to show that distinct parts of the network, where nodes might be initiating the exploration of their neighborhoods, are likely to never communicate, and this lack of communication results in having no leaders or multiple leaders with constant probability.

Throughout the proof of Theorem 15, we assume that nodes start without unique ids. However, since nodes have knowledge of the network size $n$, it is straightforward to generate unique IDs with high probability. Hence we can use the same reduction as [11] (Sec. 3, paragraph “Unique IDs vs Anonymous”) to remove this assumption and show that our result holds even when nodes are equipped with unique ids.

4.1 The lower bound graph(s)

Graphs $G$ and $\mathcal{GS}$.  We start out by describing the construction of the graph $G$ that we use to prove the message complexity lower bound. For any given $n$ and $\alpha$ such that \mathopen{}\mathclose{{}\left(\frac{1}{n^{2}}}\right)<\alpha<\mathopen{}\mathclose{{}\left(\frac{1}{12^{2}}}\right), we create the graph $G$ that has a total number of $n$ nodes and a conductance $\phi=\Theta(\alpha)$. In this regard, we also define a parameter \epsilon=\mathopen{}\mathclose{{}\left(\frac{\log(1/\alpha)}{2\log n}}\right).

We first construct a super-node graph $\mathcal{GS}$ with $N=\lfloor n^{1-\epsilon}\rfloor$ super-nodes, and later derive the graph $G$ from $\mathcal{GS}$. The graph $\mathcal{GS}$ is created as a random regular graph (as in [8],[7]) where each super-node has a degree $4$. See Figure 1. For the purpose of analysis, since it does not change our bounds, we assume that both $n^{1-\epsilon}$ and $n^{\epsilon}$ are integers.

Say $V(\mathcal{GS})=\{s_{1},s_{2},\dots s_{n^{1-\epsilon}}\}$ and $E(\mathcal{GS})=\{e_{1},e_{2},\dots,e_{4n^{1-\epsilon}}\}$ be the vertex set and the edge set of the graph $\mathcal{GS}$. To create the graph $G$ from $\mathcal{GS}$, each super-node $s_{i}$ is replaced with a clique $C_{i}$ of $\lceil n^{\epsilon}\rceil$ nodes. For each edge $e_{i}$ of $\mathcal{GS}$, that exists between two super-nodes say $s_{j}$ and $s_{k}$, a corresponding edge $e^{\prime}_{i}$ is created in the graph $G$ between a (previously unchosen) node chosen randomly from the clique $C_{j}$ and a (previously unchosen) node chosen randomly from the clique $C_{k}$. As each super-node has exactly $4$ edges connected to it, for each clique there would exist $4$ such chosen nodes (called external-edged nodes). An edge between any two nodes belonging to the same clique is called an intra-clique edge, whereas an edge between nodes belonging to different cliques is called an inter-clique edge. To maintain uniform node degrees of exactly $n^{\epsilon}$, two intra-clique edges are removed, one from between any two of the external-edged nodes, and the other from between the remaining two external-edged nodes. See Figure 2. Thus, in any clique of the graph $G$ there would be two types of nodes, $n^{\epsilon}-4$ nodes with only intra-clique edges called internal-edged nodes and $4$ nodes with both intra-clique edges and one inter-clique edge called external-edged nodes.

Based on the construction of $G$, there exists a one to one mapping between the nodes of the super-node graph $\mathcal{GS}$ and the cliques in the graph $G$.

Graph $\mathcal{CG}$.  We define the clique communication graph $\mathcal{CG}$ as a graph whose vertex set is equivalent to the vertex set of the super-node graph $\mathcal{GS}$, which we simply call cliques. An edge exists in $\mathcal{CG}$ from clique $C_{1}$ to $C_{2}$ iff a message is sent on the inter-clique edge from some node in $C_{1}$ to a node in $C_{2}$. Note that the edge set of $\mathcal{CG}$ can grow over the course of the algorithm. For the purpose of our analysis, we only keep track of the first message sent on an inter-clique edges and so we treat $\mathcal{CG}$ as a simple graph.

High-Level Overview of the Lower Bound Proof

We begin by showing that the conductance of the constructed lower bound graph $G$ is $\phi=\Theta(1/n^{2\epsilon})$. Then, we assume towards a contradiction that there exists an algorithm that solves implicit leader election on the graph $G$ by sending at most $Mn^{2\epsilon}$ messages in expectation, where $M=o({n^{(1-\epsilon)/2}})$. It implies from the construction of $G$, that $Mn^{2\epsilon}=o(\sqrt{n}/\phi^{3/4})$, as $\phi=\Theta(1/n^{2\epsilon})$ and $M=o({n^{(1-\epsilon)/2}})$. Next, on the graph $G$ we show that any algorithm that sends at most $Mn^{2\epsilon}$ many messages in expectation, is likely to find at most $O(M)$ inter-clique edges. Then, given the fact that only inter-clique edges can be used for communicating in the clique communication graph $\mathcal{CG}$, we show that the random variables representing the states of the resulting connected components (in $\mathcal{CG}$) are nearly independent of one another. We leverage this “near independence” to show that the algorithm is likely to elect either no leader or more than one leader with constant probability (similarly to identically distributed and fully independent indicator random variables), thus resulting in a contradiction. We formalize this overview in the remainder of this section.

Lemma 16**.**

The conductance of the graph $G$ is $\phi=\Theta(\alpha)=\Theta({1}/{n^{2\epsilon}})$ with high probability.

Proof.

First, we define an optimal cut of a graph as the cut that determines the minimum cut-conductance of the graph, and hence also determines the conductance of the graph. We prove the lemma by using the following claim.

Claim 17**.**

The optimal cut of the graph $G$ does not pass through any of the cliques, i.e., all the edges that are cut by the optimal cut comprises only of inter-clique edges.

Proof.

Let us assume for the sake of contradiction that a given cut $\mathcal{K}$ of the graph $G$, with cut-conductance $\phi_{\mathcal{K}}<1/6$, is the optimal cut of $G$. We show that, if $\mathcal{K}$ intersects with (passes through) any clique, the conductance can always be reduced to $\phi_{new}$ such that $\phi_{new}<\phi_{\mathcal{K}}$ by moving a group of nodes from one side of the cut to the other. This will contradict our assumption of $\mathcal{K}$ being the optimal cut and thereby prove the above claim. If $\phi_{\mathcal{K}}\geqslant 1/6$, we compare this cut to the middle cut of the graph $G$ that cuts the graph into two equal parts and does not pass through any cliques. With a simple calculation it is easily show that this middle cuts’ conductance is $<\phi_{\mathcal{K}}$.

We refer to the total volume of the graph (summation of all node degrees) as $V_{total}$. The side of the cut $\mathcal{K}$ that has the (initial) lower volume $(<V_{total}/2)$ is called as the min side of the cut and the side (initially) having the larger volume $(>V_{total}/2)$ is called as the max side of the cut. If volumes of both sides are equal then we arbitrarily assign one side as min and the other as max. For the given cut $\mathcal{K}$, we consider $\phi_{\mathcal{K}}=C/V$, where $C$ represents the cut edges (edges with end nodes on either side of the cut $\mathcal{K}$) and $V$ represents the volume of the min side of the cut. Note that, since node degrees are uniform, each node contributes $n^{\epsilon}$ towards the volume, and thus the side having the lesser number of nodes has the minimum volume.

We look at the cliques that are cut by $\mathcal{K}$, the side of the clique that has $<n^{\epsilon}/2$ nodes is labeled as the minority side and the side of the clique that has $>n^{\epsilon}/2$ nodes is labeled as the majority side. If both sides have exactly $n^{\epsilon}/2$ nodes labeling is done arbitrarily. In this regard, note that whenever we say min/max side we refer to the side of the cut of the entire graph, whereas when we say minority/majority side we refer to the cut sides of the particular clique under consideration.

Consider any clique $C_{i}$ that is divided by the cut $\mathcal{K}$. Let there be $k$ nodes in the minority side of the $C_{i}$ and $n^{\epsilon}-k$ nodes in the majority side, where $k\leqslant n^{\epsilon}/2$. To show that we can obtain a lower conductance, we always move $k$ nodes from the minority side of the clique to the opposite side of the cut $\mathcal{K}$ (except Case 3, where moving the $k$ nodes leads to the volume of the min side of the cut becoming [math] : in this case $(n^{\epsilon}-k)$ nodes are moved from the majority side of the clique to the other side of the cut). After the nodes are moved, we show that for all cases that the maximum possible value of conductance obtained after moving the nodes ($\phi_{new}$), is less than the conductance prior to the nodes being moved ($\phi_{\mathcal{K}}$), giving us a contradiction. Observe that the denominator is always greater than [math] as in no case all the nodes are moved out of the eventual min side.

For each case (except Case 3), when $k$ nodes are moved, say there are $k_{1}$ internal-edged nodes and $k_{2}$ external-edged nodes such that $k_{1}+k_{2}=k$. Each of the $k_{1}$ internal-edged nodes in the minority side was previously connected to $n^{\epsilon}-k$ nodes in the majority side (due to the clique edges) and each of the $k_{2}$ external-edged nodes in the minority side was previously connected to at least $(n^{\epsilon}-k)-1$ nodes in the majority side (case that maximizes $\phi_{new}$). Therefore, comparing $\phi_{\mathcal{K}}$ with $\phi_{new}$, the reduction in the number of cut edges is at least $k_{1}(n^{\epsilon}-k)+k_{2}(n^{\epsilon}-k-1)=k(n^{\epsilon}-k)-k_{2}$. The total possible number of external-edged nodes is at most $4$ (as the super-node graph was $4$-regular), therefore in this case $k_{2}\leqslant 4$. Also by our choice of $\epsilon$ (and the range of $\alpha$), we see that $4<n^{\epsilon}/3\implies 4<kn^{\epsilon}/3$. We consider the following cases for a clique $C_{i}$ while moving $k$ nodes from the minority side to the opposite side of the cut.

Case 1 : If $k$ nodes move from min side of the cut to the max side.

Moving $k$ nodes reduces the volume of the min side of the cut by $kn^{\epsilon}$.

[TABLE]

[TABLE]

As $\phi_{\mathcal{K}}$ is $<1/6$, $\phi_{\mathcal{K}}-\phi_{new}>0$, which implies that $\phi_{new}<\phi_{\mathcal{K}}$.

Case 2 : If $k$ nodes move from max side of the cut to the min side.

Case 2A : If min side’s volume still remains $\leqslant V_{total}/2$ after the nodes are moved.

Moving $k$ nodes into the min side of the cut increases the volume by $kn^{\epsilon}$.

[TABLE]

The number of cut-edges strictly decrease from previous while the volume increases therefore it is clear that $\phi_{new}<\phi_{\mathcal{K}}$.

Case 2B : If min side’s volume becomes $>V_{total}/2$ due to the $k$ moved nodes.

The max side now becomes the side with the lower value of volume as a result of $k$ nodes moving to the other side with its volume $=V_{total}-V-kn^{\epsilon}$, where $V_{total}$ is the total volume of the graph.

[TABLE]

[TABLE]

As $V\leqslant V_{total}/2$ (because initially $V$ was the volume of the side having the lower volume among the two sides of the cut) and as $\phi_{\mathcal{K}}$ is $<1/6$, we see that the terms in the numerator, C\mathopen{}\mathclose{{}\left(V_{total}-2V}\right)\geqslant 0 and Vkn^{\epsilon}\mathopen{}\mathclose{{}\left(1/6-\phi_{\mathcal{K}}}\right)>0, i.e. $\phi_{\mathcal{K}}-\phi_{new}>0$, which implies that $\phi_{new}<\phi_{\mathcal{K}}$.

Case 3 : In a special case, when moving $k$ nodes from minority side of the clique to the majority side results in making the volume of the min side of the cut $=0$. (This is the case where the min side of the cut contains only the minority side of a clique). Instead of moving $k$ nodes from the minority side of the clique to the majority, $(n^{\epsilon}-k)$ nodes are moved from the majority side to the minority side (such that the min side of the cut now has exactly one clique). In contrast to all the previous cases, in this case nodes move from the majority side of the clique to the minority side. It is to be noted that this movement cannot result in increasing the volume of the min side of the cut to a value $>V_{total}/2$. Say there are $k_{1}$ internal-edged and $k_{2}$ external-edged nodes in the majority such that $k_{1}+k_{2}=(n^{\epsilon}-k)$. Each of the $k_{1}$ internal-edged nodes in the majority side was previously connected to $k$ nodes in the minority side (due to the clique edges) and each of the $k_{2}$ external-edged nodes in the majority side was previously connected to at least $k-1$ nodes in the minority side (case that maximizes $\phi_{new}$). Therefore, comparing $\phi_{\mathcal{K}}$ with $\phi_{new}$, the reduction in the number of cut edges is at least $k_{1}(k)+k_{2}(k-1)=k(n^{\epsilon}-k)-k_{2}$. The total possible number of external-edged nodes is at most $4$ (as the super-node graph was $4$-regular), therefore in this case $k_{2}\leqslant 4$. Also by our choice of $\epsilon$ (and the range of $\alpha$), we see that $4<n^{\epsilon}/3\implies 4<kn^{\epsilon}/3$. Moving $(n^{\epsilon}-k)$ nodes into the min side of the cut increases the volume by $n^{\epsilon}(n^{\epsilon}-k)$.

[TABLE]

The number of cut-edges strictly decrease from previous while the volume increases therefore it is clear that $\phi_{new}<\phi_{\mathcal{K}}$.

Since for each case we can obtain a conductance of $\phi_{new}<\phi_{\mathcal{K}}$ if cut $\mathcal{K}$ passes through a clique, we conclude that the optimal cut would not pass through any of the cliques. ∎

Now, we give a one to one correspondence between the cuts on the super-node graph $\mathcal{GS}$ and the cuts on $G$ that do not pass through any cliques by considering any cut $\mathcal{K}_{\mathcal{GS}}$ of $\mathcal{GS}$ and an identical cut $\mathcal{K}_{G}$ on $G$ such that if $\mathcal{K}_{\mathcal{GS}}$ cuts an edge $e^{\prime}$ in the graph $\mathcal{GS}$, then the cut $\mathcal{K}_{G}$ would cut edge $e$ of the graph $G$ that was created in behest of $e^{\prime}$ while constructing graph $G$ from $\mathcal{GS}$ (refer to the construction of $G$ described in the beginning of Section 4).

Note that, this also creates a one to one correspondence of their respective cut-conductances such that $\phi_{\mathcal{K}_{G}}(G)=4\phi_{\mathcal{K}_{\mathcal{GS}}}(\mathcal{GS})/n^{2\epsilon}$. Clearly, the number of cut edges across the cuts $\mathcal{K}_{\mathcal{GS}}$ and $\mathcal{K}_{G}$ remains same in either case. Let the volume of the smaller side the cut $\mathcal{K}_{\mathcal{GS}}$ be $V$. Since each super-node has a degree $=4$, the total number of super nodes present in the smaller side of the cut equals $V/4$. As described earlier, while constructing graph $G$ from $\mathcal{GS}$ each super-node is replaced by a clique of $n^{\epsilon}$ nodes with each node having a degree $=n^{\epsilon}$, wherein the degree is adjusted to include the $4$ inter-clique edges by removing $2$ intra-clique edges. Therefore, the volume of the smaller side of the corresponding cut $\mathcal{K}_{G}$ of the graph $G$ would be $(V/4)n^{2\epsilon}$. Thus, if the cut conductance determined by $\mathcal{K}_{\mathcal{GS}}$ in $\mathcal{GS}$ is $\phi_{\mathcal{K}_{\mathcal{GS}}}$, it implies that the cut conductance given by the cut $\mathcal{K}_{G}$ in $G$ would be $\phi_{\mathcal{K}_{G}}=4\phi_{\mathcal{K}_{\mathcal{GS}}}/n^{2\epsilon}$.

It immediately follows from the correspondence that if cut $\mathcal{K}_{\mathcal{GS}}$ is the optimal cut that determines the conductance of the graph $\mathcal{GS}$, then its corresponding identical cut $\mathcal{K}_{G}$ would be the cut determining the conductance of $G$. From [7], we know that for a sufficiently large $n$, almost every random regular graph with degree $=4$ has a constant conductance which implies that w.h.p. the conductance of $G$, $\phi(G)=\Theta(1/n^{2\epsilon})$. ∎

4.2 Distinct parts remain disjoint

Recall that we assume $M=o({n^{(1-\epsilon)/2}})$ and, assume towards a contradiction that the algorithm sends at most $Mn^{2\epsilon}$ messages in expectation. In this section, we show that parts of the network where nodes might be initiating the exploration of their neighborhoods, evolve independently in the sense that they are likely to never communicate.

Let random variable $\mathsf{Msgs}$ give the number of messages sent by the algorithm and let random variable $\mathsf{Msgs}(C)$ give the number of messages sent by the nodes in clique $C$.

Lemma 18**.**

Without receiving any messages, if a clique $C$ sends a message444We slightly abuse notation by saying a clique $C$ sends a message when, in fact, some node in $C$ performs the sending action. over an inter-clique edge, then it follows that the nodes in $C$ have sent at least $\Omega(n^{2\epsilon})$ messages in expectation, i.e. \mathbb{E}\mathopen{}\mathclose{{}\left[\mathsf{Msgs}(C)}\right]=\Omega(n^{2\epsilon}).

Proof.

Recall from the construction of the super-node graph $\mathcal{GS}$ that we have assigned the inter-clique ports uniformly at random among all available ports of $C$. Any clique $C$ has a total of $n^{2\epsilon}$ ports out of which only $4$ ports belong to inter-clique edges. Also, the nodes are unaware of their neighbors’ identities, and in particular, the four nodes containing inter-clique port are unaware of this fact. First, we see that if a clique $C$ sends more than $n^{2\epsilon}/2$ messages before sending its first inter-clique message, the lemma is vacuously true. Otherwise, given that no messages were received via an inter-clique edge, it holds that, at any point before sending the first inter-clique edge, there are at least $n^{2\epsilon}/2$ ports among the nodes in $C$ over which no message has been sent yet, and each of them is equally likely to connect to an inter-clique edge. Thus, the probability that a message is sent over an inter-clique edges for the first time (in clique $C$) is at most $4/(n^{2\epsilon}-\tfrac{n^{2\epsilon}}{2})=8/n^{2\epsilon}$.

Therefore, in expectation the number of messages sent by any clique $C$ before sending its first inter-clique message is at least $n^{2\epsilon}/8$ which is $\Omega(n^{2\epsilon})$. ∎

In the rest of our proof, will analyze the probability that certain subgraphs of the clique communication graph $\mathcal{CG}$ (see section 4.1) contain a leader node. We will first state a crucial consequence of Lemma 18 in the language of clique communication graphs:

Lemma 19**.**

With probability $1-o(1)$, the clique communication graph $\mathcal{CG}$ contains at most $O(M)$ edges.

Proof.

Let $B=cM$, for a sufficiently large constant $c$, and suppose towards a contradiction that $\mathcal{CG}$ contains at least $B$ edges with constant probability $\gamma>0$.

For each clique that is in a non-singleton connected component in the clique communication graph $\mathcal{CG}$, we define its first edge as the first inter-clique edge over which its nodes have sent (or received) a message to (from) another clique. Let $F$ be the set of cliques that have first edges. Since each clique can connect to at most $4$ other cliques in $\mathcal{CG}$, we have $|F|\geqslant B/4$. We have

[TABLE]

Since the number of messages required for discovering an inter-clique edge of $C$ is independent of the event $|F|\geqslant B/4$, it holds that

[TABLE]

Applying Lemma 18 for each $C\in F$, we obtain from (3) that

[TABLE]

By choosing $c$ sufficiently large, we obtain a contradiction to the assumption of sending at most $Mn^{2\epsilon}$ messages in expectation. ∎

Spontaneous Cliques. Since we consider randomized algorithms, we assume that each node is equipped with a random bit string of infinite length. If a clique $C$ does not have any incoming edges in $\mathcal{CG}$ throughout the execution, i.e., it does not receive any messages from nodes in other cliques, then the actions and the state transitions of its nodes depend exclusively on the supplied random bit strings. In particular, inspecting these random bit strings, we can determine whether nodes in $C$ will send messages across any inter-clique edges of $C$. This motivates us to call $C$ spontaneous, if some node in $C$ eventually sends an outgoing message assuming that no node ever receives an incoming message (as per its initial random string). (Note that it may not actually send an outgoing message because it may receive a message first from some node in another clique.) We use the notation $P(C)$ to denote the connected component of a clique $C$ in $\mathcal{CG}$ and note that $P(C)$ can grow over time.

Disjoint Components. We define $\mathsf{Disj}$ to be the event where, at any point in the algorithm’s execution, each connected component in $\mathcal{CG}$ contains at most one spontaneous clique, and each non-singleton connected component contains exactly one. This, we show is in fact likely to occur. The next lemma summarizes the main result of this subsection:

Lemma 20**.**

Event $\mathsf{Disj}$ occurs with probability $1-o(1)$.

Proof.

From Lemma 19, we know that with probability $1-o(1)$, the clique communication graph $\mathcal{CG}$ contains at most $cM$ edges, for some fixed constant $c$. Also note that, the only way of violating event $\mathsf{Disj}$, is the merging of two connected components, each that initially had only one spontaneous clique. Clearly, for each non-singleton connected component, there is at least one spontaneous node. We show that conditioned on the event that $\mathcal{CG}$ has $\leqslant cM$ edges, the probability that a connected component $P$ selects an inter-clique edge to a subgraph $Q$, which can be either another non-singleton connected component or a spontaneous clique (that may still be a singleton) is quite low. Denote this event by $\{P\rightarrow Q\}$. Let $j$ and $k$ be the number of open ports of $P$ and $Q$, respectively. Then, it holds that

[TABLE]

since $M=o(\sqrt{N})$ by assumption. This shows that, two non-singleton connected components do not combine with probability at least 1-o\mathopen{}\mathclose{{}\left(\frac{1}{\sqrt{N}}}\right). Considering that there are at most $cM$ possible edges in the clique graph (see Lemma 19), we know that $\mathsf{Disj}$ occurs with probability at least \mathopen{}\mathclose{{}\left(1-\frac{1}{\sqrt{N}}}\right)^{cM}=1-o(1). ∎

4.3 Bounding the dependencies between connected components.

So far, we have shown that connected components are likely to remain disjoint throughout the execution. However, we cannot directly argue that this implies a small probability of electing a leader, since the conditioning on event $\mathsf{Disj}$ restricts the evolution of a given connected component, as we explain in more detail below.

We view the execution of the algorithm as a sequence of steps performed by cliques, where a step involves either an update to a clique’s state (defined below) or the sending of a message. Note that a step here is different from a round as there may be simultaneous actions at cliques happening in the same round, but we can consider an arbitrary order on such simultaneous events for analysis.

We define the state of clique $C$ in $\mathcal{CG}$ as either (1) empty, if $C$ is not spontaneous, or (2) its state consists of the local states of the nodes that are part of the connected component in $\mathcal{CG}$. In this notation, sending a message between two nodes in the same clique corresponds to a local update to the clique’s state.

Formally, we use the notation $S(C,t)$ to denote the state of clique $C$ after $t$ steps and define $S(t)$ to be the collective state of all the cliques after $t$ steps. By inspecting $S(C,t)$, we can derive whether there is a leader in one of the cliques of the connected component of $C$ in $\mathcal{CG}$.

For the rest of the proof, we assume that all connected components remain disjoint throughout the execution, i.e., event $\mathsf{Disj}$ occurs (see Lemma 20).

Let $\kappa$ be a collection of states after step $t$ for all the cliques and suppose that $\kappa$ represents a state in which $\mathsf{Disj}$ holds; formally, the event $S(t)=\kappa$ has nonzero probability conditioned on $\mathsf{Disj}$. We use the notation $\kappa(C)$ to refer to the state of the clique $C$ in the collection of states $\kappa$. If the clique nodes eventual states were completely independent, then we would have $\mathrm{Pr}[S(t)=\kappa]=\prod_{C\in\mathcal{CG}}Pr(S(C,t)=\kappa(C)].$ Note that, the conditioning on $\mathsf{Disj}$ can introduce dependencies between the event that some clique transits to a given state and the state of some other cliques and thus we cannot assume that the equality holds. However, we prove that any possible dependency due to event $\mathsf{Disj}$, cannot decrease the probability of $S(t)=\kappa$, which is sufficient for our purposes:

Lemma 21**.**

Let $\kappa$ be a collection of the clique states after step $t$ that has positive probability of occurring conditioned on $\mathsf{Disj}$. Then, it holds that

[TABLE]

Proof.

We use induction over the number of steps $t$. In the base case, i.e. the first step $t=1$, (4) holds with equality as no other steps have been made yet. Next, we assume the statement holds for step $t-1$ and show that it holds for any step $t\geqslant 2$:

[TABLE]

by the inductive hypothesis. For each possible predecessor state $\kappa^{\prime}$, the probability of transitioning to $\kappa$ depends on the needed step to move from $\kappa^{\prime}$ to $\kappa$. This, however, depends on a single clique taking a step and changing its state accordingly. Let $C$ refer to the clique node that must perform a step to transform $\kappa^{\prime}$ into $\kappa$ and denote the corresponding event that this happens by \{\text{C$takes step:$\kappa^{\prime}\rightarrow_{t}\kappa}\} . (We ignore states $\kappa^{\prime}$ from which $\kappa$ is unreachable in one step; obviously their contribution to the probability of $\kappa$ is zero.) We get

[TABLE]

Plugging this into the right-hand side of (5) and factoring out $\mathrm{Pr}[S(C,t-1)\!=\!\kappa^{\prime}(C)]$ from the product, yields

[TABLE]

where the last equality follows because the conditioning on $\mathsf{Disj}$ tells us that $C$ is the only clique updating its state in step $t$, i.e., $\kappa(C^{\prime})=\kappa^{\prime}(C^{\prime})$ and $S(C^{\prime},t)=S(C^{\prime},t-1)$, for all $C^{\prime}\neq C$.

To complete the proof, we will show that

[TABLE]

In calculating \mathrm{Pr}[\text{C$takes step:$\kappa^{\prime}\rightarrow_{t}\kappa}], we have to exclude the events that are prohibited by the fact that we have conditioned on $\mathsf{Disj}$, which implies that this probability depends not just on the state of $C$ after step $t-1$, but also on the other connected components. Let $P_{t}(C)$ be the connected component of a spontaneous clique $C$ after step $t$. Since we condition on event $\mathsf{Disj}$, it cannot happen that some node in $P_{t-1}(C)$ receives a message from a node in some clique $C^{\prime}\notin P_{t-1}(C)$, as this would result in a connected component $P_{t}(C)$ having $2$ spontaneous cliques. For a similar reason, step $t$ cannot be such that a node in $P_{t-1}(C)$ sends a message to a node in some non-singleton component $P_{t-1}(C^{\prime})$, where $C^{\prime}\neq C$. Thus, we are left with the following two possibilities to show that (7) holds:

Step $t$ concerns only nodes in $P_{t-1}(C)$: In this case, the event corresponding to step $t$ is independent of the state of the cliques not in $P_{t-1}(C)$ and hence (7) holds with equality. 2. 2.

Step $t$ consists of some node in $P_{t-1}(C)$ sending a message $m$ to a clique $C^{\prime}\notin P_{t-1}(C)$, and $C^{\prime}$ is not part of any non-singleton connected component: The left-hand side of (7) assumes that we do not condition on any additional state, and therefore $C^{\prime}$ can be any of the, say $\ell$, cliques not in $P_{t-1}(C)$. On the other hand, when conditioning on the state of components other than $P_{t-1}(C)$, the number of possible cliques where $m$ can be sent to might be smaller than $\ell$, to avoid hitting a clique that is in some other non-singleton connected component (which would violate $\mathsf{Disj}$). In other words, the number of cliques that $m$ can be sent to cannot increase when we conditioning on additional state on the right-hand side of (7).

Plugging (7) into (6), we get

[TABLE]

The lemma follows by using the fact that \sum_{\text{\kappa^{\prime}}}\mathrm{Pr}[S(C,t-1)\!=\!\kappa^{\prime}(C)]=1. ∎

4.4 Disjoint connected components cannot break the symmetry

At this point, we have shown that, conditioned on the connected components remaining disjoint, the state of the individual connected components is almost independent. In particular, we have shown that the probability of collectively being in any specific disjoint state is at least as large as the product of the individual probabilities. Throughout, we are conditioning on the connected components being disjoint.

To complete the proof, we need three further steps. First, we need to relate the states of the cliques to whether or not a given clique has elected a leader. Then, we need to relate this almost independent process to a collection of independent random variables that are easier to analyze. Finally, we show that with constant probability the algorithm elects zero or more than one leaders.

Leadership.

We want to analyze the probability of a given set of outcomes in terms of leader election. We define an indicator random variable $Y(C,t)$ such that $Y(C,t)=1$ if and only if clique $C$ is spontaneous and has a leader in its connected component after step $t$; we simply write $Y(C)$ when $t$ is clear from the context or not important. By symmetry, all cliques are identical, and hence are equally likely to be spontaneous and also equally likely to be in a connected component with a leader. We define $s$ as the probability of the clique $C$ being spontaneous and $p$ as the probability of the spontaneous clique $C$ having a leader, i.e, p=\mathrm{Pr}[Y(C)=1\mid\text{C is spontaneous}]. It follows that $\mathrm{Pr}[Y(C)\!=\!1]=sp$.

As noted earlier, observe that with the conditioning on $\mathsf{Disj}$, the $Y$s are not necessarily independent. For example, the knowledge that $Y(C^{\prime})=1$, for some clique $C^{\prime}$, might imply that the connected component of $C^{\prime}$ has a certain minimum size, which in turn limits the ways in which the connected component of $C$ can expand in the next step.

Let $Z$ be a vector of desired outcomes for these indicator random variables, i.e., for each clique $C$ we consider whether $Y(C)=Z_{C}$. Let $L(C)$ be the set of states for $C$ compatible with the outcomes $Z_{C}$, i.e., where component $C$ does or does not elect a leader as specified by $L(C)$. Let $L$ be the product of all the $L(C)$ subspaces, i.e., $L$ is exactly the set of states compatible with $Z$ for all $C$. Let $F$ be the state of the algorithm when it stops sending messages.

In the following lemma, we show that the probability of being in one of the states compatible with $Z$ can be decomposed into the probabilities of the individual indicator random variables. (If the connected components were really independent, it would be exact equality, rather than $\geqslant$.)

Lemma 22**.**

\mathrm{Pr}\mathopen{}\mathclose{{}\left[Y=Z}\right]\geqslant\prod_{C\in\mathcal{CG}}\mathrm{Pr}\mathopen{}\mathclose{{}\left[Y(C)=Z_{C}}\right].

Proof.

The \mathrm{Pr}\mathopen{}\mathclose{{}\left[Y=Z}\right] is really the same as \mathrm{Pr}\mathopen{}\mathclose{{}\left[F\in L}\right], by the way in which we have defined $L$. We first observe that the probability that $F\in L$ is actually the sum of a collection of disjoint events, i.e., the individual states. For each, the probability can be decomposed by the near-independence property of Lemma 21. We then observe that the set $L$ is actually the product of a collection of subspaces, allowing us to rearrange terms and recombine disjoint events.

[TABLE]

∎

Independent variables.

Recall that \mathrm{Pr}\mathopen{}\mathclose{{}\left[Y(C)=1}\right]=sp, where $s$ is the probability that $C$ is spontaneous and $p$ is the probability that a clique elects a leader if it is spontaneous. (And by symmetry, these are all identical.) We define a new set of independent indicator random variables $X(C)$ where \mathrm{Pr}\mathopen{}\mathclose{{}\left[X(C)=1}\right]=sp.

Lemma 23**.**

For any integer $k$, \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}{Y(C)}>k}\right]\geqslant\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}{X(C)}>k}\right].

Proof.

We show that this follows from Lemma 22, by summing over the collection of outcomes where $\sum Y(C)>k$. Since there are $N$ cliques in total and we can write \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)>k}\right]=\sum_{l=k+1}^{N}\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=l}\right], we will first obtain a bound on \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=l}\right], which is the probability of the event that there are exactly $l$ spontaneous cliques (with leader), for integer $l>0$.

Let $Z$ be the $N$-bit vector of the desired outcomes of the indicator random variables $Y(C)$. By abuse of notation, we can think of $Y$ as a vector of the individual random variables $Y(C)$. Let $\mathcal{Z}$ be the set of all $N$-bit vectors $Z$ that have a support of exactly size $l$. It follows that

[TABLE]

Plugging this bound into \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)>k}\right], we obtain

[TABLE]

This completes the proof of the lemma. ∎

Zero leaders.

We now analyse the probability that there are zero leaders, and use that to show that $sp\geqslant 1/n^{1-\epsilon}$.

Lemma 24**.**

$sp\geqslant 1/n^{1-\epsilon}$**

Proof.

We first show that \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}Y(C)=0}\right]\geqslant(1-sp)^{n^{1-\epsilon}}. We then use this to conclude that $sp\geqslant 1/n$. Let us consider $W$ as a subset of cliques of $\mathcal{CG}$. When saying $W$ is spontaneous, we mean that all cliques in $W$ are spontaneous.

[TABLE]

Equation 8 follows as we can introduce an indicator variable $w_{C}$ for each clique $C$ in $\mathcal{CG}$, where $w_{C}=1$ iff the clique $C$ is spontaneous. Rearranging the equation for the two different possible values of $w_{C}$ and observing that $w_{C}=1$ for all $C\in W$, we obtain Equation 4.4.

Specifically, we know that, for any algorithm to succeed the probability of zero leaders has to be less than a constant. Here, we have shown that any algorithm that sends $\leqslant Mn^{2\epsilon}$ messages in expectation has at most $O(M)$ edges in the clique communication graph with probability $1-o(1)$, and the connected components formed in the clique communication graph are also disjoint with probability $1-o(1)$. Conditioned on those events, we have just shown that with probability $(1-sp)^{n^{1-\epsilon}}$ there are no leaders and the algorithm fails. Thus, for this to be smaller than some constant, we conclude that $sp>1/n^{1-\epsilon}$. ∎

This proves something that intuitively makes sense: in order to ensure at least one leader, if the probability of a clique electing a leader is $sp$, and if we have $n^{1-\epsilon}$ cliques, then the probability $sp\geqslant 1/n^{1-\epsilon}$ to ensure at least one leader. (It required just a bit more care because we did not have complete independence.)

More than one leader.

We now analyze the probability that there is more than one leader, showing that this occurs with constant probability. This concludes our proof, as it indicates that the algorithm fails to elect exactly one leader with constant probability.

Lemma 25**.**

\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}{Y(C)}>1}\right]>\Omega(1)**

Proof.

We assume from Lemma 24 that $sp>1/n^{1-\epsilon}$. We know from Lemma 23 that \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}{Y(C)}>1}\right]\geqslant\mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}{X(C)}>1}\right]. So we are going to analyze the probability that $\sum_{C}{X(C)}>1$. And this is a straightforward analysis of independent random variables.

The probability that all the $X(C)$ are 0 is at most:

[TABLE]

(This relies on the fact that $sp\geqslant 1/n^{1-\epsilon}$.)

We can also analyze the probability that there is exactly one $C$ where $X(C)=1$. Specifically, this occurs with probability:

[TABLE]

This is maximized when $sp=1/n^{1-\epsilon}$, so we conclude that

[TABLE]

Finally, then, we conclude that \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}X(C)>1}\right]\geqslant 1-2/e-o(1). That is, with at least constant probability there is more than one $X(C)=1$, and hence \mathrm{Pr}\mathopen{}\mathclose{{}\left[\sum_{C}(Y(C))>1}\right]\geqslant\Omega(1). With constant probability, the algorithm elects more than one leader. ∎

We conclude that if a given algorithm sends at most $Mn^{2\epsilon}$ messages in expectation, then, with constant probability, it either elects zero leaders or more than one leader, thus resulting in a contradiction. This completes the proof for lower bounding the number of messages required for implicit leader election. However, for the purpose of readability we restate the theorem and the proof outline.

Theorem 15.

Suppose there is a randomized leader election algorithm that succeeds with probability $1-o(1)$ in $n$-node networks where each node has a unique ID and knows the network size $n$. Then, for every $\alpha$, where $\tfrac{1}{n^{2}}<\alpha<\tfrac{1}{12^{2}}$, there exists a graph $G$ of $\Theta(n)$ nodes and conductance $\phi=\Theta(\alpha)$ such that the algorithm requires \Omega\mathopen{}\mathclose{{}\left({\sqrt{n}}/{\phi^{3/4}}}\right) messages in expectation.

Proof Outline..

First, in section 4.1, we construct a lower bound graph $G$ for which the above theorem would hold. By lemma 16, we know that graph $G$ has conductance $\phi=\Theta(1/n^{2\epsilon})$. We then assume towards a contradiction that there exists an algorithm that solves implicit leader election by sending at most $Mn^{2\epsilon}=o(\sqrt{n}/\phi^{3/4})$ messages in expectation, where $M=o({n^{(1-\epsilon)/2}})$. Next, lemma 19 shows that any algorithm sending at most $O(Mn^{2\epsilon})$ messages in expectation would have at most $O(M)$ edges in the clique communication graph $\mathcal{CG}$ with probability $1-o(1)$. Given this, we know from lemma 20 that event $\mathsf{Disj}$ occurs with probability $1-o(1)$, i.e. connected components (distinct parts of the network) do not merge (communicate). Thereafter, lemma 21 and 22 show that these distinct parts are nearly independent i.e. the random variables representing the states of the resulting connected components (in $\mathcal{CG}$) are nearly independent of one another (behaves similarly to identically distributed and fully independent indicator random variables). Lemma 24 and 25 leverage this near independence to show that the algorithm is likely to elect either no leader or more than one leader with constant probability. This results in a contradiction and completes our proof. ∎

We also obtain the following corollaries that lower bounds the number of messages required for any algorithm that solves broadcast or constructs a spanning tree. On the constructed lower bound graph $G$, as opposed to implicit leader election, an algorithm for either broadcast or spanning tree construction would need to discover all $N=n^{1-\epsilon}$ cliques instead of just $\sqrt{N}$ cliques. In the following corollary, we lower bound the number of messages required for any broadcast algorithm.

Corollary 26**.**

Suppose that there is a randomized broadcast algorithm that succeeds with probability $1-o(1)$. Then, for every $\alpha$, where \mathopen{}\mathclose{{}\left({1}/{n^{2}}}\right)<\alpha<\mathopen{}\mathclose{{}\left({1}/{12^{2}}}\right), there exists a graph $G$ of $\Theta(n)$ nodes and conductance $\phi=\Theta(\alpha)$ such that the algorithm requires \Omega\mathopen{}\mathclose{{}\left({n}/{\sqrt{\phi}}}\right) messages in expectation.

Proof.

In the constructed lower bound graph $G$ (described in Section 4.1), observe that any broadcast algorithm would need to find all the $N=n^{1-\epsilon}$ cliques. As shown in Lemma 18, we see that discovering a yet undiscovered clique requires $\Omega(n^{2\epsilon})$ messages. Consequently, the total number of messages required to find all the cliques is $\Omega({n^{1-\epsilon}}\cdot n^{2\epsilon})$ in expectation. From Lemma 16, we know that the conductance of the graph $G$ is $\phi=1/n^{2\epsilon}$. Therefore, the algorithm would require $\Omega(n\cdot n^{\epsilon})=\Omega(n/\sqrt{\phi})$ messages in expectation. ∎

We repeat the same argument to give a message complexity lower bound for spanning tree construction.

Corollary 27**.**

Suppose that there is a randomized spanning tree construction algorithm that succeeds with probability $1-o(1)$. Then, for every $\alpha$, where \mathopen{}\mathclose{{}\left({1}/{n^{2}}}\right)<\alpha<\mathopen{}\mathclose{{}\left({1}/{12^{2}}}\right), there exists a graph $G$ of $\Theta(n)$ nodes and conductance $\phi=\Theta(\alpha)$ such that the algorithm requires \Omega\mathopen{}\mathclose{{}\left({n}/{\sqrt{\phi}}}\right) messages in expectation.

Proof.

In the constructed lower bound graph $G$ (described in Section 4.1), observe that any spanning tree construction algorithm would need to find at least $N-1=O(n^{1-\epsilon})$ cliques. As shown in Lemma 18, we see that discovering a yet undiscovered clique requires $\Omega(n^{2\epsilon})$ messages. Consequently, the total number of messages required to find all the cliques is $\Omega({n^{1-\epsilon}}\cdot n^{2\epsilon})$ in expectation. From Lemma 16, we know that the conductance of the graph $G$ is $\phi=1/n^{2\epsilon}$. Therefore, the algorithm would require $\Omega(n\cdot n^{\epsilon})=\Omega(n/\sqrt{\phi})$ messages in expectation. ∎

5 The critical knowledge of the network size

In this section, we show that the knowledge of the network size $n$ is critical for our algorithm to succeed by giving a message complexity lower bound of $\Omega(m)$ for all graphs if $n$ is not known.

In [24], Kutten et al. show a message complexity lower bound of $\Omega(m)$ in expectation for implicit leader election in general graphs (where $m$ refers to the number of edges in the network graph) even when the number of nodes in the network $n$ and the diameter of the network $D$ are known to all the nodes. Here, we show that this lower bound applies only to graphs that are not well connected or where nodes are not aware of the value of $n$. This lower bound fails for the case of well-connected graphs for the case where $n$ is known (as shown by our algorithm). However, we would like to point out that the knowledge of $n$ is critical for our algorithm to succeed.

Consider any $2$-connected graph $G_{0}$ of $n$ nodes, where nodes do not know the value of $n$ and a range $Z=[1,n^{4}]$ of ID’s. $G_{0}$ can have many instantiations, depending upon the node ID assignment and the port number mapping. An ID assignment is a function $\varphi$ : $V(G_{0})\mapsto Z$. A port mapping for node $v$ is a mapping $P_{v}:[1,deg_{v}]\mapsto\Gamma(v)$ (namely, $v$’s neighbors). A port mapping for the graph $G_{0}$ is $P=\langle P_{v_{1}},\dots,P_{v_{n}}\rangle$. Every choice of $\varphi$ and $P$ yields a concrete graph $G_{\varphi,P}$.

Theorem 28**.**

Let $\mathcal{R}$ be any implicit leader election algorithm that succeeds with probability at least $1-\beta$, for some constant $\beta\leqslant 3/56$. If $n$ is not known to the nodes, for any $2$-connected graph $G_{0}$ of $n$ nodes and $m$ edges, there exists an id assignment and a port mapping, for which the expected number of messages used by $\mathcal{R}$ on $G$ is $\Omega(m)$.

Proof.

To show the lower bound, we rely on the construction of a graph family referred to as dumbbell graphs and on a solution of an intermediate problem called bridge crossing on this graph family. In this regard, we reuse some of the work done in [24] to show that solving bridge crossing on this dumbbell graph family requires $\Omega(m)$ messages in expectation. For completeness, we rewrite some of the definitions and lemmas used in [24].

Given any $2$-connected graph $G_{0}$, lets $\mathcal{G}$ be the collection of concrete graphs $G_{\varphi,P}$ obtained from $G_{0}$ by fixing the node id assignment and the port number mapping. The set of id’s of this graph is denoted by $ID(G_{\varphi,P})=\{\varphi(v)|v\in V(G_{0})\}$. An “open graph” $G[e]$ is obtained from a graph $G\in\mathcal{G}$ by erasing an edge $e$ of $G_{0}$ and leaving the two ports that were attached to it empty. Let $G^{open}$ be the collection of open graphs obtained from $G_{0}$.

For two open graphs $G^{\prime}[e^{\prime}]$ and $G^{\prime\prime}[e^{\prime\prime}]$ with disjoint sets of id’s, $ID(G^{\prime}[e^{\prime}])\cap ID(G^{\prime\prime}[e^{\prime\prime}])=\varnothing$, let $Dumbbell(G^{\prime}[e^{\prime}],G^{\prime\prime}[e^{\prime\prime}])$ be the graph obtained by taking one copy of each of these graphs, and connecting their open ports. Hence, a dumbbell graph is composed of two open graphs plus two connecting edges, referred to as bridges. Moreover, we say that $G^{\prime}[e^{\prime}]$ participates on the left and $G^{\prime\prime}[e^{\prime\prime}]$ participates on the right in $Dumbbell(G^{\prime}[e^{\prime}],G^{\prime\prime}[e^{\prime\prime}])$. Strictly speaking, there could be two such graphs, but let us consider only one of them.

For concreteness, if $e^{\prime}=(v^{\prime},w^{\prime})$ and $e^{\prime\prime}=(v^{\prime\prime},w^{\prime\prime})$ where $ID(v^{\prime})<ID(w^{\prime})$ and $ID(v^{\prime\prime})<ID(w^{\prime\prime})$, then the graph $Dumbbell(G^{\prime}[e^{\prime}],G^{\prime\prime}[e^{\prime\prime}])$ contains the bridge edges $(v^{\prime},v^{\prime\prime})$ and $(w^{\prime},w^{\prime\prime})$. We create a collection $\mathcal{I}$ of inputs for our problem consisting of all the dumbbell graphs.

[TABLE]

Partition the collection of inputs $\mathcal{I}$ into classes as follows: for every two graphs $G^{\prime},G^{\prime\prime}\in G$, define the class C(G^{\prime},G^{\prime\prime})={Dumbbell(G^{\prime}[e^{\prime}],G^{\prime\prime}[e^{\prime\prime}])\bigm{|}e^{\prime},e^{\prime\prime}\in E(G^{\prime})}, consisting of the $m^{2}$ dumbbell graphs constructed from $G^{\prime}$ and $G^{\prime\prime}$. Finally, create a uniform distribution $\Psi$ on $\mathcal{I}$.

Similar to in [24], we define an intermediate problem on the input collection $\mathcal{I}$, called bridge crossing (BC). An algorithm for this problem is required to send a message on one of the two bridge edges connecting the two open graphs (from either direction). More precisely, any algorithm solving BC is allowed to start simultaneously at all nodes, and succeeds if during its execution, a message has crossed one of the two connecting bridge edges. (Note that in our model, the nodes are unaware of their neighbors’ identities, and in particular, the four nodes incident to the two bridge edges are unaware of this fact.)

We now give a high level overview of the main ideas of the proof. For any given $2$-connected graph $G_{0}$, we show that there exists a graph $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ in the collection $\mathcal{I}$ corresponding to $G_{0}$, for which any algorithm that solves bridge crossing requires $\Omega(m)$ messages in expectation. Here $G_{l}$ and $G_{r}$ are graphs obtained from $G_{0}$ by some id assignment and port mapping; $G_{l}[e_{l}],G_{r}[e_{r}]$ are their corresponding open graphs obtained by removing edges $e_{l}$ and $e_{r}$ respectively. The existence of the dumbell graph follows from the following lemma (from [24]) and Yao’s minmax principle (c.f. Prop. 2.6 in [30]). Thereafter, we give an indistinguishability argument in which we show that if $n$ is not known, no algorithm can distinguish between graphs $G_{l}$ and $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ (or $G_{r}$ and $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$) with sufficiently large probability by sending only $o(m)$ messages. Based on this indistinguishability argument and the fact that BC requires $\Omega(m)$ messages, we show that one side of the dumbbell graph (either $G_{l}$ or $G_{r}$) would need to send at least $m/2$ messages to solve leader election.

Lemma 29**.**

(Lemma $3.6$ of [24])* Every deterministic algorithm $\mathcal{D}$ that achieves BC on at least $1/4$ of the dumbbell graphs in the collection $\mathcal{I}$ has expected message complexity $\Omega(m)$ on $\Psi$.*

Combining the above lemma with Yao’s minmax principle, we obtain the following lemma that describes the message complexity of any algorithm for BC (both deterministic and randomized) that succeeds with sufficiently high probability ($>5/8$) on the worst case graph of $\mathcal{I}$.

Lemma 30**.**

Any algorithm $\mathcal{A}$ that solves BC with probability $>5/8$ on the worst-case graph of $\mathcal{I}$ (say $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$) has expected message complexity of at least $\Omega(m)$.

Consider a universal leader election algorithm $\mathcal{R}$ that succeeds on any given graph $G$ with probability at least $1-\beta$, where $\beta\leqslant 3/56$. We imagine running $\mathcal{R}$ in parallel on all three graphs ($Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}]),G_{l}$ and $G_{r}$) using the same random bits. Let $\mathcal{X}$ be the time-point where algorithm $\mathcal{R}$ achieves BC on the graph $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ (if $\mathcal{R}$ does not achieve BC, we consider $\mathcal{X}=\infty$). Also, let the expected number of messages sent by algorithm $\mathcal{R}$ on any graph $G$ until time-point $t$ be represented by $msg_{t}(G)$, and so $msg_{\mathcal{X}}(Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}]))$ is the expected number of messages sent by $\mathcal{R}$ up to the time-point $\mathcal{X}$ on the graph $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$.

Observe that until $\mathcal{X}$, the nodes in $G_{l}[e_{l}]$ (the left side of $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$) are not aware of the existence of $G_{r}[e_{r}]$ (as no message has traveled across the bridge edges and $n$ is also not known). As $G_{l}$ has the exact same ids as $G_{l}[e_{l}]$ and $\mathcal{R}$ uses the same random bits, until the point $\mathcal{X}$, nodes behave identically in both cases. That is, after $t$ steps (where $t<\mathcal{X}$), if node $x$ in $G_{l}[e_{l}]$ is in state $\sigma$, then node $x$ of $G_{l}$ would also be in state $\sigma$. The same argument follows for $G_{r}[e_{r}]$ and $G_{r}$. This implies that until BC, the state of any node in $G_{l}$ (resp. $G_{r}$) is identical to its corresponding node in $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ and as such, the behavior of the nodes would be identical.

Observation 31**.**

If $n$ is not known, any algorithm $\mathcal{A}$ (using the same random bits) cannot differentiate if it is running on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ or on $G_{l}$ (resp. $G_{r}$) until the time-point $\mathcal{X}$, when it achieves BC on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$. Therefore, until the point $\mathcal{X}$ the behavior of any node in $G_{l}$ (resp. $G_{r}$), would be identical to that of the corresponding node in $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$.

Let $\mathsf{succ}$ be the event that algorithm $\mathcal{R}$ successfully elects a unique leader in all the three graphs $G_{l}$, $G_{r}$ and $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ within finite time. Conditioned on $\mathsf{succ}$, let $\mathcal{Y}_{1}$ and $\mathcal{Y}_{2}$ be the time-points where $\mathcal{R}$ solves leader election on $G_{l}$ and $G_{r}$ respectively ($\mathcal{Y}_{1}\neq\infty$ and $\mathcal{Y}_{1}\neq\infty$). That is, after $\mathcal{Y}_{1}$ (resp. $\mathcal{Y}_{2}$), exactly one node elects itself as the leader and no more messages are sent on $G_{l}$ (resp. $G_{r}$). We also define $\mathcal{Y}=\max(\mathcal{Y}_{1},\mathcal{Y}_{2})$. Using the fact that bridge crossing requires $\Omega(m)$ messages on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$, we will show that leader election takes at least $\Omega(m/2)$ messages either for graph $G_{l}$ or for graph $G_{r}$. In this regard, we consider two different possibilities, each of which is conditioned on the event $\mathsf{succ}$.

Case 1 : $\mathcal{Y}<\mathcal{X}$. We show that this case is not possible by showing a contradiction. As $\mathcal{Y}<\mathcal{X}$ , it implies that $\mathcal{R}$ solves LE on both $G_{l}$ and $G_{r}$ before solving BC on the graph $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$. From Observation 31, we know that $\mathcal{R}$ cannot differentiate if it is running on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ or on $G_{l}$ (resp. $G_{r}$) until the point $\mathcal{X}$. Therefore algorithm $\mathcal{R}$ on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ would behave in an identical fashion with that in $G_{l}$ (resp. $G_{r}$) and would elect two leaders (one from $G_{l}$ and other from $G_{r}$). Thus contradicting our assumption of event $\mathsf{succ}$. This also tacitly implies that if event $\mathsf{succ}$ happens then $\mathcal{R}$ also solves BC (as $\mathcal{X}$ cannot be $\infty$).

Case 2 : $\mathcal{Y}\geqslant\mathcal{X}$. This case implies that either both $\mathcal{Y}_{1}\geqslant\mathcal{X}$ and $\mathcal{Y}_{2}\geqslant\mathcal{X}$ or only either one of them is $\geqslant\mathcal{X}$. Using Observation 31, we can say that the total number of messages sent upto the point $\mathcal{X}$ by running $\mathcal{R}$ on $G_{l}$ and $G_{r}$ is exactly equal to the number of messages sent by running $\mathcal{R}$ on $Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}])$ until time $\mathcal{X}$. There also might be some additional messages sent on $G_{l}$ and/or $G_{r}$ as $\mathcal{Y}\geqslant\mathcal{X}$. Therefore, the total number of messages sent by $\mathcal{R}$ on $G_{l}$ and $G_{r}$ would be at least $msg_{\mathcal{X}}(Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}]))$. By Lemma 30, we know that $msg_{\mathcal{X}}(Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}]))\geqslant\Omega(m)$. Thus, we see that $msg_{\mathcal{Y}_{1}}(G_{l})+msg_{\mathcal{Y}_{2}}(G_{r})\geqslant msg_{\mathcal{X}}(Dumbbell(G_{l}[e_{l}],G_{r}[e_{r}]))\geqslant\Omega(m)$.

That is, conditioned on the event $\mathsf{succ}$, either $msg_{\mathcal{Y}_{1}}(G_{l})\geqslant\Omega(m/2)$ or $msg_{\mathcal{Y}_{2}}(G_{r})\geqslant\Omega(m/2)$. Without loss of generality, assume that $msg_{\mathcal{Y}_{1}}(G_{l})\geqslant msg_{\mathcal{Y}_{2}}(G_{r})$. Also, since $\mathcal{R}$ is a universal leader election algorithm that succeeds on any given graph with probability at least $1-\beta$, where $\beta\leqslant 3/56$, then the probability that event $\mathsf{succ}$ happens would be $\geqslant(1-\beta)^{3}\geqslant 4/5$. This implies from above \mathbb{E}\mathopen{}\mathclose{{}\left[\text{Messages sent on }G_{L}\mid\mathsf{succ}}\right]\geqslant\Omega(m/2). To calculate the value of \mathbb{E}\mathopen{}\mathclose{{}\left[\text{Messages sent on }G_{L}}\right], we use \mathbb{E}\mathopen{}\mathclose{{}\left[\text{Messages sent on }G_{L}}\right]\geqslant\mathbb{E}\mathopen{}\mathclose{{}\left[\text{Messages sent on }G_{L}\mid\mathsf{succ}}\right]\cdot\mathrm{Pr}(\mathsf{succ})\geqslant\Omega(m/2)\cdot 4/5=\Omega(m). We consider the $msg_{\mathcal{Y}_{1}}(G_{l})=\Omega(m)$ as the worst case message complexity and the corresponding graph as the worst case graph. The existence of this worst-case graph proves the theorem. ∎

6 Conclusion

In this paper we show that implicit leader election can be achieved in sub-linear message complexity for sufficiently well-connected graphs. This shows that the major communication cost for the explicit variant of the leader election comes from broadcasting the leader information to all the nodes rather than the process of electing a leader.

Furthermore, we observe that that there exists a possible gap of $O(1/\phi^{5/4})$ between the upper and the lower bounds shown here. It remains an interesting open problem to see if this gap can be reduced further.

Acknowledgments

This research was supported by AcRF Tier $1$ grant T1 251RES1719 (Adaptive Data Structures: Concurrent, Cache-Efficient, Distributed). Peter Robinson acknowledges the support of the Natural Sciences and Engineering Research Council of Canada (NSERC).