Time-optimal construction of overlay networks

This article shows how to construct an overlay network of constant degree and diameter O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} in O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} time starting from an arbitrary weakly connected graph. We assume a synchronous communication network in which nodes can send messages to nodes they know the identifier of, and new connections can be established by sending node identifiers. Suppose the initial network’s graph is weakly connected and has constant degree. In that case, our algorithm constructs the desired topology with each node sending and receiving only O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} messages in each round in O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} time w.h.p., which beats the currently best O(log3/2n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log ^{3/2} n)$$\end{document} time algorithm of Götte et al. (International colloquium on structural information and communication complexity (SIROCCO), Springer, 2019). Since the problem cannot be solved faster than by using pointer jumping for O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} rounds (which would even require each node to communicate Ω(n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\Omega (n)$$\end{document} bits), our algorithm is asymptotically optimal. We achieve this speedup by using short random walks to repeatedly establish random connections between the nodes that quickly reduce the conductance of the graph using an observation of Kwok and Lau (Approximation, randomization, and combinatorial optimization. Algorithms and techniques (APPROX/RANDOM 2014), Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2014). Additionally, we show how our algorithm can be used to efficiently solve graph problems in hybrid networks (Augustine et al. in Proceedings of the fourteenth annual ACM-SIAM symposium on discrete algorithms, SIAM, 2020). Motivated by the idea that nodes possess two different modes of communication, we assume that communication of the initial edges is unrestricted, whereas only polylogarithmically many messages can be sent over edges that have been established throughout an algorithm’s execution. For an (undirected) graph G with arbitrary degree, we show how to compute connected components, a spanning tree, and biconnected components in O(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log n)$$\end{document} time w.h.p. Furthermore, we show how to compute an MIS in O(logd+loglogn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log d + \log \log n)$$\end{document} time w.h.p., where d is the initial degree of G.


INTRODUCTION
Many modern distributed systems (especially those which operate via the internet) are not concerned with the physical infrastructure of the underlying network.Instead, these large scale distributed systems form logical networks that are often referred to as overlay networks or peer-to-peer networks.In these networks, nodes are considered as connected if they know each other's IP-Addresses.Practical examples for such systems are cryptocurrencies, the Internet of Things, or the Tor network.Further examples include overlay networks like Chord [54], Pastry [51], and skip graphs [3].In this work, we consider the fundamental problem of constructing an overlay network of low diameter as fast as possible from an arbitrary initial state.Note that (log( )) this is the obvious lower bound for the problem: If the nodes initially form a line, then it takes (log ) rounds for the two endpoints to learn each other, even if every node could introduce all of its neighbors to one other in each round.
To the best of our knowledge, the first overlay construction algorithm with polylogarithmic time and communication complexity that can handle (almost) arbitrary initial states has been proposed by Angluin et al. [2].Here, the authors assume a weakly connected graph of initial degree .If in each round each node can send and receive at most messages, and new edges can be established by sending node identifiers, their algorithm transforms the graph into a binary search tree of depth (log ) in time ( + log2 ), w.h.p. 1 Since a low-depth tree can easily be transformed into many other topologies (and fundamental problems such as sorting or routing can easily be solved from such a structure), this idea has sparked a line of research investigating how quickly such overlays can be constructed.For example, [4] gives an (log ) time algorithm for graphs with outdegree 1.If the initial degree is polylogarithmic, and nodes can send and receive a polylogarithmic number of messages, there is a deterministic (log 2 ) time algorithm [29].Very recently, this has been improved to (log 3/2 ), w.h.p. [30].However, to the best of our knowledge, there is no (log( ))-time algorithm that can construct a well-defined overly with logarithmic communication (Table 1 provides an overview over the works that can be compared with our result).In this paper, we finally close the gap and present the first algorithm that achieves these bounds, w.h.p.All of the previous algorithms (i.e, [2,4,27,29,30]) essentially employ the same high-level approach of [2] to alternatingly group and merge so-called supernodes (i.e., sets of nodes that act in coordination) until only a single supernode remains.However, these supernodes need to be consolidated after being grouped with adjacent supernodes to distinguish internal from external edges.This consolidation step makes it difficult to improve the runtime further using this approach.Instead, we use a radically different approach, arguably much simpler than existing solutions.It is based on classical overlay maintenance algorithms for unstructured networks such as, for example, [40] or [28] 2 , as well as practical libraries for overlays like JXTA [48] or the overlay of Bitcoin.
Instead of arranging the nodes into supernodes (and paying a price of complexity and runtime for their maintenance), we simply establish random connections between the nodes by performing short constant length random walks.Each node starts a small number of short random walks, connects itself with the respective endpoints, and drops all other connections.Then, it repeats the procedure on the newly obtained graph.Using novel techniques by Kwok and Lau [38] combined with elementary probabilistic arguments, we show that short random walks incrementally reduce the conductance of the graph.Once the conductance is constant, the graph's diameter must be (log ).Note that such a graph can easily be transformed into many other overlay networks, such as a sorted ring, e.g., by performing a BFS and applying the algorithm of Aspnes and Wu [4] to the BFS tree or by using the techniques by Gmyr et al. [29]

Related Work
The research on overlay construction is not limited to the examples given in the introduction.Since practical overlay networks are often characterized by dynamic changes coming from churn or adversarial behavior, a vast amount of papers focus on reaching and maintaining a valid topology of the network in the presence of faults.These works can be roughly categorized into two areas.On the one hand, there are so-called self-stabilizing overlay networks, which try to detect invalid configurations locally and recover the system into a stable state (see, e.g., [21] for a comprehensive survey).However, since most solutions focus on a very general context (such as asynchronous message passing and arbitrary corrupted memory), only a few algorithms provably achieve polylogarithmic runtimes [14,33], and most have no bounds on the communication complexity.On the other hand, there are overlay construction algorithms that explicitly use only polylogarithmic communication per node and proceed in synchronous rounds.In this category, we have algorithms that maintain an overlay topology under randomized or adversarial errors.These works focus on quickly reconfiguring the network to distribute the load evenly (under churn) or to reach an unpredictable topology (in the presence of an adversary) [9,10,18,31].However, a common assumption is that the overlay starts in some welldefined initial state.The work by Gilbert et al. [27] combines the fast overlay construction with adversarial churn.They present a construction algorithm that tolerates adversarial churn as long as the network always remains connected and there eventually is a period of length Ω(log( ) 2 ) where no churn happens.The exact length of this period depends on the goal topology.Further, there is a paper by Augustine et al. [6] that considers ( )-time algorithms for so-called graph realization problems.Their goal is to construct graphs of any given degree distributions as fast as possible.They assume, however, that the network starts as a line, which makes the construction of the graphs considered in this work very easy.
One of the main difficulties in designing algorithms to construct overlay networks quickly lies in the node's limited communication capabilities in a broader context.Therefore, our algorithm further touches on a fundamental question in designing efficient algorithms for overlay networks: How can we exploit the fact that we can (theoretically) communicate with every node in the system but are restricted to sending and receiving (log( )) messages.Recently, the impact of this restriction has been studied in the so-called Node-Capacitated Clique (NCC) model [7], in which the nodes are connected as a clique and can send and receive at most (log ) messages in each round.The authors present ( ) algorithms (where (•) hides polylogarithmic factors, and is the arboricity 3 of ) for local problems such as MIS, matching, or coloring, a ( + ) algorithm for BFS tree, and a (1) algorithm for the minimum spanning tree (MST) problem.Robinson [50] investigates the information the nodes need to learn to solve graph problems and derives a lower bound for constructing spanners in the NCC.Interestingly, his result implies that spanners with constant stretch require polynomial time in the NCC and are therefore harder to compute than MSTs.As pointed out in [20], the NCC is, under certain limitations, able to simulate PRAM algorithms efficiently.If the input graph's degree is polylogarithmic, for example, we easily obtain polylogarithmic time algorithms for (minimum) spanning forests [17,32,49].Notably, Liu et al. [42] recently proposed an (log +log log / ) time algorithm for computing connected components in the CRCW PRAM model, which would also likely solve overlay construction.[8,37].Note that these algorithms require very high (local) communication.If the initial graph is very sparse, then SSSP can be solved in (small) polylogarithmic time and with limited local communication, exploiting the power of the NCC [20].

Model
We consider overlay networks with a fixed node set .Each node has a unique identifier id( ), which is a bit string of length (log ), where = | |.Further, time proceeds in synchronous rounds 4 .We represent the network as a directed graph = ( , ), where there is a directed edge ( , ) ∈ if knows id( ).
If knows id( ) in round , then it can send a message to that will be received at the beginning of round + 1.New connections can be established by sending node identifiers: if sends id( ) to , then can establish an edge ( , ).
We restrict the size of a message to (log ) bits, which allows a message to carry a constant number of identifiers.
Furthermore, we limit the total number of messages each node can send and receive in each round.More precisely, in this paper we distinguish two different model variants: NCC 0 model: Each node can send and receive at most (log ) messages in each round.This corresponds to the socalled NCC 0 model [6], which is a variant of the general Node-Capacitated Clique (NCC) model for overlay networks [7].
The bound of (log ) is argued as a natural choice, preventing algorithms from being needlessly complicated while still ensuring scalability.Since this model is very general, our main algorithm will be presented in this model.

Hybrid model:
As in the hybrid model of Augustine et al. [8], we distinguish between local edges, which are edges of the initial networks, and global edges, which are additional edges that are established throughout an algorithm's execution.In each round, every node can send a single message of size (log ) over each local edge, which corresponds to the CONGEST model.Furthermore, it can send and receive a polylogarithmic number of messages over global edges.
Note that our model corresponds to the model of [8] for local capacity = (1) and global capacity = (1) with the difference that global edges need to be established explicitly, whereas the global network forms a clique in [8].Further, whereas the algorithms presented in [8] require each node to only send and receive (log ) messages in each round using the global network (i.e., the global capacity is (log )), we allow polylogarithmically many messages to be sent.This allows us to achieve very efficient algorithms even for high initial node degrees without focusing too much on the technicalities required to achieve a global capacity of (log ).
We assume that if (in any of these models) more messages than allowed are sent to a node, the node receives an arbitrary subset (and the rest is simply dropped by the network).Furthermore, we assume that every node has sufficient memory for our protocol to work correctly and every node is sufficiently fast so that it can process all messages that arrived at the beginning of round within that round5 .

Problem Statement(s) & Our Contribution
Before we formally define the problems considered in this paper, we first review some basic concepts from graph theory.
Recall that = ( , ) is a directed graph.A node's outdegree denotes the number of outgoing edges, i.e., the number of identifiers it stores.Analogously, its indegree denotes the number of incoming edges, i.e., the number of nodes that store its identifier.A node's degree is the sum of its in-and outdegree, and the graph's degree is the maximum degree of any node, which we denote by .We say that a graph is weakly connected if there is a (not necessarily directed) path between all pairs of nodes.A graph's diameter is the maximum over all node pairs , of the length of a shortest path between and (where we ignore the edges' directions).
Although is a directed (knowledge) graph, for the problems considered in this paper we regard as being undirected.Our algorithms ensure that the graph can always easily be made bidirected by letting each node introduce itself to all of its neighbors.Further, note that apart from the first of the following problems, all problems aim at finding a solution with respect to the initial structure of (the undirected version of) .
The main goal of this paper is to construct a well-formed tree, which is a rooted tree of constant degree and diameter (log ) that contains all nodes of .Our main result, which is presented in Section 2 and proven in Section 2.3, is the following.
Theorem 1.1 (Main Theorem).Let = ( , ) be a weakly connected directed graph with degree (1).There is a randomized algorithm that constructs a well-formed tree = ( , ) in (log ) rounds, w.h.p., in the NCC 0 model.Over the course of the algorithm, each node sends a total of at most (log 2 ) messages, w.h.p.
Since it takes time Ω(log ) to construct a well-formed tree starting from a line even with unbounded communication, our runtime is asymptotically optimal.We remark that we do not require the nodes to know exactly; however, they do need to know an upper bound ≥ log on log such that = (log ).
If the initial degree was ( ), and the nodes were allowed to process Θ( •log ) many messages, then our algorithm could also achieve a runtime of (log ).Therefore, our result directly improves upon the (log 3/2 ) time algorithm of [30], who assume a polylogarithmic degree and allow polylogarithmic communication.Note that a direct comparison to the model of Angluin et al. [2,4] is a bit difficult: In their model, each node can only send a single message in each round, and, if the initial degree is , there is a lower bound of ( + log ).It is still unclear whether our techniques could be applied to meet the lower bound of their model.They also pose the question of whether there is an (log ) time algorithm if each node is allowed to communicate messages; as stated above, we only answer this question affirmatively for the case that Θ( • log ) messages can be sent and received, which might not be optimal.
1.3.1 Applications & Implications.An immediate corollary of our result is that any "well-behaved" overlay of logarithmic degree and diameter (e.g., butterfly networks, path graphs, sorted rings, trees, regular expanders, De Brujin Graphs, etc.) can be constructed in (log ) rounds, w.h.p.These overlays can be used by distributed algorithms to common tasks like aggregation, routing, or sampling in logarithmic time.Furthermore, we point out the following implications of this result.
(1) Every monitoring problem presented in [29] can be solved in time (log ), w.h.p., instead of (log 2 ) deterministically.These problems include monitoring the graph's node and edge count, its bipartiteness, as well as the approximate and exact weight of an MST.
(3) For most algorithms that have been presented for the NCC (and hybrid networks that model the global network by the NCC) [7,8,20], the rather strong assumption that all node identifiers are known may be dropped.Instead, if the initial knowledge graph has degree (log ), we can construct a butterfly network in time (log ), which suffices for most primitives to work (note that all presented algorithms have a runtime of Ω(log ) anyway).
We strongly believe that our techniques could lead to networks that are highly robust against churn and DoS-attacks, at least as long as the churn is oblivious.An adversary with full knowledge of the communication graph that can decide, which nodes join and leave the network in given round, can easily identify minimum cuts in the network and disconnect it.If, however, the nodes fail independently and random with a certain probability, say , a logarithmic sized minimum cut (of different nodes) is enough to keep the network connected w.h.p.We touch a bit more on this topic in the end.
In Section 3, we then give some applications of the algorithm for the hybrid model.As already pointed out, all of the following algorithms can be performed in the hybrid network model of Augustine et al. [8] for = (log ) and = (1), which provides a variety of novel contributions for hybrid networks 6 .For each algorithm we give a bound on the required global capacity.Note that using more sophisticated techniques, our algorithms may very likely be optimized to require a much smaller global capacity.We remark that all of the following algorithms can be adapted to achieve the same runtimes in the NCC 0 model, if the initial degree is constant.
Connected Components.Here, we consider a graph that is not (necessarily) connected.For each connected component of , we want to establish a well-formed tree that contains all nodes of .The section begins by presenting an adaption of our main algorithm in Section 3.1 that circumvents some problems introduced by the potentially high node degrees.As a first application of this algorithm, in Section 3.2 we show how to establish a well-formed tree on each connected component of (if is not connected initially).Theorem 1.2.Let = ( , ) be a directed graph.There is a randomized algorithm that constructs a well-formed tree on each connected component of (the undirected version of) in (log ) rounds, w.h.p., in the hybrid model.Further, if all components have a (known) size of ( ), the runtime reduces to (log + log log ) rounds, w.h.p.The algorithm requires global capacity (log 3 ), w.h.p.
Here, we first need to transform the graph into a low-arboricity spanner using the efficient spanner construction of Miller et al. [45], which was later refined by Elkin and Neiman [19].Here, each node ∈ draws an exponential random variable and broadcasts it for (log( ) rounds.Each node keeps all edges via which it first received the value that minimizes ( , ) − .We show that, if the size of each component is bounded by , it suffices to observe variables smaller than 2 log( ) as there are (log ) nodes that draw higher value w.h.p.The nodes that draw higher values, simply discard them.This speeds the algorithm to (log( )) while still producing a subgraph with few edges.This graph can then be rearranged into a connected (log )-degree network, allowing us the apply our main algorithm of Theorem 1.1.

Spanning Trees.
Here, the goal is to compute a (not necessarily minimum) spanning tree of .In Section 3.3, we show how to obtain a spanning tree of the initial graph by "unwinding" the random walks over which the additional edges have been established.
Theorem 1.3.Let = ( , ) be a weakly connected directed graph.There is a randomized algorithm that constructs a spanning tree of (the undirected version of) in (log ) rounds, w.h.p., in the hybrid model.The algorithm requires global capacity (log 5 ), w.h.p.
It is unclear whether our algorithm also helps in computing an MST; it seems that in order to do so we would need different techniques.
Biconnected Components.We call an undirected graph biconnected, if every two nodes , ∈ are connected by two directed node-disjoint paths.Intuitively, biconnected graphs are guaranteed to remain connected, even if a single node fails.Our goal is to find the biconnected components of , which are the maximal biconnected subgraphs of .
Note that cut vertices, which are nodes whose removal increases the number of connected components, are contained in multiple biconnected components.
We show how to apply the PRAM algorithm of Tarjan and Vishkin [55] to compute the biconnected components of a graph to the hybrid model.The algorithm relies on a spanning tree computation, which allows us to use Theorem 1.3 to achieve a runtime of (log ), w.h.p.
Theorem 1.4.Let = ( , ) be a weakly connected directed graph.There is a randomized algorithm that computes the biconnected components of (the undirected version of) in (log ) rounds, w.h.p., in the hybrid model.Furthermore, the algorithm computes whether is biconnected, and, if not, determines its cut nodes and bridge edges.The algorithm requires global capacity (log 5 ), w.h.p.
Maximal Independent Set (MIS).In the MIS problem, we ask for a set ⊆ such that (1) no two nodes in are adjacent in the initial graph and (2) every node ∈ \ has a neighbor in .We present an efficient MIS algorithm that combines the shattering technique [12,23] with our overlay construction algorithm to solve the MIS problem in almost time (log ), w.h.p.This technique shatters the graph into small components of undecided nodes in time (log( )).
In these components we can efficiently compute MIS solutions using a spanning tree of depth (log(log( ))) which we can compute in (log(log( ))) rounds.This leads to an (log + log log ) time algorithm, where is the initial graph's degree.
Theorem 1.5.Let = ( , ) be a weakly connected directed graph.There is a randomized algorithm that computes an MIS of in (log + log log ) rounds, w.h.p., in the hybrid model.The algorithm requires global capacity (log 3 ), w.h.p.

Mathematical Preliminaries
Before we give the description of our main algorithm, we introduce some notions from probability and graph theory that we will frequently use throughout the remainder of this paper.First, we heavily use a well-known Chernoff Bound, which is a standard tool for the analysis of distributed algorithms.In particular, we will use the following version: ).Let = =1 for independent random variables ∈ {0, 1} and E( ) ≤ and ≥ 1.
Similarly, for E( ) ≥ and 0 ≤ ≤ 1 we have Furthermore, our analysis will heavily rely on the (small-set) conductance of the communication graph.The conductance of set ⊂ is the ratio of its outgoing edges and its size | |.The conductance Φ( ) of a graph is the minimal conductance of every subset.More precisely, we will need a more generalized notion of small-set conductance that only observes sets of a certain size.Formally, the small-set conductance is defined as follows: Definition 1.7 (Small-Set Conductance).Let := ( , ) be a connected Δ-regular graph and ⊂ with | | ≤ | | 2 be any subset of with at most half its nodes.Then, the conductance Φ( ) ∈ (0, 1) of is defined as follows: For a parameter ∈ (0, 1) the (small-set) conductance of is then defined as: 8. For = 1, we call Φ( ) := Φ 1 ( ) simply the conductance of .

THE OVERLAY CONSTRUCTION ALGORITHM
In this section, we present our algorithm to construct a well-formed tree in time (log ), w.h.p., and give an overview of the proof to establish the correctness of Theorem 1.1.To the best of our knowledge, our approach is different from all previous algorithms for our problem [3,4,29,30] in that it does not use any form of clustering to contract large portions of the graph into supernodes.From a high level, our algorithm progresses through (log ) graph evolutions, where the next graph is obtained by establishing random edges on the current graph.More precisely, each node of a graph simply starts few random walks of constant length and connects itself with the respective endpoints.The next graph only contains the newly established edges.We will show that after (log ) iterations of this simple procedure, we reach a graph that has diameter (log ).
One can easily verify that this strategy does not trivially work on any graph, as the graph's degree distributions and other properties significantly impact the distribution of random walks.However, as it turns out, we only need to ensure that the initial graph has some nice properties to obtain well-behaved random walks.More precisely, throughout our algorithm, we maintain that the graph is benign, which we define as follows.
Definition 2.1 (Benign Graphs).Let := ( , ) be a directed graph and Δ, Λ = Ω(log ) be two arbitrary values (with big enough constants hidden by the Ω-Notation).Then, we call benign if and only if it has the following three properties: (1) ( is Δ-regular) Every node ∈ has exactly Δ in-and outgoing edges (which may be self-loops).
The properties of benign graphs are carefully chosen to be as weak as possible while still ensuring the correct execution of our algorithm.A degree of Δ = Ω(log ) is necessary to keep the graph connected.If we only had a constant degree, a standard result from random graphs implies that w.h.p. there would be nodes disconnected from the graph when sampling new neighbors.If the graphs were not lazy, many theorems from the analysis of Markov chains would not hold as the graph could be bipartite, which would greatly complicate the analysis.This assumption only slows down random walks by a factor of 2. Lastly, the Λ-sized cut ensures that the graph becomes more densely connected in each evolution, w.h.p.In fact, with constant-sized cuts, we cannot easily ensure this property when using random walks of constant length.

Algorithm Description
We will now describe the algorithm in more detail.Recall that throughout this section, we will assume the NCC 0 model, which means that each node can send and receive (log ) distinct messages.Further, we assume for simplicity that the initial graph has at most a constant maximal degree = (1) and is connected. 7esides the initial set of edges, the algorithm has four input parameters ℓ, Δ, Λ, and that are known to all nodes.
Recall that = (log ) is an upper bound on log .The value ℓ = Ω(1) denotes the length of the random walks, Δ = (log ) is the desired degree, and Λ = (log ) denotes the size of the minimum cut.All of these parameters are tunable and the hidden constants need to be chosen big enough for the algorithm to succeed w.h.p.We discuss this in more detail in the analysis.
Before the first evolution, we need to prepare the initial communication graph to comply with these parameters, i.e., we must turn it into a benign graph.Since the input graph has a maximal degree of = (1), this is quite simple as we can assume 2 Λ ≤ Δ = (log ).Given this assumption, the graph can be turned benign in 2 steps.First, all edges are copied Λ times to obtain the desired minimum cut.After this step, each node has at most Λ edges to other nodes.Then, each node adds self-loops until its degree is Δ and each node has Δ 2 self-loops.As we chose 2 Λ ≤ Δ, this is always possible.
Let now 0 = ( , 0 ) be the resulting benign graph.The algorithm proceeds in iterations 1, . . ., .In each iteration, a new communication graph = ( , ) is created through sampling Δ 8 new neighbors via random walks of length ℓ.Each node ∈ creates Δ 8 messages containing its own identifier, which we call tokens.Each token is randomly forwarded for ℓ rounds in .More precisely, each node that receives a token picks one of its incident edges in uniformly at random and sends the token to the corresponding node. 8If receives less than 3  8 Δ tokens after ℓ steps, it sends its own identifier back to all the tokens' origins to create a bidirected edge.Otherwise, it picks 3  8 Δ tokens at random (without replacement) 9 .Since the origin's identifier is stored in the token, both cases can be handled in one communication round.Finally, each node adds self-loops until its degree is Δ again.The whole procedure is given in Figure 1 as the method C E ( 0 , ℓ, Δ, Λ, ).The subroutine M B ( 0 , ℓ, Δ, Λ) add edges and selfloops to make the graph comply to Definition 2.1.Our main observation is that after = (log ) iterations, the resulting graph has constant conductance, w.h.p., which implies that its diameter is (log ).Furthermore, the degree of is (log ).To obtain a well-formed tree , we first perform a BFS on starting from the node with lowest identifier 10 .This requires time (log ) and gives us a rooted tree with degree and diameter (log ).To transform this tree into a well-formed tree, we perform the merging step of the algorithm of [29,Theorem 2].From a high level, the algorithm first transforms into a constant-degree child-sibling tree [4], in which each node arranges its children as a path and only keeps an edge to one of them.Using the Euler tour technique (see, e.g., [55]), this tree is then transformed into a rooted tree of constant degree and depth (log ) in time (log ).This tree is our desired well-formed tree , which concludes the algorithm.

Analysis Overview
Before we go into the proof's intricate details, let us first prove that during the execution of the algorithm all messages are successfully sent.Remember that we assume the nodes to have a capacity of (log ) and thus a node can only send and receive (log ) messages as excess messages are dropped.That means, in order to prove that no message is dropped, we must show that no node receives more than (log ) random walk tokens in a single step.
For the proof, we observe a well known fact about the distribution of random walks that has been independently shown in [18], [16] and [52]: [16,18,52]).For a node ∈ and an integer let ( , ) be the random variable that denotes the number of token at node in round .Then, it holds Pr ( , .
The lemma follows from the fact that each node receives Δ 8 tokens in expectation given that all neighbors received Δ 8 tokens in the previous round.This holds because is regular.Since all nodes start with Δ 8 tokens, the lemma follows inductively.Since all walks are independent, a simple application the Chernoff Bound yields the result.Note that this Lemma also directly implies that, w.h.p., all random walks create an edge as every possible endpoint receives less than 3Δ 8 token and therefore replies to all of them.In the remainder the analysis we will implicitly condition all random choices on these facts.
The main challenge of our analysis is to show that after ∈ (log( )) evolutions, the final graph has diameter of (log( )).Given this fact, the technique from [29, Theorem 2] transforms into well-formed tree in (log( )) rounds.Thus, our analysis will focus on showing that has logarithmic diameter.To do so, we will perform an induction over the sequence of graphs G := 1 , . . ., .Our main insight is that -given the communication graph is benign -we can use short random walks of constant length to iteratively increase the graph's conductance until we reach a graph of low diameter.In particular, we show that the graph's conductance is strictly increasing by a factor L 2.3.Let and +1 be the graphs created in iteration and + 1 respectively and assume that is benign with a minimum cut of at least Λ ≥ 640.Then, it holds In particular, for any ℓ ≥ 2 • 640 2 , it holds Intuitively, this makes sense as the conductance is a graph property that measures how well-connected a graph is and -since the random walks monotonically converge to the uniform distribution -the newly sampled edges can only increase the graph's connectivity.
To be precise, our main argument is the fact that random walks of length ℓ are distributed according to ℓ , where ℓ is the ℓ ℎ power of the random walk matrix for .Since, for the most part, we will consider the evolution from to +1 , we will refer to Φ( ) and Φ( ℓ ) simply as Φ and Φ ℓ .In particular, if we consider a subset ⊂ , then Φ ℓ denotes the probability that a random walk ends outside of the subset after ℓ steps, in which case the corresponding node creates an edge outgoing of the subset.Since we ensure that the total number of edges in a set stays constant, this creation of an outgoing edge increases the set's conductance in expectation.Thus, we can show the following lemma: L 2.4.Given that each node starts Δ 8 tokens, which all create an edge, it holds: Therefore, a lower bound on Φ ℓ gives us a lower bound on the expected conductance of the newly sampled graph.
However, the standard Cheeger inequality (see, e.g., [53] for an overview) that is most commonly used to bound a graph's conductance with the help of the graph's eigenvalues does not help us in deriving a meaningful lower bound for Φ ℓ .In particular, it only states that Φ ℓ = Θ(ℓΦ 2 ).Thus, it only provides a useful bound if ℓ = Ω(Φ −1 ), which is too big for our purposes, as Ω(Φ −1 ) is only constant if Φ is already constant.More recent Cheeger inequalities shown in [41] relate the conductance of smaller subsets to higher eigenvalues of the random walk matrix.On the first glance, this seems to be helpful, as one could use these to show that at least the small sets start to be more densely connected and then, inductively, continue the argument.Still, even with this approach, constant length walks are out of the question as the new Cheeger inequalities introduce an additional tight (log ) factor in the approximation for these small sets.
Thus, the random walks would need to be of length Ω(log ), which is still too much to achieve our bounds.Instead, we use the following result by Kwok and Lau [38], which states that every Φ ℓ improves even for constant values of ℓ.
It holds that: ]).Let = ( , ) be any connected Δ-regular lazy graph with conductance Φ and let ℓ be its ℓ th power.For a set ⊂ define Φ ℓ ( ) as the conductance of in ℓ .Then, it holds: Given this bound, we can show that benign graphs indeed increase their (expected) conductance from iteration to iteration.
However, this fact alone is not enough to finalize the proof.Recall that we need to show that every subset has a conductance of ( √ ℓΦ( )) in +1 in order to prove that Φ( +1 ) = Ω( √ ℓΦ( )).Since there are exponentially many subsets, a bound in the magnitude of ( − ) is not sufficient.Now recall that, since the number of edges within is unchanged, the rising conductance implies that the number of outgoing edges of each set rises by Ω( √ ℓ) (or reaches . Thus, given that has Λ outgoing edges, the value of Φ +1 ( ) is concentrated around its expectation with probability −Ω Λ .This follows from the Chernoff bound and the fact that the random walks are quasi independent 11 .This is then used to derive the high probability bound.By a celebrated result of Karger, the number of subsets with Λ outgoing edges can be bounded by ( 2 ) [35].Thus, for a big enough Λ, a bound of −Ω ( Λ) is enough to show all sets increase their conductance.
Since all the arguments from before only hold if is benign, we must additionally make sure that each graph in G := 1 , . . ., is indeed begnin.As before, we prove this step by step and show that +1 is benign given that is benign.
L 2.6.Let and +1 be the graphs created in iteration and + 1 respectively and assume that is benign.
While the regularity and the laziness follow directly from observing the algorithm, the minimum is cut trickier.
Here, we need to use an argument similar to the one used for proving the conduction: We show that every subset (in expectation) has cut of size 2Λ if we choose ℓ big enough.This follows again from a lemma in [38] and a connection between the minimum cut and the small set expansion.Finally, we again use the Chernoff bound in conjunction with Karger's lemma to proof that all cuts are bigger than Δ w.h.p.
To round up the analysis, we now only need to show that after (log ) iterations, the graph has a diameter of (log ).For this, we need two more facts:.First, we observe the worst possible initial conductance.
The former follows from the fact that in the worst case there is an ( )-sized set that is connected to the remaining graph by a single edge.Second, we observe that a constant conductance implies a logarithmic diameter if the graph is regular.It holds: ).Let := ( , ) be any Δ-regular graph with conductance Φ, then the diameter of is at most (Φ −1 log ).
This implies a diameter of 2 ∈ (Φ −1 log( )) Given that after every iteration the graph's conductance increases by a factor ( √ ℓ) w.h.p, a simple union bound tells us, as long as we consider ( ) iterations, the conductance is increases in every iteration w.h.p.Thus, after log Φ log ℓ = (log ) iterations, the most recent graph must have constant conductance, w.h.p.Therefore, since each iteration lasts only ℓ = (1) rounds, after (log ) rounds the graph has a constant conductance and thus logarithmic diameter.This concludes the analysis.

Analysis of C E
We now provide a more detailed analysis Before we go into the proof's intricate details, let us first prove that all messages are successfully sent during the execution of the algorithm.Remember that we assume the nodes to have a capacity of (log ) and thus, a node can only send and receive (log ) messages as excess messages are dropped arbitrarily.That means, in order to prove that no message is dropped, we must show that no node receives more than (log ) random walk tokens in a single step.However, this is a well known fact about the distribution of random walks: L 2.9 (S [16,18,52]).For a node ∈ and an integer let ( , ) be the random variable that denotes the number of token at node in round .Then, it holds P ( , ) ≥ 3Δ 8 ≤ − Δ 8 .
The lemma follows from the fact that each node receives Δ 8 tokens in expectation given that all neighbors received Δ 8 tokens in the previous round.This holds because is regular.Since all nodes start with Δ 8 tokens, the lemma follows inductively.Since all walks are independent, a simple application of the Chernoff Bound yields the result.Note that this Lemma also directly implies that, w.h.p., all random walks create an edge as every possible endpoint receives less than 3Δ  8 token and therefore replies to all of them.In the remainder of the analysis, we will implicitly condition all random choices on these facts.
The main challenge of our analysis is to show that after ∈ (log( )) evolutions, the final graph has diameter of (log( )).Given this fact, the technique from [29, Theorem 2] transforms into well-formed tree in (log( )) rounds.Thus, our analysis will focus on showing that has a logarithmic diameter.To do so, we will perform an induction over the sequence of graphs G := 1 , . . ., .Our main insight is that -given the communication graph is benign -we can use short random walks of constant length to iteratively increase the graph's conductance until we reach a graph of low diameter.In particular, we show that the graph's conductance is strictly increasing by a factor .10.Let and +1 be the graphs created in iteration and + 1 respectively and assume that is benign with a minimum cut of at least Λ ≥ 640.Then, it holds In particular, for any ℓ ≥ 2 • 640 2 , it holds Intuitively, this makes sense as the conductance is a graph property that measures how well-connected a graph is and -since the random walks monotonically converge to the uniform distribution -the newly sampled edges can only increase the graph's connectivity.
Our first observation is the fact that random walks of length ℓ are distributed according to 1-step walks in ℓ .
In particular, if we consider a subset ⊂ and pick a node ∈ uniformly at random, then Φ ℓ ( ) denotes the probability that a random walk started at ends outside of the subset after ℓ steps.In this case, creates an edge to some node in \ .Since we ensure that the total number of edges in a set stays constant, creating such an outgoing edge increases the set's conductance in expectation.Thus, we can show the following lemma: L 2.11.Let Φ +1 ( ) be the conductance of set ⊂ in +1 .Given that each node starts Δ 8 tokens, which all create an edge, it holds: Before we can prove the lemma, we need some auxiliary lemmas and definitions.For , ∈ let ℓ ( , ) be indicator for the event that an ℓ-step random walk in which started in ends in .Analogously, let 1 ( , ℓ ) be the probability that a 1-step random walk in ℓ which started in ends in .If we consider a fixed node that is clear from the context, we may drop the subscript and write 1 ( , ℓ ) instead.Further, let ℓ ( , ) is the exact number of walks of length ℓ between and in .
L 2.12.The probability to move from to in ℓ is given by:

P
. The statement can be proved via an induction over ℓ, the length of the walk.
(IB) For the base case we need to show that 1-step random walk in is equivalent to picking an outgoing edge in 1 := uniformly at random.This follows trivially from the very definition of a random walk.
(IS) Now suppose that performing an (ℓ − 1)-step random walk in is equivalent to performing a 1-step walk in ℓ−1 .Consider a node ∈ and let denote its neighbors in and itself.By the law of total probability, it holds: Using the inductions hypothesis we we can substitute Pr ℓ−1 ( , ) = 1 for Pr 1 ( , ℓ−1 ) = 1 and get: Recall that is a multigraph and there can be more than one edge between each and .Thus, let now ( , ) denote the number of edges between and for every ∈ .Since we defined that ∈ , the value ( , ) counts 's self-loops.Since is Δ-regular, the probability that a random walk at node moves to is exactly ( , ) Δ .Back in the formula, we get: Finally, note that ∈ ℓ−1 ( , ) • ( , ) counts all paths of length exactly ℓ from to in .This follows because each path := ( 1 , . . ., ℓ ) from to can be decomposed into a path ′ := ( 1 , . . ., ℓ−1 ) of length ℓ − 1 to some neighbor of (or itself) and the final edge (or self-loop) ℓ .Thus, it follows that: This was to be shown.
Next, we consider the random walks that start in a given set and end outside of it (i.e., the random walks used to create connections outside of ).Given our definition from above, we can show that the number of walks that end outside of depends on the size of , the degree Δ, and Φ ℓ :

(E C
).Let be a Δ-regular graph and ⊂ be a any subset of nodes with | | := ≤ 2 and suppose each node in starts Δ 8 random walks.Let Y count the ℓ-step random walks that start at some node in ∈ and end at some node ∈ \ .Then it holds: First, we observe that we can Y as the sum of binary random variables for each walk.For each ∈ let 1 , . . ., be indicator variables that denote if a token started by ended in := \ after ℓ steps.Given this definition, we see that Recall that an ℓ-step random walk in corresponds to a 1-step random walk in ℓ .This means for each of its Δ 8 tokens node picks one of its outgoing edges in ℓ uniformly at random and sends the token along this edge (which corresponds to an ℓ-step walk).For ease of notation, let O be the number of edges of node ∈ in ℓ where the other endpoint is not in .Now consider the ℎ random walk started at and observe .Note that it holds: Here, the denominator Δ ℓ comes from the fact that ℓ is Δ ℓ -regular.
Let O be the number of all outgoing edges from the whole set in ℓ .It holds that O := ∈ O .Recall that the definition of Φ ℓ is the ratio of edges leading out of and all edges with at least one endpoint in .Given that ℓ is a Δ ℓ -regular graph, a simple calculation yields: This proves the lemma.
Given this lemma, we can now prove the expected conductance.As we only observe regular graphs and w.h.p. all tokens create an edge, the expected conductance of a set simply follows from dividing Y by Δ , which immediately yields the lemma.Therefore, we get: L 2.14.Given that each node starts Δ 8 tokens, which all create an edge, it holds: Recall each nodes starts Δ 8 tokens and we assume all tokens create an edge.By observing the algorithm, we note that by construction the degree can never be higher than Δ.Recall that every node creates its edges for +1 based on the tokens it received.If any node receives fewer than Δ tokens, it creates self-loops to reach a degree of Δ.If it receives more, excess edges are dropped arbitrarily to ensure a degree of at most Δ.Thus, each set maintains Δ| | edges in total as each node will always has Δ edges irregardless of how many tokens is received.Given this fact and using Lemma 2.13 above we get Therefore, a lower bound on Φ ℓ gives us a lower bound on the expected conductance of the newly sampled graph.
However, the standard Cheeger inequality (see, e.g., [53] for an overview) that is most commonly used to bound a graph's conductance with the help of the graph's eigenvalues does not help us in deriving a meaningful lower bound for Φ ℓ .In particular, it only states that Φ ℓ = Θ(ℓΦ 2 ).Thus, it only provides a useful bound if ℓ = Ω(Φ −1 ), which is too big for our purposes, as Ω(Φ −1 ) is only constant if Φ is already constant.More recent Cheeger inequalities shown in [41] relate the conductance of smaller subsets to higher eigenvalues of the random walk matrix.At first glance, this seems to be helpful, as one could use these to show that at least the small sets start to be more densely connected and then, inductively, continue the argument.Still, even with this approach, constant length walks are out of the question as the new Cheeger inequalities introduce an additional tight (log ) factor in the approximation for these small sets.Thus, the random walks would need to be of length Ω(log ), which is still too much to achieve our bounds.Instead, we use the following result by Kwok and Lau [38], which states that Φ ℓ improves even for constant values of ℓ.It holds that: ).Let = ( , ) be any connected Δ-regular lazy graph with conductance Φ and let ℓ be its ℓ-walk graph.For a set ⊂ define Φ ℓ ( ) as the conductance of in ℓ .
Then, it holds: Given this bound, we can show that benign graphs indeed increase their (expected) conductance from iteration to iteration.In the following, we provide a sketch of the proof in [38].Before we go into the details, we need another batch of definitions from the study of random walks and Markov chains.Let := ( , ) be s Δ-regular, lazy graph and let ∈ R × the stochastic random walk matrix of .Each entry ( , ) in the matrix has the value ( , ) Δ where ( , ) denotes the number of edges between and (or self-loops if = ).Likewise ℓ is the random walk matrix of ℓ where each entry has value ℓ ( , ) Δ ℓ .Note that both and ℓ are doubly-stochastic, which both their rows and their columns sum up 1.For these types of weighted matrices, Kwok and Lau define the expansion ( ) of a subset ⊂ as follows: For regular graph (and only those), this value is equal to the conductance Φ ( ) of , which we observed before.This claim can be verified by the following elementary calculation: Therefore, the claim that Kwok and Lau make for the expansion also hold for the conductance of regular graphs 12 .The proof in [38] is based on the function (ℓ) (| |) introduced by Lovász and Simonovits [43].Consider a set ⊂ , then Lovasz and Simonovits define the following curve that bounds the distribution of random walk probabilities for the nodes of .
Here, the vector is the so-called characteristic vector of with = 1 | | for each ∈ and 0 otherwise.Further, the term ( ℓ ) denotes the ℎ value of the vector ℓ .Lovász and Simonovits used this curve to analyze the mixing time of Markov chains.Kwok and Lau now noticed that it also holds that: L 2.16 (L 6 [38]).It holds: Based on this observation, they deduce that a bound for 1 − (ℓ) ( ) doubles as a bound for Φ ℓ .In particular, they can show the following bounds for (ℓ) (| |): L 2.17 (L 7 [38]).It holds Plugging these two insights together, we get The last inequality follows from the fact that √ ℓΦ is at most 1 2 and a standard approximation.This is the main result of [38].We refer the interested reader to Lemma 7 of [38] for the full proof with all necessary details.Their main technical argument is based on the following recusive relation between (ℓ+1) and (ℓ) , which was (in part) already shown in [43]: L 2.18 (L 1.4 [43]).It holds Here, we use the abbreviation | | := max{| |, − | |}.They use this to create a recursive formula that can be simplified to the given result using careful calculations.However, this fact alone is enough for our proof as the lower bound is too loose for subsets that already have a good conductance.Instead we require that Φ ℓ ( ) is at least as big as Φ ( ).Note that this is not necessarily the case for all graphs.Instead, we must use the fact that our graphs are lazy.We show this in the following lemma: L 2.19.Let := ( , ) be any connected Δ-regular lazy graph with conductance Φ and let ℓ be its ℓ-walk graph.For a set ⊂ define Φ ℓ ( ) the conductance of in ℓ .Then, it holds: This fact was already remarked in [43] based on an alternative formulation.However, given that (ℓ) is concave, it holds that for all values , ≥ 0 with ≤ that And thus, together with Lemma 2.18, we get: Here, we chose = 2Φ and = 0 and applied Equation 25.This proves the first claim.
Second, we claim that (1)) (| |) is equal to 1 − Φ ( ) as long as the graph we observe is lazy.
For this claim (which was not explicitly shown in [38], but implied in [43]) we observe and find the assignment of the 's that maximizes the sum.Lovasz and Simonovits already remarked that it is maximized by setting = 1 for all ∈ .However, since there is no explicit lemma or proof to point to in [43], we prove it here.First, we show that all entries ( ) for nodes ∈ are least 1 2| | and all entries ( ) ′ for nodes ′ ∉ are at most 1 2| | .We begin with the nodes in .Given that is Δ-regular and lazy, we have for all ∈ that Here, = 1 | | follows because ∈ per definition.The inequality ( , ) ≥ 1 2 follows from the fact that is lazy and each node has a self-loop with probability 1  2 .As a result, the entry ( ) for ∈ has at least a value of 1 2| | , even if it has no neighbors in .On the other hand, we have for all nodes ′ ∉ that This follows from excluding all entries with ∉ .Note that for these values it holds = 0. Further, Since is Δ-regular and lazy, each node ′ ∉ has at most Δ 2 edges to nodes in .
Thus, the corresponding value ( ) of any ∈ is at least as big as value ( ) ′ of ′ ∉ .By a simple greedy argument, we now see that =1 ( ℓ ) is maximized by picking = 1 for all nodes in : To illustrate this, suppose that there is a choice of the 's such that =1 ( ) is maximized and it holds < 1 for some ∈ .Since no can be bigger than 1 and the =1 = | | there must be a ′ ∉ with ′ > 0. Since ( ) ≥ ( ) ′ decreasing ′ and increasing does not decrease the sum.Thus, choosing = 1 for all ∈ must maximize the term =1 ( ) .Thiy yields: Here, the value O S denotes the edges leaving .Given that the graph is Δ-regular, the term Δ| | − O S counts all edges in .This was to be shown.
If we combine our two claims, the lemma follows.
Thus, as long as is regular and lazy, we have a suitable lower bound for Φ ℓ .In fact, we can show the following: L 2.20.Let ⊂ be set of nodes with outgoing edges, then it holds: This follows from the Chernoff bound and the fact that the random walks are quasi independent 13 .However, this fact alone is not enough to finalize the proof of Lemma 2.10.Recall that we need to show that every subset has a conductance of ( √ ℓΦ ) in +1 in order to prove that Φ +1 = Ω( √ ℓΦ ).Since there are exponentially many subsets, a bound in the magnitude of ( − ) is not sufficient on its own.Luckily, by a celebrated result of Karger, the number of subsets with Λ outgoing edges can be bounded by ( 2 ) [35], i.e, it holds T 2.21 (T 3.3 [35], ).Let be an undirected, unweighted graph and let Λ > 1 be the size of a minimum cut in .For an even parameter ≥ 2 the number of cuts with at most Λ edges is bounded by 2 2 .
Given that a set has Λ outgoing edges, the value of Φ +1 ( ) is concentrated around its expectation with probability −Ω ( Λ) .Thus, for a big enough Λ, a bound of −Ω ( Λ) is enough to show all sets increase their conductance.
With this insight, we can prove Lemma 2.10: For a set ⊂ we define B to be the event that Φ +1 ( ) is smaller than √ ℓΦ .In this case, we say that has bad conductance.Obviously, if no set has bad conductance, then the resulting conductance of +1 must also be at least 1 640 √ ℓΦ and lemma follows.We let B = ⊂ B be the event that there exists a set with bad conductance, i.e, there is any B that is true.To prove the lemma, we show that B does not happen w.h.p.Therefore, we let S ∈ P ( ) be the set of all sets that have a cut of size ∈ [ Λ, 2 Λ).Further, we let Λ ≥ 6400 log for a constant .Note that can be chosen as high as we want by constructing a sufficiently large minimum cut in 0 by creating copies of each initial edge.Using all these definitions we can show that the following holds: Now we can apply Theorem 2.21 and see that By using the Lemma 2.20, we get: Thus, Lemma 2.10 follows for any constant hidden in Λ = Ω(log ).

Ensuring That Each is Benign
We will show that indeed each is a Δ-regular, lazy graph with a Λ-sized cut.Note that the last property also ensures that is connected.While the first property follows directly from the algorithm, the latter two require some closer observations.
Ensuring that is Δ-regular.By observing the algorithm, we note that by construction the degree can never be higher than Δ.Recall that every node creates its edges for +1 based on the tokens it received.If any node receives fewer than Δ tokens, it creates self-loops to reach a degree of Δ.If it receives more, excess edges are dropped arbitrarily to ensure a degree of at most Δ.
Ensuring that is lazy.For this, recall that a node connects to endpoints of all its Δ 8 tokens and additionally to the origins of all (but at most 3Δ  8 ) tokens it received.Thus, in the worst case, it creates Δ 8 + 3Δ 8 = Δ 2 outgoing edges.Thus, it creates at least Δ 2 -and therefore enough -self-loops.
Ensuring that has Λ-sized minimum cut.The third property, the Λ-sized minimum cut, is perhaps the most difficult to show.However, at a closer look, the proof is almost identical to the proof of Lemma 2.10.In particular, we show that all cuts that are close to the minimum cut will (in expectation and w.h.p.) increase in their size in each iteration, but never fall below Λ.The idea behind the proof uses the fact that [38] actually gives us a stronger bound on the expected growth of the subset than just the conductance.In fact, for each subset , it suffices to observe subsets of similar size to get a lower bound for Φ ℓ ( ).Before we go into more details, we recall the notion of small-set conductance, which is a natural generalization of conductance: be any subset of .The small-set conductance Φ of is then defined as: Given this definition, we note that there is also a (weaker) bound on the small set conductance of ℓ in [38].It holds: [38]).Let := ( , ) be any connected Δ-regular lazy graph with small-set conductance Φ for any ∈ (0, 1)and let ℓ be its th power.For a set ⊂ with | | ≤ 2 define Φ ℓ ( ) the conductance of in ℓ .Then, it holds: Therefore, we see that that sets ⊂ of size • 2 whose conductance Φ( ) is close to Φ have many tokens that end outside of .
One can easily see that there is a simple relation between the small-set conductance and the minimum cut of a graph.Since the conductance of a set is the number of its outgoing edges divided by its size, the minimum cut gives us a simple lower bound all small set conductance for all values of .It holds: L 2.24.Let := ( , ) have minimum cut of Λ, then the small-set conductance Φ of is at least Λ Δ .
P .Suppose there is set ⊂ and | | ≤ Δ with conductance smaller than Λ Δ .Then, either the number of outgoing edges must be smaller, or size of the set must be bigger.However, since the number of outgoing edges of is at least Λ, it must hold that | | > Δ .This is a contradiction since we assumed that | | ≤ Δ .This is simple observation this enough to show that all sets that have close to Λ outgoing connections slightly increase the number for their outgoing connections for a big enough ℓ.In particular, it holds: L 2.25.Suppose that ℓ > 2 • 640 2 .Then, for any set with outgoing edges, it holds: P .The proof follows the same basic structure as before.Recall that for each set , the number of outgoing edges in +1 is determined by a series (quasi-)independent binary variables.Thus, by the Chernoff Bound, it holds that Now, we claim that it holds E[Y] ≥ max{2Λ, 4 } and choosing ≥ 1 /2, we get Therefore, it remains to show that our claim that E[Y] ≥ max{2Λ, 4 } holds true and we are done.Now, we distinguish between two cases: Case 1: O ≥ 8Λ By Lemma 2.13 we have for all set with outgoing edges that Thus, for > 8Λ we have Y S ≥ 4 and the lemma follows.Case 2: O < 8Λ In the following, we consider only sets ⊂ with fewer than 8Λ outgoing edges.Consider a set of size | | = = .By Lemma 2.24 it holds that Φ 2 ≥ Λ 2Δ .Thus, again using Lemma 2.13, it holds The factor of 2 that appears in the denominator in the second line results from Lemma 2.23.Since we observe a set of size , we must consider Φ 2 .Since we always consider sets of size at most 2 , this is always well-defined.
Since the number of edges in stays constant, we can again conclude By choosing a sufficiently large ℓ > 2 • 640 2 , we get E[Y ] > 2Λ as desired.
We can round up the proof by the same trick as before.Again, we must show that every cut has a value of at Λ and use Karger's bound together with Lemma 2.25 to show that no cut has a worse value, w.h.p.L 2.26.If is begnin, the minimum cut of +1 is at least Λ w.h.p.

P .
For a set ⊂ we define C to be the event that Y is smaller than Λ.In this case, we say that has bad cut.Obviously, if no set has bad cut, the minimum cut of +1 is Λ We let C = ⊂ C be the event that there exists a set with bad cut, i.e, there is any C that is true.To prove the lemma, we show that C does not happen w.h.p.As before, we let S ∈ P ( ) be the set of all sets that have a cut of size ∈ [ Λ, 2 Λ).Further, we let Λ ≥ log for a constant , i.e, we denote the constant hidden in the -Notation as .Note that can be chosen as high as we want by constructing a sufficiently large minimum cut in 0 by creating copies of each initial edge.Using all these definitions we can show that the following holds: Thus, the lemma follows for a sufficently large constant hidden in Λ = Ω(log ).

Finalizing the Proof
To round up the analysis, we now only need to show that after (log ) iterations, the graph has constant conductance.
Based on our insights, we can conclude that if Δ, ℓ and Λ are big enough, then, w.h.p., if is benign, then +1 is benign and has at least twice its conductance (if it was not already constant).In particular, the following three events hold true w.h.p.
(1) For Δ > 8 log( ) it holds with probability 1 − ℓ that all node receive less then 3Δ 8 token each round.We call this event E 1 .
Note that given E 1 , the algorithm can modeled as the experiment described above.By the union bound, the events E 1 , E 2 and E 3 hold together w.h.p.
Given that after every iteration, the graph's conductance increases by a factor ( √ ℓ) w.h.p, a simple union bound tells us, as long as we consider ( ) iterations, the conductance increases in every iteration w.h.p.Thus, after log Φ log ℓ = (log ) iterations, the most recent graph must have constant conductance, w.h.p.Therefore, since each iteration lasts only ℓ = (1) rounds, after (log ) rounds, the graph has a constant conductance and logarithmic diameter.This concludes the analysis.

APPLICATIONS IN THE HYBRID MODEL
We now present some applications of our algorithm in the hybrid model.Note that in this section, we will use the fact that a node can communicate with all of its neighbors in via small messages, i.e, we assume the CONGEST model for .Recall that this is a necessary assumption to achieve a runtime that is independent of the graph 's degree (or arboricity).However, the global capacity, which bounds the total number of messages a node can send and receive via global edges, is bounded by (1).Before we approach the different graph problems in the hybrid model, we first give an adaption of C E to this model that circumvents some problems introduced by the potentially high node degrees.This algorithm will be the basis of all algorithms in the remainder of this section.

Adapting C E to the Hybrid Model
In Section 2 we used a very simple approach to construct the initial benign graph on which C E is executed: copy each initial edge (log ) times.While this technique works for (1)-regular graphs, extending it to more general input graphs introduces some difficulties.In particular, for graphs of degree = (1) the benign graph's degree becomes Δ = (log ).Although the algorithm itself could handle this case if we increased the allowed communication capacity to (Δ) 14 , the resulting overlay network would have superlogarithmic degree, violating the definition of a well-formed tree.Additionally, this prevents us from using our main algorithm as a black box for the applications in the following section.In this section, we approach this problem by presenting a variant of Theorem 1.1 for the hybrid model that allows an initial degree of = (log ).In particular, we will use slightly longer random walks (of logarithmic length) and more communication per node.However, since each node only communicates a polylogarithmic number of messages over global edges, the algorithm directly works in the models of [29,30].The main contribution of this section is the following adapted version of Theorem 1.1: T 3.1.Let = ( , ) be a weakly connected directed graph with degree = (log ) and nodes.There is a randomized algorithm that constructs a well-formed tree = ( , ) in (log + log log )) rounds, w.h.p., in the hybrid model.The algorithm requires global capacity (log 3 ).
At the core of our adapted algorithm lies the following technical theorem, which was independently shown by [18], [10], and [39].It assures us that we can simulate random walks of length ℓ in time (log ℓ) in overlay networks, given that we have sufficient communication bandwidth.

L
3.2 (R S , [10,18,39]).Let be a -regular graph.If each node can send and receive ( ℓ) messages of size (log ) in each round, then each node can sample = Ω(log ) random walks of length ℓ in time (log ℓ), w.h.p.
The main idea behind the algorithm is to stitch short random walks to longer ones while maintaining their independence.For the first 2 rounds, all random walk token are forwarded as usual, i.e., for each token an incident edge is picked uniformly at random.Then, after these 2 rounds, we stitch the random walks together to quickly double their length (at the cost of reducing their number by half).In particular, in each round, each node selects half of the random walk tokens it received and marks them as red.All other token are marked as blue.If the node has an odd number of token, the remaining token is simply dropped.For each red token, every node picks one of the remaining blue tokens uniformly at random and without replacement.Then, it sends the red token to the blue token's origin.Afterwards, the blue token is discarded to maintain the independence of the red walks.One can easily verify the following three facts: (1) After log ℓ rounds, all surviving tokens are distributed according to random walks of length ℓ.This follows because combining a red and blue token effectively doubles the length of the walk.Also, since each each token has an equal probability of becoming red, there is no significant bias in the distribution.
(2) All surviving random walks are independent.This follows because we never reuse a blue token and thus, the surviving walks are uncorrelated.
(3) If Δ = (log ) and each node starts (Δℓ) tokens, then (Δ) of them survive, w.h.p.This follows because every token that never becomes blue survives.Since a token becomes blue with probability 1 /2 in each round and there are log ℓ rounds, in expectation ( Δℓ ℓ ) = (Δ) survive.The rest follows from Chernoff bounds 15 and sufficiently large Δ.
For a more detailed analysis, we refer to [10,18,39], where all of these claims are proved in detail.
We now adapt three implementation details of C E .First, instead of initially copying each edge (Λ) times, each node only adds self-loops until it reaches degree Δ > 2 .Second, in each evolution, we use the rapid sampling technique instead of normal random walks.Next, we need to consider that -if we use rapid sampling -a node cannot control how many of its tokens succeed.Therefore, all tokens that survived for ℓ rounds are sent back to their origin together with the identifier of their endpoint.Then, each node picks Δ 8 of these tokens to create edges and answers back to the respective endpoints.Last, we choose ℓ = (Λ 2 ).We will show that a) this causes the minimum cut and the conductance to grow by (Λ) in expectation and w.h.p., and b) the runtime is (log + log log ) w.h.p.
For the first statement, we observe that a large portion of the analysis in Section 2.3 remains valid for the adapted algorithm.Note that the creation of edges is changed as we added an extra step to determine the tokens that survived.This slightly changes the random experiment that bounds the number of outgoing edges of each set.Since Lemma 3.2 guarantees us that, w.h.p., enough tokens survive and their distribution is unchanged, the expected value in Lemma 2.13 stays the same.Further, the Chernoff bound still applies because the random walks stay independent.Thus, given that we have big enough minimum cut, the algorithm works as before.Now observe our analysis of the minium cut, especially Lemma 2.25, we can easily see that the following holds: If we choose ℓ = (Λ 2 ), then Lemma 2.25 holds regardless of the initial cut's size for a large enough ℓ for the Chernoff Bound to kick in.Thus, after the first evolution, the minimum cut is of size Λ, w.h.p. and the increase in conductance is Θ(Λ) as well.Therefore, the algorithm works, w.h.p. without copying each edge (Δ) times.
Finally, we must observe how these longer walks affect the runtime.Since Λ 2 = (log 2 ), we can simulate the random walks in (log log ) rounds instead of using normal walks.This requires a global capacity of (log 3 ) by Lemma 3.2.Thus, a single evolution takes (log log ) rounds instead of (1).However, due to the longer walks, also have an increase of Θ(log ) in the conductance.This follows directly from Lemma 2.10.Now observe that the minimal conductance of any graph with nodes and degree Δ is 1  Δ Therefore, we only need ′ := ( log log log ) evolutions to obtain an expander and the overall runtime is (log + log log ).

Connected Components
In this section, we show how the algorithm can be used to find connected components in an arbitrary graph .In particular, for each connected component of , want to establish a well-formed tree (overlay edges) that contains all nodes of .The main result of this section is the following theorem: 15 Note that Chernoff also applies to drawing without replacement.consider the case that the node that maximizes ( ) is within distance of (log ) to .Then, our adaptation does not consider this node because we terminate the broadcast before it can reach (whereas it may have reached in the original algorithm).We compensate this by letting nodes of low degree add all of their edges.But since we are only interested in the nodes' outdegrees and not the other properties of the spanner, i.e., the number of edges, this is fine for our case.
In the following, we will show that the resulting graph ( ) is directed and has an outdegree of (log ) in expectation and with high probability.We begin with the definition of an active node.Intuitively, an active node ∈ is a node that is reached by a sufficiently large within 2 log rounds.Definition 3.4 (Active Node).Given the non-discarded random values 1 , . . ., ′ , we call a node ∈ active, if it holds ( ) ≥ 0. All others are inactive.
Since for any node ∈ that did not discard its value we have ≥ 0, and ( ) = − ( , ) ≥ 0 as ( , ) = 0, such a node must be active.By the same argument, all nodes ∈ that discarded their value only become active, if they receive a value such that − ( , ) ≥ 0. As the following lemma implies, this holds for all nodes whose degree is large enough.L 3.5.Let ∈ be an inactive node, then ( ) ≤ log , w.h.p., where ( ) is the degree of in .

P
. Suppose for contradiction that there is any ∈ with ( ) > log that is inactive.
Let 1 , . . ., ( ) be independent random variables sampled from the exponential distribution with parameter 1 2 that are drawn by 's neighbors.To show the lemma, we will show that there is at least one with > 1.We will call such an good.As ( , ) = 1 this implies that − ( , ) is non-negative, which -by definition -is sufficient to show that is active.The probability for the event that a random value is larger than 1 is Thus, the expected number of good values is larger than log .Since the values are drawn independently, a simple application of the Chernoff bound yields that there are at least 2 log good values with high probability.
Note that not all good values are sent to as they may be discarded.Thus, we need to rule out the discarded values.
We call any ≥ 2 log a big value.Then, w.h.p., there are at most 8 log big values.The proof is straightforward as the probability to draw a big value is Since there are only nodes in each component, we have that ( ) ≤ , which implies that the expected number of big values (in any neighborhood) is (1).Since the values are drawn independently at random, a simple application of the Chernoff bound yields that there are no more than 8 log big values with probability 1 − ( ′ ).Here, ′ is a constant that depends on the size .
Combining these two statement yields that there are more good than big values, w.h.p., for a large enough > 16 .
Thus, Ω(1) good values are not discarded.Finally, by a union bound, any node with ( ) > log receives a positive value and is therefore active.
One immediate implication for an active node is given in the following statement.L 3.6.For any active node let ∈ be the node maximizing ( ) := − ( , ).We have that ( , ) < 2 log + 1.
Step 2: Transform ( ) into a bounded degree graph .Now we will construct a bounded degree graph from ( ).
Note that -in contrast to ( ) -is not a subgraph of and contains additional edges.Although ( ) has few edges in total, there can still be nodes of high degree because there may be nodes with high indegree.Our goal is that nodes of high indegree redirect their incoming edges to other nodes in order to balance the degrees.This technique is conceptually similar to the construction of a child-sibling tree as in [4] and [29].
(1) In the first step, all nodes learn all of their incoming connections in ( ).For this, every node ∈ with an edge = ( , ) in ( ) sends a message containing its identifier to .Since must also have existed in and each identifier is of size (log ), this step can be executed in exactly one round in the CONGEST model.
(2) Next, we delegate all incoming edges away and create a list of all incoming nodes.For the construction, consider a node ∈ and let ( ) := 1 , . . ., be all nodes with ( , ) ∈ ( ), i.e, the incoming edges of .W.l.o.g., assume that 1 , . . ., are ordered by increasing identifier.Then, for each > 1, sends the identifier of to −1 and vice versa.This results in the following set of edges: One can easily verify that each node has at most one incoming edge left (i.e., the edge from 1 to ) and received at most two edges for each outgoing edge (i.e., the edges to −1 and −1 ).Thus, the resulting graph = ( , ) has a degree of (log ) since each node's outdegree in ( ) is within (log ) w.h.p. by Lemma 3.10.
Note that both these steps take (log ) communication rounds.The runtime of the first phase only depends on the broadcast of the 's and thus takes (log ) steps.In the second step, all nodes only exchange two messages with their neighbors in ( ), so its runtime is (1).Since all nodes know the same estimate of (log ), the phases can be synchronized via round counters.

Spanning Trees
We will now show how the algorithm of Theorem 1.2 can be used to construct a spanning tree of the (undirected version of the) initial graph .For simplicity, we assume that this graph is connected; our algorithm can easily be extended to also compute spanning forests of unconnected graphs by running it in each connected component.We show the following theorem: Theorem 1.3.Let = ( , ) be a weakly connected directed graph.There is a randomized algorithm that constructs a spanning tree of (the undirected version of) in (log ) rounds, w.h.p., in the hybrid model.The algorithm requires global capacity (log 5 ), w.h.p.
Note that Theorem 1.2 constructs a graph ′ that results from ′ = (log /log log ) evolutions of the graph 0 of Lemma 3.3 and that has diameter (log ), and degree (log 2 ), w.h.p.First, we construct a spanning tree ′ of ′ by performing a BFS from the node with highest identifier.Our idea is to iteratively replace all the edges of ′ by edges of ′ −1 , replace these edges by edges of ′ −2 , and so on, until we reach a graph that contains only edges of 0 .
We then first break all cycles of this graph using pointer jumping, and finally infer a spanning tree of by reverting the delegation of edges in Phase 2 of the algorithm of Section 3.2.
More precisely, our algorithm works as follows.First, the nodes perform a depth-first traversal of ′ using the Euler tour technique.Specifically, we execute the algorithm of [20,Lemma 4]. 17As a by-product, the nodes learn the path ′ that corresponds to a depth-first traversal of ′ .This path covers all nodes and, since ′ is a well-formed tree, contains each node at most (log 2 ) times.Next, we want to replace all edges of ′ by edges of 0 in an iterative fashion.
To be able to do that, the two endpoints of every random edge created throughout the execution of our main algorithm need to know the edges the corresponding token traversed (the edges that make up ).Note that the token traverses ℓ = (log 2 ) nodes.To annotate each token with the edges it traverses, we need to increase the global capacity of the algorithm of 1.2 to (log 5 ), since by Lemma 3.2 each node needs to send and receive (log 3 ) messages, each of which consisting of (log 2 ) "submessages".Therefore, the endpoints of each edge of ′ can inform the endpoints of all edges of ′ −1 that make up , which creates a path ′ −1 that only contains edges of ′ −1 .In turn, these endpoints of all edges of ′ −1 can inform all nodes that make up the edge to obtain ′ −2 , and so on, until we obtain a path 0 .L 3.11.0 contains all nodes of and can be computed in time (log ).Furthermore, each node is contained at most (log 4 ) times, w.h.p.

P .
Since ′ contains all nodes of , and we only repeatedly replace edges by paths, 0 also contains all nodes.
Furthermore, each node is contained in ′ at most (log ) times, w.h.p, since is a well-formed tree.Note that for Δ = (log ) Lemma 2.9 implies that in each round of each evolution, each node is only traversed by (log ) tokens, w.h.p.Further, since ℓ = (log 2 ), during each evolution of the algorithm every node is traversed by a total of (log 3 ) tokens.Therefore, when replacing an edge of by a path in −1 , each node is only added (log 3 ) times, w.h.p.Since we have ′ = (log ), each node is contained at most (log 4 ) times in 0 , w.h.p.
To transform 0 = ( 1 , . . ., ) into a spanning tree 0 of 0 , each node ∈ selects the edge over which it is reached first in , i.e., = { −1 , } such that = and = argmin ∈{1,..., } = .These edges can easily be found using [20, Theorem 1], which performs pointer jumping and uses the prefix sum technique on .Note that since each node is contained in at most (log 4 ) times by Lemma 3.11, the algorithm can be performed with global capacity (log 4 ) in time (log ).The selected edges form a so-called loop erased path of 0 that covers all nodes, therefore the set { | ∈ } is a spanning tree 0 of 0 .
However, 0 may not be a spanning tree of .Recall that an edge { , } in 0 may not exist in (i.e., if it resulted from a redirection of an edge { , } in 0 in Phase II of Section 3.2, where and were incoming nodes of ).However, after computing the edges over which each node is reached first in , we can simply replace each edge { , } that does not exist in by the two edges { , } and { , } that exist in using global communication.Thereby, a node may learn that is is actually reached earlier in , and we "repair" the loop erased path to obtain a spanning tree of .We conclude Theorem 1.3.

Biconnected Components
In this section, we present an adaptation of Tarjan and Vishkin's biconnectivity algorithm [55] to compute the biconnected components of in time (log ), proving the following theorem.
Theorem 1.4.Let = ( , ) be a weakly connected directed graph.There is a randomized algorithm that computes the biconnected components of (the undirected version of) in (log ) rounds, w.h.p., in the hybrid model.Furthermore, the algorithm computes whether is biconnected, and, if not, determines its cut nodes and bridge edges.The algorithm requires global capacity (log 5 ), w.h.p.
The algorithm constructs a helper graph ′ = ( , ′ ) with the edges of as nodes and with an edge set ′ chosen such that any two edges of are connected in ′ if and only if they lie on a cycle in .Therefore, the nodes of each connected component of ′ are edges of the same biconnected component in .If there is only one component in ′ , then is biconnected.
On a high level, the algorithm can be divided into five steps.In Step 1, we construct a rooted spanning tree of and enumerate the nodes from 1 to , assigning each node a label ( ), according to the order in which they are In the remainder of this section, we describe how the five steps can be implemented in the hybrid model in time (log ) using Theorem 1.1 together with the results of [7] and [20].The correctness of Theorem 1.4 then follows directly from [55, Theorem 1].
Step 1: Construct .is computed using Theorem 1.3 in time (log ), w.h.p.The tree can be rooted using the algorithm of [20, Lemma 4], which arranges the nodes of as an overlay ring that corresponds to a depth-first traversal of and performs pointer jumping on that ring.As a by-product, we can easily enumerate the nodes in the order in which they are visited in the depth-first traversal, whereby each node obtains its label.
Step 2: Compute Subtree Aggregates.To retrieve the value ( ) for each node ∈ , the nodes perform the algorithm of [20,Lemma 6] on : If each node stores a value , then the algorithm computes the sum of all values that lie in each of 's adjacent subtrees (i.e., the components into which decomposes if gets removed) deterministically in time (log ); we obtain ( ) by setting = 1 for each ∈ .However, to compute ℎ ℎ( ) and ( ), for each node ∈ , the nodes need to compute maxima and minima.Therefore, we need the following lemma, which is a generalization of [20, Lemma 6]. 18 3.12.Let = ( , ) be a tree and assume that each node ∈ stores some value .Let be a distributive aggregate function.The goal of each node is to compute the value ({ | ∈ }) for each of its neighbors in , where is the connected component of the subtree ′ of induced by \ { } that contains .The problem can be solved in time (log ), w.h.p.

P .
As described before, we enumerate the nodes of from 1 to by assigning them a label ( ) according to the order in which they are visited in a depth-first traversal of (starting at the node with smallest identifier).
Furthermore, we construct a list as an overlay in ascending order of their label, and root towards .This can be done in time (log ) using techniques of [20].Afterwards, the nodes perform pointer jumping on to create shortcut edges for (log ) rounds, which decreases the diameter of to (log ).Additionally, the endpoints , of a shortcut edge { , } ∈ learn the weight ({ , }) := ({ | ∈ , ( ) ≤ ( ) ≤ ( )}).Now consider some node ∈ .First, we show how can compute ({ | ∈ ( )}), i.e., the aggregate of all values in 's subtree.Note that this value is exactly ({ | ∈ , ( ) ≤ ( ) ≤ ( )}), where is the node for which ( ) = ( ) + | ( )| − 1 (i.e., the node in 's subtree with largest label).Note that this value is the aggregate of all values on the segment between and on .To obtain this value, only needs to learn the weights of at most (log ) shortcut edges on that segment.
However, since many nodes may want to contact the same node, we cannot send request messages directly, even if each node knew all node identifiers.Instead, we make use of techniques of [7] to construct multicast trees towards each node 19 .Since each node needs to contact (log ) nodes, it participates in the construction of (log ) multicast trees.Further, each node ∈ is the root of at most (log ) multicast trees (one for each of its adjacent shortcut edges).When multicasts the weight of a shortcut edge in the respective multicast tree, all nodes that participated in the construction of that tree will be informed.Plugging the parameters = ( log ) (which is the total number of requests) and = ˆ = (log ) (which is the number of weights each node wants to learn) into [7,Theorem 2.3] and [7, Theorem 2.4], we get that each node learns all weights in time (log ), w.h.p. 20After having learned the weights of all edges on , can easily compute ({ | ∈ ( )}).By sending this value to its parent in (over a local edge), each node learns the aggregate of the subtree of each of its children.It remains to compute ({ | \ ( )}), i.e. the aggregate of all non-descendants of .Note that since the descendants of form a connected segment from to in , these non-descendants form exactly two segments on : one from to (excluding ), and one from to the last node of (excluding ).Using the same strategy as before, can compute the aggregate of all these values by learning the weight of (log ) shortcut edges.
Step 3: Construct ′′ .Recall that ′′ is the subgraph of ′ induced only by the nodes that correspond to edges of .
In order to simulate ′′ , we let each node of act on behalf of the node of ′′ that corresponds to 's parent edge.
That is, when simulating an algorithm on ′′ , is responsible for all messages the node corresponding to 's parent edge is supposed to communicate.We now need to connect all nodes corresponding to edges that are on a common simple cycle in .Tarjan and Vishkin showed that it suffices to consider the simple cycles consisting of a nontree edge and the unique shortest path between its adjacent nodes [55].To do this, they propose the following rules: (1) If ( , ) and ( , ) are edges in the rooted tree (directed from child to parent), and { , } is an edge in − such that is no descendant of and is no descendant of in (i.e., and lie in different subtrees), add {{ , }, { , }} to ′′ .
( Roughly speaking, for each non-tree edge { , } that connects two different subtrees of , the first rule connects the parent edges of and , whereas the second rule connects all edges of that lie on the two paths from to to their lowest common ancestor.An illustration of these rules can be found in the left and center image of Figure 2. As Tarjan and Vishkin point out, each node can determine each connection of its parent edge that is formed according to the first rule by comparing ( ) + ( ) with the label ( ) of each of its neighbors in ; if ( ) + ( ) ≤ ( ), then the two parent edges of are connected in ′′ .For the second rule, each node , ( ) ≠ 1 with child connects its parent edge with the parent edge of if ( ) < or ℎ ℎ( ) ≥ + ( ).
Step 4: Compute Connected Components of ′′ .To compute the connected components of ′′ , we execute the algorithm of Theorem 1.2 on ′′ .Note that every two nodes that are connected in ′′ are simulated by adjacent nodes in ; therefore, the local communication in ′′ can be carried out using the local edges of .Furthermore, since each node of simulates at most one node of ′′ , the global communication can also be simulated with the same communication capacity as in Theorem 1.2.After (log ) rounds, w.h.p., we have established a well-formed tree on each connected component of ′′ .
Step 5: Extend ′′ to ′ .Finally, we incorporate the non-tree edges into the connected components of ′′ using the following rule of Tarjan and Vishkin.
An example can be found in the right image of Figure 2. Note that this only extends the connected components of ′′ by single nodes (i.e., it does not merge components of ′′ ).Therefore, afterwards we know the biconnected component of each edge of .Specifically, if there is only one biconnected component in ′ (which can easily be determined by counting the number of nodes that act as the root of a well-formed tree in ′′ ) we can determine whether is biconnected.Furthermore, we can determine the cut nodes and bridge edges in .We conclude Theorem 1.4.
in which all nodes finished, the observer signals the nodes to stop via broadcast and also tells them which execution finished.To do so efficiently, we execute the algorithm of Theorem 1.2 on each component of undecided nodes and let the root of each established well-formed tree act as the observer.
More precisely, our algorithm to solve the MIS problem operates in the following three steps of length (log + log log ) each.To synchronize these steps, we need to assume that, in addition to log as an approximation of log log , the nodes know an approximation of (log ).
Step 1: Shatter the Graph into Small Components.First, we run Ghaffari's (Weak-)MIS algorithm from [23] for (log ) rounds.Let 1 , . . ., be the connected components of that only consist of undecided nodes (obviously, the nodes can use the local edges to determine which of its neighbors are in the same component).The remainder of our algorithm will run on each of these 's in parallel.
Step 2: Construct an Overlay for each Component.Next, we establish a well-formed tree on each using the algorithm of Theorem 1.2.
Step 3: Execute Métivier's Algorithm in Parallel.Finally, we construct an MIS for each as follows: (1) On each , we run the MIS algorithm of Métivier et al. independently Θ(log ) times in parallel.Since each execution only needs messages of size 1, this can be done in the CONGEST model.More precisely, the nodes simply send random bit strings of length (log ), where the ℎ bit belongs to execution .
(2) Whenever an execution finishes on a node ∈ , i.e., a node or one of its neighbors joins the MIS, it uses to send a message to the root that contains the execution and the current round.Since there are at most (log ) executions finishing in each given round, the information on which executions have finished can be fitted into (log ) bits.
(3) The root broadcasts all finished executions to the nodes using .
(4) The nodes adopt the result of the first execution that finishes.If several executions finish simultaneously, the lexicographically smallest one is chosen.
We are now able to prove Theorem 1.5.P T 1.5.First, note that Ghaffari's algorithm can seamlessly be implemented in the CONGEST model as it only sends (log ) sized messages.After executing it, each knows with probability 1 − (Δ) whether it is in the MIS.Furthermore, the random decision only depends on a node's 2-neighborhood.Thus, w.h.p, the graph is shattered into isolated, undecided components 1 , . . ., of size at most ( 4 log ) (see, e.g., [23, Lemma 4.2, (P2)]).Now consider the construction of well-formed trees 1 , . . ., for these components.Since each component has size ( 4 log ), the construction takes time (log( 4 log )) = (log + log log ), w.h.p., by Theorem 1.2.Further, the resulting trees 1 , . . ., have a height of (log + log log ).This allows us to (deterministically) compute aggregate functions on each in time (log + log log ).
Now consider the last step and fix a component with its corresponding tree .Let be the be the index of the first successful execution of Métivier's algorithm, i.e., the first execution where all nodes have either joined the MIS or have a neighbor that joined.Then, after (log + log log ) rounds, the root of is aware of index through a simple aggregation.The root then broadcasts to all nodes in .Thus, after another (log + log log ) rounds, all nodes are aware of and stop.

Definition 2 .
22 (Small-Set Conductance).Let := ( , ) be a connected Δ-regular graph and ⊂ with | | ≤ | | 2 visited in a depth-first traversal of .Let ( ) be the set of descendants of in (including ).The goal of Step 2 is to compute ( ) := | ( )| as well as ℎ ℎ( ) := max{ ( ) | ∈ + ( )} and ( ) := min{ ( ) | ∈ + ( )}, where+ ( ) := ( ) ∪ { ∈ | { , } ∈ \ , ∈ ( )}is the union of 's descendants and its descendants neighbors in the undirected version of .Using these values, in Step 3 the nodes construct the subgraph ′′ of ′ that only contains the nodes that correspond to edges of (i.e., it does not include nodes for the non-tree edges of − ).The nodes simulate ′′ in a way that allows them to perform Theorem 1.2 without any overhead to establish a well-formed tree on each connected component of ′′ in Step 4. Finally, in Step 5 the components of ′′ are extended by nodes corresponding to non-tree edges to obtain the full biconnected components of .

Fig. 2 .
Fig.2.The directed edges are tree edges, and the undirected edge is a non-tree edge.Le : The first rule adds an edge between the two parent edges of and .Center: The second rule connects all nodes on the two paths from to to their lowest common ancestor.Right: The edge { , } is connected to the component using the third rule.
[5]adi et al.[5]achieve a comparable result in the MPC model (that uses ( ) communication per node) with a runtime logarithmic in the input graph's spectral expansion.Note that, however, the NCC, the MPC model, and PRAMs are arguably more powerful than the overlay network model considered in this paper, since nodes can reach any other node (or, in the case of PRAMs, processors can contact arbitrary memory cells), which rules out a naive simulation that would have Ω(log ) overhead if we aim for a runtime of (log ).Also, if the degree is unbounded (which is our assumption for the hybrid model), simulating PRAM algorithms, which typically have work Θ( ), becomes completely infeasible.Furthermore, since many PRAM [8,20,37]s are very complicated, it is highly unclear whether their techniques can be applied to our model.Last, there is a hybrid network model Augustine et al.[8]that combines global (overlay) communication with classical distributed models such as CONGEST or LOCAL.Here, in a single round, each node can communicate with all its neighbors in a communication graph and addition can send and receive a limited amount messages from each node in the system.So far, most research for hybrid networks focussed on shortest-paths problems[8,20,37].For example, in general graphs APSP can be solved exactly and optimally (up to polylogarithmic factors) in time ( √ ), and SSSP can be computed in time (min{ 2/5 , √ }) exactly.Whereas even an Ω( √ ) approximation for APSP takes time ( √ ), a constant approximation of SSSP can be computed in time ( )