Broadcast and minimum spanning tree with o ( m ) messages in the asynchronous CONGEST model

We provide the ﬁrst asynchronous distributed algorithms to compute broadcast and minimum spanning tree with o ( m ) bits of communication, in a sufﬁciently dense graph with n nodes and m edges. For decades, it was believed that Ω( m ) bits of communication are required for any algorithm that constructs a broadcast tree. In 2015, King, Kutten and Thorup showed that in the KT1 model where nodes have initial knowledge of their neighbours’ identities it is possible to construct MST in ˜ O ( n ) messages in the synchronous CONGEST model. In the CONGEST model messages are of size O ( log n ) . However, no algorithm with o ( m ) messages was known for the asynchronous case. Here, we provide an algorithm that uses O ( n 3 / 2 log 3 / 2 n ) messages to ﬁnd MST in the asynchronous CONGEST model. Our algorithm is randomized Monte Carlo and outputs MST with high probability. We will provide an algorithm for computing a spanning tree with O ( n 3 / 2 log 3 / 2 n ) messages. Given a spanning tree, we can compute MST with ˜ O ( n ) messages.


Introduction
We consider a distributed network as an undirected graph with n nodes and m edges, and the problem of finding a spanning tree and a minimum spanning tree (MST) with efficient communication.That is, we require that every node in the graph learns exactly the subset of its incident edges which are in the spanning tree or MST, respectively.A spanning tree enables a message to be broadcast from one node to all other nodes with only n − 1 edge traversals.In a sensor or ad hoc network where the weight of a link between nodes reflects the amount of energy required to transmit a message along the link [23], the minimum spanning tree (MST) provides an energy efficient means of broadcasting.The problem of finding a spanning tree in a network has been studied for more than three decades, since it is the building block of solu-Funded with an NSERC Grant.
B Valerie King val@uvic.caAli Mashreghi ali.mashreghi87@gmail.com 1 Department of Computer Science, University of Victoria, Victoria, BC, Canada tions to many other fundamental problems such as counting, leader election, and deadlock resolution [3].
A spanning tree can be constructed by a simple breadthfirst search from a single node using m bits of communication.The tightness of this communication bound was a "folk theorem", according to Awerbuch et al. [5].Their 1990 paper defined the KT1 model where nodes have unique IDs and know only their neighbours.It showed, for a limited class of algorithms, a lower bound of Ω(m) messages in a synchronous KT1 network.In 2015, Kutten et al. [23] proved a lower bound for general randomized algorithms with O(log n) bit messages, in the KT0 model, where nodes do not know their neighbours.In 2015, King, Kutten, and Thorup gave the first distributed algorithm ("KKT") with o(m) communication to build a broadcast tree and MST in the KT1 model.They devised Monte Carlo algorithms in the synchronous KT1 model with Õ(n) communication [22].This paper and a followup paper [25] left open the problem of whether a o(m) bit communication algorithm in the asynchronous model was possible, for either the spanning tree or MST problem, when nodes know their neighbours' IDs.
In an asynchronous network, there is no global clock.All processors may wake up at the start and send messages, but further actions by a node are event-driven, i.e., in response to messages received.The pioneer work of Gallager, Humblet, and Spira [17] ("GHS") presented an asynchronous protocol for finding the MST in the CONGEST model, where messages are of size O(log n).GHS requires O(m + n log n) messages and O(n log n) time if all nodes are awakened simultaneously.Afterwards, researchers worked on improving the time complexity of MST algorithms in the CONGEST model but the message complexity remained Ω(m).
In this paper, we provide the first algorithm in the KT1 model which uses o(m) bits of communication for finding a spanning tree in an asynchronous network, specifically we show the following: Theorem 1 Given any network of n nodes where all nodes awake at the start, we can construct a spanning and a minimum spanning tree with time and message complexity of O(n 3/2 log 3/2 n) in the asynchronous KT1 CONGEST model, with high probability.
Note that throughout this work, we will not be discussing the time complexity of our algorithm since in the worstcase, it is asymptotically the same as its message complexity.Please see preliminaries section, for a brief discussion on this.
Trivially, once any spanning tree is constructed, broadcasting can be done using O(n) messages from any of the nodes.

Techniques
Many distributed algorithms to find an MST use the Boruvka method: Starting from the set of isolated nodes, a forest of edge disjoint rooted trees which are subtrees of the MST are maintained.The algorithms run in phases: In a phase, in parallel, each tree A finds a minimum weight outgoing edge, that is, one with exactly one endpoint in A and its other endpoint in some other tree B. Then the outgoing edge is inserted to create the "merged" tree containing the nodes of A and B. In what seems an inherently synchronous process, every tree (or a constant fraction of the trees) participates in some merge, the number of trees is reduced by a constant factor per phase, and O(log n) phases suffice to form a single tree.[3,17,22,25].
The KKT paper introduced procedures Find Any and Find Min which can find any or the minimum outgoing edge leaving the tree, respectively.These require O(|T |) messages and Õ(|T |), respectively, where |T | is the number of nodes in the tree T or a total of Õ(n) per phase.As this is done synchronously in KKT, only O(log n) phases are needed, for a total number of only O(n log n) messages to build a spanning tree.
While Find Any and Find Min are asynchronous procedures, the Boruvka approach of [22] does not seem to work in an asynchronous model with o(m) messages, as it does not seem possible to prevent only one tree from growing, one node at a time, while the other nodes are delayed, for a cost of O(n 2 ) messages.The asynchronous GHS also uses O(log n) phases to merge trees in parallel, but it is able to synchronize the growth of the trees by assigning a rank to each tree.A tree which finds a minimum outgoing edge waits to merge until the tree it is merging with is of equal or higher rank.The GHS algorithm subtly avoids traversing the whole tree until a minimum weight outgoing edge to an appropriately ranked tree is found.This method seems to require communication over all edges in the worst case.
The technique for building a spanning tree in this paper is very different from the technique in [22] or [17].We grow one tree T rooted at one preselected leader in phases.(If there is no preselected leader, then this may be done from a small number of randomly self-selected nodes.)Initially, each node classifies itself as a low-degree or a high-degree node.Nodes that have degree less than √ n log 3/2 n are lowdegree nodes.Otherwise, they are high-degree nodes.Also, each node selects itself to be a star node with probability 1/ √ n log n. (We use log n to denote log 2 n.)This technique is inspired from [12], and provides a useful property that every node whose degree is at least √ n log 3/2 n is adjacent to a star node with high probability.Initially, star nodes (and lowdegree nodes) send out messages to all of their neighbours.Each high-degree node which joins T waits until it hears from a star node and then invites it to join T .In addition, when low-degree and star nodes join T , they invite their neighbours to link to T via their incident edges.Therefore, with high probability, the following invariant for T is maintained as T grows: Invariant 1 T includes all neighbours of any star or lowdegree node in T .Each high-degree node in T is adjacent to a star node in T .
To be more accurate, this invariant is not initially true.We design a subroutine named E x pand (described later), and after each execution of E x pand the invariant is satisfied with high probability.
As mentioned earlier, dividing nodes into two groups based on their degree, i.e., low-degree and high-degree nodes, is crucial for our algorithm to succeed in saving messages.Therefore, it is important to mention that such division in an asynchronous network does not automatically enable us to use approaches that can be used in the synchronous model.For example, in the synchronous model, if low-degree nodes send messages to all of their neighbours, after only one round all nodes learn which of their neighbours are low-degree and which are high-degree.Then, they can construct a subgraph of higher degree nodes which consequently allows them to save messages.However, in the asynchronous model, a node, not hearing from its neighbour, does not know when to conclude that its neighbour is high-degree.
The challenge is for high-degree nodes in T to find neighbours outside T .If in each phase, an outgoing edge from a high-degree node in T to a high-degree node x (not in T ) is found and x is invited to join T , then x's adjacent star node (which must lie outside T by Invariant 1) is also found and invited to join.As the number of star nodes is O( √ n/ log 1/2 n), this number also bounds the number of such phases.The difficulty is that there is no obvious way to find an outgoing edge to a high degree node because, as mentioned above, in an asynchronous network, a high degree node has no apparent way to determine if its neighbour has high degree without receiving a message from its neighbour.
Instead, we relax our requirement for a phase.With each phase either (A) A high-degree node (and star node) is added to T or (B) T is expanded so that the number of outgoing edges to low-degree nodes is reduced by a constant factor.As there are no more than O( √ n/ log 1/2 n) phases of type A and no more than O(log n) phases of type B between each type A phase, there are a total of O( √ n log 1/2 n) phases before all nodes are in T .The key idea for implementing a phase of type B is that the tree T waits until its nodes have heard enough messages passed by low-degree nodes over outgoing edges before initiating an expansion.The efficient implementation of a phase, which uses only O(n log n) messages, requires a number of tools which are described in the preliminaries section.
Once a spanning tree is built, we use it as a communication network while finding the MST.This enables us to "synchronize" a modified GHS which uses Find Min for finding minimum outgoing edges, using a total of Õ(n) messages.

Asynchronous networks
The first breakthrough for computing the MST was by Gallager, Humblet, and Spira [17], who designed an asynchronous algorithm which achieved O(n log n) time and O(m+n log n) message complexity.The algorithm was in the CONGEST model.Then, later works gradually improved the time complexity of asynchronous MST computation to linear in n [3,8,15,16,32].The message complexity of the aforementioned papers is O(m + n log n).Since our focus here is on dense graphs with at least Ω(n 3/2 ) edges, we may omit the n log n term.Notice that all of these algorithms could take Θ(n) time for some input.In other words, an MST algorithm with O(n) time and O(m+n log n) is existentially optimal, i.e., if the input graph has a diameter of Θ(n) no algorithm with better time complexity can be presented.However, in practice, most networks have a diameter much smaller than n.This led the researchers to find algorithms that achieve sublinear time complexity for such graphs.However, the first algorithms with this property were in the synchronous model.
Synchronous networks Garay et al. [18] were the first to give a sublinear time O(D + n 0.614 )-round MST algorithm, where D is the hop diameter of the network.Kutten and Peleg [24] gave an algorithm with O(D + √ n log * n) time complexity, and Elkin [9] provided an algorithm with time Õ(μ(G, w) + √ n).In his algorithm, μ(G, w) is the MSTradius of the network that for certain graphs can be much smaller than D. In KT0 model, lower bounds of Ω(D + √ n) on the time complexity and lower bounds of Ω(m) on the message complexity have been proven [4,10,23,29,31].There are algorithms that match both lower bounds simultaneously up to a polylogarithmic factor [13,28].
A spanning tree can be constructed by a simple breadthfirst search from a single node using m messages.The tightness of this communication bound was a "folk theorem", according to Awerbuch, Goldreich, Peleg and Vainish [5].For a limited class of algorithms, they showed a lower bound of Ω(m) messages in the synchronous KT1 network.
However, in 2015, King et al. [22], provided an algorithm in the KT1 model with Õ(n) time and message complexity, which was the first algorithm that obtained a o(m) message complexity.Their algorithm is randomized and Monte Carlo, i.e., it outputs the solution with high probability.Note that with high probability (w.h.p.) means with a probability of 1 − 1 n c , where constant c is a parameter of the algorithm.The Awerbuch et al. [5] lower bound on the number of messages holds only for (randomized) algorithms where messages may contain a constant number of IDs, and IDs are processed by comparison only and for general deterministic algorithms, where ID's are drawn from a very large size universe.
Lower bounds on time for approximating the minimum spanning tree have been proved in the synchronous KT0 model In [10,31], Kutten et al. [23] show an Ω(m) lower bound on message complexity for randomized general algorithms in the KT0 model.In this paper we show that in the KT1 CONGEST model and with asynchronous communication, it is possible to provide randomized algorithms to achieve o(m) message complexity.
Find Any and Find Min which appear in the KKT algorithms build on ideas for sequential dynamic connectivity in [21].A sequential dynamic ApproxCut also appeared in that paper [21].Solutions to the sequential linear sketching problem for connectivity [1] share similar techniques but require a more complex step to verify when a candidate edge name is an actual edge in the graph, as the edges names are no longer accessible once the sketch is made (See Sect.2.4).
The threshold detection problem was introduced by Emek and Korman [14].It assumes that there is a rooted spanning tree T where events arrive online at T 's nodes.Given some threshold k, a termination signal is broadcast by the root if and only if the number of events exceeds k.We use a naive solution of a simple version of the problem here.
A synchronizer, introduced by Awerbuch [2] and studied in [6,7,11,30], is a general technique for simulating a synchronous algorithm on an asynchronous network using 123 communications along a spanning tree.To do this, the spanning tree must be built first.Using a general synchronizer imposes an overhead of messages that affect every single step of the synchronous algorithm that one wants to simulate, and would require more communication than our special purpose method of using our spanning tree to synchronize the modified GHS.
There are two related works in the synchronous CON-GEST model [19,20] that provide MST algorithms with Õ(n 3/2 ) messages and in Õ(D + √ n) time.The idea of selecting a small subset of nodes (which we will call star nodes in this paper) to help with reducing the message complexity is the shared among these works.More importantly, there is the need to treat nodes differently based on their degree.Roughly speaking, nodes with degree > √ n (called high-degree nodes) are treated differently from nodes whose degree is ≤ √ n (called low-degree nodes).A node has to have a way to tell which of their neighbours are high-degree and which are not.This distinction can be made very easily if the communication is synchronous.It can be done with O(1) time and O(n 3/2 ) messages.However, in an asynchronous network there is no efficient way to distinguish these nodes.Our paper is different from the aforementioned works in the techniques it provides to deal with the problems that arise in the presence of asynchrony.We achieve the same message complexity for the asynchronous model while the time complexity of our algorithms is also Õ(n 3/2 ).
Note that during this journal publication, we have provided another result in asynchronous model that keeps the message complexity and improves the time complexity to O(n) [26,27].

Organization
Section 2 describes the model.Section 3 gives the spanning tree algorithm for the case of a connected network and a single known leader.Finally, Sect. 4 provides the MST algorithm.Section 5 provides the algorithm for computing a minimum spanning forest in disconnected graphs.

Model
Let c ≥ 1 be any constant.The communication network is the undirected graph G = (V , E) over which a spanning tree or MST will be found.Edge weights are integers in [1, n c ]. IDs are assigned uniquely by the adversary from [1, n c ].All nodes have knowledge of c and n which is an upper bound on |V | (number of nodes in the network) within a constant factor.All nodes know their own ID along with the IDs of their neighbours (KT1 model) and the weights of their incident edges.Nodes have no other information about the network.e.g., they do not know |E| or the maximum degree of the nodes in the network.If the edge weights are not unique they can be made unique by appending the ID of the endpoints to its weight, so that the MST is unique.Nodes can only send direct messages to the nodes that are adjacent to them in the network.Our algorithm is described in the CONGEST model in which each message has size O(log n).Note that in the literature CONGEST usually refers to a synchronous network; however, our algorithms are asynchronous and by CONGEST we only mean that the size of each message is bounded by O(log n).The KT1 CONGEST model has been referred to as the "standard model" [5].
Message cost is the sum over all edges of the number of messages sent over each edge during the execution of the algorithm.If a message is sent it is guaranteed to be eventually received.
We say a network "finds" a subgraph if at the end of the distributed algorithm, every node knows exactly which of its incident edges in the network are part of the subgraph.The algorithm here is Monte Carlo, in that it succeeds with probability 1 − n −c for any constant c ("w.h.p.").
We initially assume there is a special node (called leader) at the start and the graph is connected.These assumptions are dropped in Sect. 5.

Communication and time complexity
Networks can be synchronous or asynchronous.Communication in a synchronous network proceeds in rounds where at the beginning of each round the nodes that intend to send a message to a subset of their neighbours, send their messages.These messages are guaranteed to be received by the end of this round.It is like communication is being synchronized using a global clock that all nodes have access to.Time complexity in a synchronous network is the number of rounds that an algorithm needs to complete.This is also known as the round complexity of the algorithm.
However, in an asynchronous network, there is no global clock.Any sent message can have an arbitrary delay before it is delivered.Another way of thinking about this is that the communication is event-driven; nodes take actions upon receiving messages (or waking up for the first time).In this work, our assumption is that all nodes wake up simultaneously and start to execute their protocols.
In an asynchronous network, time complexity is defined as the worst-case execution time if the delivery delays of all messages are normalized to be at most one time unit.Therefore, the time complexity is determined by the worstcase chain of events.We assume that the time for completing local computations within a node is negligible.
The time complexity of an asynchronous algorithm is trivially bounded by its message complexity since the worst chain of execution is if all messages are sequentially organized and there is no parallelism.In this paper, we rely on this fact and will not be discussing the time complexity of our algorithms.

Definitions and subroutines
T is initially a tree containing only the leader node.Thereafter, T is a tree rooted at the leader node.We use the term outgoing edge from T to mean an edge with exactly one endpoint in T .An outgoing edge is described as if it is directed; it is from a node in T and to a node not in T (the "external" endpoint).
The algorithm uses the following subroutines and definitions: -Broadcast(M): Procedure whereby the leader of T sends a message M to its children and its children broadcast to their subtrees.-E x pand: A procedure for adding nodes to T and preserving Invariant 1 after doing so.-Find Any: Returns to the leader an outgoing edge chosen uniformly at random with probability 1/16, or else it returns ∅.The leader then broadcasts the result.Find Any requires O(n) messages.We specify Find Any(E ) when we mean that the outgoing edge must be an outgoing edge in a particular subset E ⊆ E. -Find Min: is similarly defined except the edge is the (unique) minimum cost outgoing edge.This is used only in the minimum spanning tree algorithm.Find Min requires O(n log 2 n/ log log n) messages.-ApproxCut: A function which w.h.p. returns an estimate in [k/ 32, k] where k is the number of outgoing edges from T and k > c log n for c a positive constant.It requires O(n log n) messages.Find Any and Find Min are described in [22] (The Find Any is called FindAny-C there.)FindAny-C was used to find any outgoing edge in the previous paper.It is not hard to see that the edge found is a random edge from the set of outgoing edges; we use that fact here.The relationships among Find Any, Find Min and ApproxCut below are described in the next subsection.-Found L (v), Found O (v): Two lists of edges incident to node v, over which v will send invitations to join T the next time v participates in E x pand.After this, the list is emptied.Edges are added to Found L (v) when v receives Low − degree message or the edge is found by the leader by sampling and its external endpoint is low-degree.Otherwise, an edge is added to Found O (v) when v receives a Star message over an edge or if the edge is found by the leader by sampling and its external endpoint is high-degree.Note that star nodes that are low-degree send both Low − degree and Star .This may cause an edge to be in both lists which is handled properly in the algorithm.-T − neighbour(v): A list of neighbours of v in T .This list, except perhaps during the execution of E x pand, includes all low-degree neighbours of v in T .This list is used to exclude from Found L (v) any non-outgoing edges.-T hreshold Detection(k): A procedure that is used to inform the leader w.h.p. when the number of events experienced by the nodes in a fragment T reaches the threshold k/4.The leader initiates this procedure and provides the parameter k.The nodes in T experience no more than k < n 2 events w.h.p.Here, an event is the receipt of Low − degree over an outgoing edge.Following the completion of E x pand, all edges (u, v) that are in Found L (u) are events if v / ∈ T − neighbour(u).The idea for this procedure is to approximate the number of outgoing edges from T , and using this approximation when we know that at least half the outgoing edges are to low-degree nodes.This provides a constant approximation on the number of events that are expected to be received.O(|T | log n) messages suffice to complete this procedure.

Note
The reason we need the T − neighbour data structure is that we assumed that messages may not be received in the same order they were sent.In particular, Low − degree messages from neighbours of a node in the fragment tree could be received very late.Therefore, we need to have this data structure so that when the fragment is waiting for events (in T hreshold Detection) we do not count these late messages as events.An alternative way to deal with this is to have nodes send back acknowledgment messages if they receive a Low − degree message.A low-degree node will only send its future messages only if it has received an acknowledgement for its initial Low − degree message.This guarantees that no Low − degree message from a node inside the fragment will contribute to the events.

Implementation of FindAny, FindMin and ApproxCut
We briefly review Find Any in [22] and explain its connection with ApproxCut.The key insight is that an outgoing edge is incident to exactly one endpoint in T while other edges are incident to zero or two endpoints.If there was exactly one outgoing edge, the parity of the sum of all degrees in T would be 1, and the bit-wise XOR of the binary representation of the names of all incident edges would be the name of the one outgoing edge.
To deal with possibility of more than one outgoing edge, the leader creates an efficient means of sampling edges at different rates: Let l = 2 log n .The leader selects and broadcasts one pairwise independent hash function h : where edge_names of an edge is a unique binary string computable by both its endpoints, e.g., {x, y} = x • y (concatenated) for x < y.Each node y forms the vector − − → h(y) whose i th bit is the parity of the number of its incident edges that hash to [1, 2 i ], i = 0, . . ., l. Starting with the leaves, a node in T computes the bitwise XOR of the vectors from its children and itself and then passes this up the tree, until the leader has computed The key insight, as mentioned in the previous paragraph, implies that for each index i, − → b i equals the parity of just the number of outgoing edges mapped to [1, With constant probability, exactly one edge of the outgoing edges has been mapped to [1, 2 min ].The leader broadcasts min.Nodes send back up the XOR of the edge_names of incident edges which are mapped by h to this range.If exactly one outgoing edge has been indeed mapped to that range, the leader will find it by again determining the XOR of the edge_names sent up.One more broadcast from the leader can be used to verify that this edge exists and is incident to exactly one node in T .
Since each edge has the same probability of falling in [1, 2 min ], this procedure gives a randomly selected edge.Note also that the leader can instruct the nodes to exclude certain edges from the XOR, say incident edges of weight greater than some w.In this way the leader can binary search for the minimal weight outgoing edge to carry out Find Min.Similarly, the leader can select random edges without replacement.
Observe that if the number of outgoing edges is close to 2 j , we would expect min to be l − j with constant probability.Here we introduce distributed asynchronous ApproxCut which uses the sampling technique from Find Min but repeats it O(log n) times with O(log n) randomly chosen hash functions.Let min_sum be the minimum i for which the sum of − → b i s exceeds c log n for some constant c.We show 2 min_sum approximates the number of outgoing edges within a constant factor from the actual number.ApproxCut pseudocode is given in Algorithm 5.
We show:

Asynchronous ST construction with o(m) messages
In this section we explain how to construct a spanning tree when there is a preselected leader and the graph is connected.
Initially, each node selects itself with probability 1/ √ n log n as a star node.Low-degree and star nodes initially send out Low − degree and Star messages to all of their neighbours, respectively.(We will be using the M notation to show a message with content M.) A low-degree node which is a star node sends both types of messages.At any point during the algorithm, if a node v receives a Low − degree or Star message through some edge e, it adds e to Found L (v) or Found O (v) respectively.
The algorithm FindST-Leader runs in phases.Each phase has three parts: 1) Expansion of T over found edges since the previous phase and restoration of Invariant 1; 2) Search for an outgoing edge to a high-degree node; 3) Wait until messages to nodes in T have been received over a constant fraction of the outgoing edges whose external endpoint is low-degree.1) Expansion Each phase is started with E x pand.E x pand adds to T any nodes which are external endpoints of outgoing edges placed on a Found list of any node in T since the last time that node executed E x pand.In addition, it restores Invariant 1 for T .Recall the invariant statement: T includes all neighbours of any star or low-degree node in T .Each high-degree node in T is adjacent to a star node in T .Implementation Expand is initiated by the leader and broadcast down the tree.When a node v receives E x pand message for the first time (it is not in T ), it joins T and makes the sender its parent.If it is a high-degree node and is not a star, and is receiving the E x pand message for the first time, it has to wait until it receives a Star message over some edge e, and then adds e to Found O (v).At all times, if this node received any Low − degree messages, it adds the corresponding neighbours to its Found L (v) list.Once the node receives the Star message, it proceeds by forwarding the E x pand over the edges in Found L (v) or Found O (v) and empties these lists.Note, that if the high-degree non-star node is not a first-timer (has received E x pand before), it just forwards the message to its children and over the edges in Found L (v) and Found O (v) lists.
If the first-timer node is low-degree or a star, it forwards E x pand to all of its neighbours.
On the other hand, if v is already in T , it forwards E x pand message to its children in T and along any edges in Found L (v) or Found O (v), i.e. outgoing edges which were "found" since the previous phase, and empties these lists.All E x pand requests received by v are answered, and their sender is added to T − neighbour(v).The procedure ends in a bottom-up way and ensures that each node has heard from all the nodes it sent E x pand requests to before it contacts its parent.
Let T i denote T after the execution of E x pand in phase i. Initially T 0 consists of the leader node and as its Found lists contain all its neighbours, after the first execution of E x pand, if the leader is high-degree, T 1 satisfies Invariant 1.An easy inductive argument on T i shows: Observation 1 For all i > 0, upon completion of E x pand, all the nodes reachable by edges in the Found lists of any node in T i−1 are in T i , and for all v ∈ T , T-neighbour(v) contains all the low-degree neighbours of v in T .E x pand is called in line 6 of the main algorithm (Algorithm 2) The pseudocode is given in the E x pand algorithm.
2) Search for an outgoing edge to a high degree node A sampling of the outgoing edges without replacement is done using Find Any multiple times.The sampling either (1) finds an outgoing edge to a high degree node, or (2) finds all outgoing edges, or (3) determines w.h.p. that at least half the outgoing edges are to low-degree nodes and there are at least 2c log n such edges.If the first two cases occur, the phase ends.Implementation Endpoints of sampled edges in T communicate over the outgoing edge to determine if the external endpoint is high-degree.If at least one is, that edge is added to the Found O list of its endpoint in T and the phase ends.If there are fewer than 2c log n outgoing edges, all these edges are added to Found O and the phase ends.If there are no outgoing edges, the algorithm ends.If all 2c log n edges go to low-degree nodes, then the phase continues with Step 3) below.This is implemented in the while loop of FindST-Leader.Throughout this section we will be using the following fact from Chernoff bounds: Assume X 1 , X 2 , . . ., X T are independent Bernoulli trials where each trial's outcome is 1 with probability 0 < p < 1. Chernoff bounds imply that given constants c, c 1 > 1 and c 2 < 1 there is a constant c such that if there are T ≥ c log n independent trials, then We show: Lemma 2 After Search, at least one of the following must be true with probability 1 − 1/n c , where c is a constant depending on c: (1) there are fewer than 2c log n outgoing edges and the leader learns them all; (2) an outgoing edge to a high-degree node is found, or ( 3) there are at least 2c log n outgoing edges and at least half the outgoing edges are to low-degree nodes.
Proof Each Find Any has a probability of 1/16 of returning an outgoing edge and if it returns an edge, it is always outgoing.After 48c log n repetitions without replacement, the expected number of edges returned is 3c log n.Chernoff bounds imply that at least 2/3 of trials will be successful with probability at least 1−1/n c , i.e., 2c log n edges are returned if there are that many, and if there are fewer, all will be returned.
The edges are picked uniformly at random by independent repetitions of Find Any.If during these repetitions, at least half the sampled outgoing edges are to high-degree nodes, the probability that all edges returned are to low-degree nodes is 1/2 2c log n < 1/n 2c .
3) Wait to hear from outgoing edges to low-degree external nodes: This step forces the leader to wait until T has been contacted over a constant fraction of the outgoing edges to (external) low-degree nodes.Note that we do not know how to give a good estimate on the number of low-degree nodes which are neighbours of T .Instead we count outgoing edges.Implementation This step occurs only if the 2c log n randomly sampled outgoing edges all go to low-degree nodes and therefore the number of outgoing edges to low-degree nodes is at least this number.In this case, the leader waits until T has been contacted through a constant fraction of these edges.
If this step occurs, then w.h.p., at least half the outgoing edges go to low-degree nodes.Let k be the number of outgoing edges; k ≥ 2c log n.The leader calls ApproxCut to return an estimate q ∈ [k/32, k] w.h.p.From Lemma 2, w.h.p. the number of outgoing edges to low-degree nodes is The nodes v ∈ T will eventually receive at least k/2 Low − degree messages over the outgoing edges.Note that these messages must have been received by v after v executed E x pand and added to Found L (v), for otherwise, these would not be outgoing edges.
The leader initiates a ThresholdDetection procedure whereby there is an event for a node v for each outgoing edge v has received a Low-degree message over since the last time v executed E x pand.As the ThresholdDetection procedure is initiated after the leader finishes E x pand, the T-neighbour(v) includes any low-degree neighbour of v that is in T .Using T-neighbour(v), v can determine which edges in Found L (v) are outgoing.
Each event experienced by a node causes it to flip a coin with probability min{c log n/r , 1}.If the coin is heads, then a trigger message labelled with the phase number is sent up to the leader.The leader is triggered if it receives at least (c/2) log n trigger messages for that phase.When the leader is triggered, it begins a new phase.Since there are at least r triggering events, the expected number of trigger messages eventually generated is (c log n/r )r ≥ c log n.Lemma 3 When the leader receives (c/2) log n messages with the current phase number, w.h.p, at least 1/128 of the outgoing edges to low-degree nodes have been added to Found L lists.
Proof Chernoff bounds imply that at least (c/2) log n trigger messages will be generated w.h.p.Alternatively, w.h.p., the number of trigger messages received by the leader will not 123 exceed (c/2) log n until at least r /2 events have occurred, as this would imply twice the expected number.We can conclude that w.h.p. the leader will trigger the next phase after k/128 of the outgoing edges to low-degree nodes have been found.

Proof of the main theorem
Here we prove Theorem 1 as it applies to computing the spanning tree of a connected network with a pre-selected leader.

Lemma 4 W.h.p., after each phase except perhaps the first, either (A) A high-degree node (and star node) is added to T or (B) T is expanded so that the number of outgoing edges to low-degree nodes is reduced by a 1/128 factor (or the algorithm terminates with a spanning tree).
Proof By Lemma 2 there are three possible results from the Search phase.If a sampled outgoing edge to a high-degree node is found, this edge will be added to the Found O list of its endpoint in T .If the Search phase ends in fewer than 2c log n edges found and none of them are to high degree nodes, then w.h.p. these are all the outgoing edges to lowdegree nodes, these edges will all be added to some Found L .If there are no outgoing edges, the algorithm terminates and a spanning tree has been found.If the third possible result occurs, then there are at least 2c log n outgoing edges, half of which go to low-degree nodes.By Lemma 3, the leader will trigger the next phase and it will do so after at least 1/128 of the outgoing edges to low-degree nodes have been added to Found L lists.
By Observation 1, all the endpoints of the edges on the Found lists will be added to T in the next phase, and there is at least one such edge or there are no outgoing edges and the spanning tree has been found.When E x pand is called in the next phase, T acquires a new high degree node in two possible ways, either because an outgoing edge on a Found list is to a high-degree node or because the recursive E x pand on outgoing edges to low-degree edges eventually leads to an external high-degree node.In either case, by Invariant 1, T will acquire a new star node as well as a high-degree node.Also by Invariant 1, all outgoing edges must come from highdegree nodes.Therefore, if no high-degree nodes are added to T by Expand, then no new outgoing edges are added to T .On the other hand, 1/128 of the outgoing edges to low-degree nodes have become non-outgoing edges as their endpoints have been added to T .So we can conclude that the number of outgoing edges to low-degree nodes have been decreased by 1/128 factor.
It is not hard to see:

Lemma 5 The number of phases in the algorithm is bounded by O(
√ n log 1/2 n).
Proof By Lemma 4, every phase except perhaps the first, is of type A or type B. Chernoff bounds imply that w.h.p., the number of star nodes does not exceed its expected number ( √ n/ log 1/2 n) by more than a constant factor, hence there are no more than O( √ n/ log 1/2 n) phases of type A. Before and after each such phase, the number of outgoing edges to low-degree nodes is reduced by at least a fraction of 1/128; hence, there are no more than log 4/3 n 2 = O(log n) phases of type B between phases of type A.
Finally, we count the number of messages needed to compute the spanning tree.

Lemma 6
The message complexity of the algorithm is O(n 3/2 log 3/2 n).
In each phase, E x pand requires a number of messages which is linear in the size of T or O(n), except that newly added low-degree and star nodes send to their neighbours when they are added to T , but this adds just a constant factor to the initialization cost.Find Any is repeated O(log n) times for a total cost of O(n log n) messages.ApproxCut requires the same number.The Threshold Detector requires only O(log n) messages to be passed up T or O(n log n) messages overall.Therefore, by Lemma 5 the number of messages over all phases is O(n 3/2 log 3/2 n).
Theorem 1 for spanning trees in connected networks with a pre-selected leader follows from Lemmas 5 and 6.

Proof of ApproxCut Lemma
Proof Let W be the set of the outgoing edges.For node y, and hash function h z vector − → h z (y) is computed where h z,i (y) is the parity of incident edges that hash to is computed in the leader.For a fixed z and i, we have : This probability is at least 1/16 for i = l − log |W | − 2 (Lemma 5 of [22]).Note that the value of i here differs from i = l − log |W | −1 used in [22].This is because the proof of Lemma 5 in there can be tighter, so the probability of 1/16 still holds even if we decrease the value by one.Remember that l = 2 log n .Therefore, since X j = c log n z=1 h z, j (as defined in the pseudocode and not to be confused with Bernoulli trials), 2 j+1 .Consider j − 4. Since the probability of an edge being hashed to [2 j−4 ] is 2 j−4 2 l , we have Thus, E[X j−4 ] ≤ c log n/32.Since an edge that is hashed to [2 j−k ] (for k > 4) is already hashed to [2 j−4 ], we have: Let y z be 1 if h z, j−4 (T ) = 1 ∨ . . .∨ h z,0 (T ) = 1, and 0 otherwise.Also, let Y = c log n z=1 y z .We have E[Y ] ≤ c log n/32.Also, for any positive integer a, From Chernoff bounds: Therefore, by finding the smallest i (called min in pseudocode) for which Furthermore, as explained in [22] (Sect. 2 on random odd hash functions), the hash functions can be defined using only two numbers; a multiplier and a threshold which can fit in one message.Therefore, broadcasting each of the O(log n) hash functions and computing the corresponding vector takes O(n) messages; so, the lemma follows.
Algorithm 1 Initialization of the spanning tree algorithm 1: procedure Initialization 2: Every node selects itself to be a star node with probability of 1/ √ n log n.

3:
Nodes that have degree < √ n log 3/2 n are low-degree nodes.Otherwise, they are high-degree nodes.(Note that they may also be star nodes at the same time.)4: Star nodes send Star messages to all of their neighbours.

5:
Low-degree nodes send Low-degree messages to all of their neighbours (even if they are star nodes too).6: end procedure Algorithm 2 Asynchronous protocol for the leader to find a spanning tree.

Finding MST with o(m) asynchronous communication
The MST algorithm implements a version of the GHS algorithm which grows a forest of disjoint subtrees ("fragments") of the MST in parallel.We reduce the message complexity of GHS by using Find Min to find minimum weight outgoing edges without having to send messages across every edge.
Algorithm 3 Given r at phase i, this procedure detects when nodes in T receive at least r /4 Low − degree messages over outgoing edges.c is a constant.

3:
When a node u ∈ T receives Send-trigger, r , i , it first participates in the broadcast.Then, for every event, i.e. every edge (u, v) ∈ Found(u) L such that v / ∈ T-neighbour(u), u sends to its parent a T rigger, i message with probability of c log n/r .

4:
A node that receives T rigger, i from a child keeps sending up the message until it reaches the leader.If a node receives an Expand before it sends up a Trigger, i , it discards the Trigger, i messages as an Expand has already been triggered.

5:
Once the leader receives at least c log n/2 Trigger, i messages, the procedure terminates and the control is returned to the calling procedure.6: end procedure Algorithm 4 Leader initiates Expand by sending Expand to all of its children.If this is the first Expand, leader sends to all of its neighbours.Here, x is any non-leader node.
1: procedure Expand 2: When node x receives an E x pand message over an edge (x, y): 3: x adds y to T-neighbour(x).

4:
if x is not in T then 5: The first node that x receives Expand from becomes x's parent.//x joins T 6: if x is a high-degree node and x is not a star node then 7: It waits to receive a Star over some edge e, then adds e to Found O (x).

8:
It forwards Expand over edges in Found L (x) and Found O (x) (only once in case an edge is in both lists), then removes those edges from the Found lists.9: else (x is a low-degree or star node) 10: It forwards the Expand message to all of its neighbours.11: end if 12: else (x is already in T ) 13: If the sender is not its parent, it sends back Done-by-reject .

Else, it forwards
Expand to its children in T , over the edges in Found L (x) and Found O (x), then removes those edges from the Found lists.14: end if // Note that if x added more edges to its Found list after forward of Expand , the new edges will be dealt with in the next Expand.

15:
When a node receives Done messages (either Done-by-accept or Done-by-reject ) from all of the nodes it has sent to, it considers all nodes that have sent Done-by-accept as its children.
Then, it sends up Done-by-accept to its parent.16: The algorithm terminates when the leader receives Done from all of its children.17: end procedure Algorithm 5 Approximates the number of outgoing edges within a constant factor.c is a constant.

3:
For node y, and hash function h z vector − → h z (y) is computed where h z,i (y) is the parity of incident edges that hash to [2 i ], i = 0, . . ., l.

4:
For hash function h z , − → h z (T ) = ⊕ y∈T − → h z (y) is computed in the leader.

7:
Return 2 l−min /64.8: end procedure But, in order to do this, we require the use of a spanning tree to help synchronize the growth of the fragments.
Note that GHS nodes send messages along their incident edges for two main purposes: (1) to see whether the edge is outgoing, and (2) to make sure that fragments with higher rank are slowed down and do not impose a lot of time and message complexity.Therefore, if we use Find Min instead of having nodes to send messages to their neighbours, we cannot make sure that higher ranked fragments are slowed down.Our protocol works in phases where in each phase only fragments with smallest ranks continue to grow while other fragments wait.A spanning tree is used to control the fragments based on their rank.(See [17] for the original GHS.) Implementation of FindMST: Initially, each node forms a fragment containing only that node which is also the leader of the fragment and fragments all have rank zero.A fragment identity is the node ID of the fragment's leader; all nodes in a fragment know its identity and its current rank.Let the precomputed spanning tree T be rooted at a node r .All fragment leaders wait for instructions that are broadcast by r over T .
The algorithm runs in phases.At the start of each phase, r broadcasts the message Rank-request to learn the current minimum rank among all fragments after this broadcast.Leaves of T send up their fragment rank.Once an internal node in T receives the rank from all of its children (in T ) the node sends up the minimum fragment rank it has received including its own.This kind of computation is also referred to as a convergecast.
Then, r broadcasts the message Proceed, min Rank where min Rank is the current minimum rank among all fragments.Any fragment leader that has rank equal to min Rank, proceeds to finding minimum weight outgoing edges by calling FindMin on its own fragment tree.These fragments then send a Connect message over their minimum weight outgoing edges.When a node v in fragment F (at rank R) sends a Connect message over an edge e to a node v in fragment F (at rank R ), since R is the current minimum rank, two cases may happen: (Ranks and identities are updated here.)1. R < R : In this case, v answers immediately to v by sending back an Accept message, indicating that F can merge with F .(Note that v might receive more than one such message at the same time from different nodes, but it still treats them in the same way.)Then, v initiates the merge by changing its fragment identity to the identity of F , making v its parent, and broadcasting F 's identity over fragment F so that all nodes in F update their fragment identity as well.Also, the new fragment (containing F and F ) has rank R .2. R = R : v responds Accept immediately to v if the minimum outgoing edge of F is e, and also F 's ID is larger than F's ID.The requirement for F 's ID being larger is only to break symmetry in case both fragments send/receive their Connect message at the same time.
Then, F merges with F as mentioned in rule 1, and the fragment will have F 's identity.Also, both fragments increase their rank to R + 1.Otherwise, v does not respond to the message until F 's rank increases.Once F increased its rank, it responds via an Accept message, fragments merge, and the new fragment will update its rank to R .
The key point here is that fragments at minimum rank are not kept waiting.Also, the intuition behind rule 2 is as follows.Imagine we have fragments F 1 , F 2 , ..., F k which all have the same rank and F i 's minimum outgoing edge goes to F i+1 for i ≤ k − 1.Now, it is either the case that F k 's minimum outgoing edge goes to a fragment with higher rank or it goes to F k .In either case, rule 2 allows the fragments F k−1 , F k−2 , . . . to update their identities in a cascading manner right after F k increased its rank.
When all fragments finish their merge at this phase they have increased their rank by at least one.Now, it is time for r to start a new phase.However, since communication is asynchronous we need a way to tell whether all fragments have finished.In order to do this, Done messages are convergecast in T .Nodes that were at minimum rank send up to their parent in T a Done message only after they increased their rank and received Done messages from all of their children in T .
As proved in Lemma 7, this algorithm uses Õ(n) messages.

Lemma 7 Having access to a spanning tree, FindMST uses O(n log 3 n/ log log n) messages and finds the MST w.h.p.
Proof All fragments start at rank zero.Before a phase begins, two broadcasts and convergecasts are performed to only allow fragments at minimum rank to proceed.This requires O(n) messages.In each phase, finding the minimum weight outgoing edges using FindMin takes O(n log 2 n/ log log n) over all fragments.Also, it takes O(n) for the fragments to update their identity since they just have to send the identity Algorithm 6 MST construction with Õ(n) messages.T is a spanning tree rooted at r .Fragment leaders at rank min Rank that have received the Proceed, min Rank message, call FindMin.Then, these fragments merge by sending Connect messages over their minimum outgoing edges.If there is no outgoing edge the fragment leader terminates the algorithm.

6:
Upon receipt of Proceed, min Rank , a node v does the following: 7: If it is a leaf in T at rank min Rank, sends up Done after increasing its rank.8: If it is a leaf in T with a rank higher than min Rank, it immediately sends up Done .9: If it is not a leaf in T , waits for Done from its children in T .Then, sends up the Done message after increasing its rank.10: r waits to receive Done from all of its children, and starts a new phase at step 3. 11: end procedure of the higher ranked fragment over their own fragment.As a result, each phase takes O(n log 2 n/ log log n) messages.
A fragment at rank R must contain at least two fragments with rank R −1; therefore, a fragment with rank R must have at least 2 R nodes.So, the rank of a fragment never exceeds log n.Also, each phase increases the minimum rank by at least one.Hence, there are at most log n phases.As a result, the message complexity is O(n log 3 n/ log log n).
From Lemma 7, Theorem 1 for minimum spanning trees follows.

Minimum spanning forest
In this section we provide an algorithm to find a minimum spanning forest when the input graph is disconnected.The algorithm still computes an MST if the graph is connected.Unlike the old algorithm in Sect.3, the algorithm presented here does not require a pre-selected leader.In other words, this algorithm can also be used to find the MST when a leader is not known ahead of time.
In order to simplify the description of the algorithm, we use the alternative way for counting events as mentioned in Sect.2.3.In fact, we assume that nodes send back acknowledgment messages when they receive a Low-degree message.Therefore, we will not need the T-neighbour data structure.
The main idea for our algorithm is to deal with components based on their sizes.A component is considered big if it has at least √ n log 3/2 n nodes, and small otherwise.With high probability, there is a star node inside all big components.However, a small component does not necessarily contain a star node.Moreover, small components cannot have a highdegree node since a node is high-degree if it has at least √ n log 3/2 n neighbours.Nodes, however, do not know the size of the component they belong to.To overcome this obstacle, we are going to have two types of nodes that run different algorithms as follows.
-Star nodes run the FindST-leader protocol.
-Low-degree nodes that have not been selected as a starnode (called low-degree non-star nodes) run the GHS algorithm.
Note that all nodes still send the initial Low-degree and Star messages.
Having nodes that run different algorithms in the same component will eventually result in a situation where a node is asked to participate in more that one protocol (initiated by different nodes).We call such an event a collision.We will later explain how we can handle these collisions so that a node can decide which protocol it should be a part of.The intuition behind running different protocols is as follows.If a component is small, all of its nodes are low-degree.Moreover, as mentioned before, a small component may not have a star node.Therefore, a small component should be able to compute the MST on its own.Since there is no highdegree node in a small component, the total number of edges in the component is O(n 3/2 log 3/2 n).Therefore, all nodes can run the GHS algorithm which uses messages proportional to the number of edges in the component, and find the MST directly.However, to ensure that the message complexity still remains o(m) we will not allow any high-degree node to participate in a GHS protocol.Therefore, the GHS protocol will complete successfully if and only if it is running in a component with no high-degree and no star node.
On the other hand, if a component is big it has a star node w.h.p.Therefore, in each big component, we can have a star node that acts as the leader of that component.Following the Find-ST protocol, the nodes of a big component will first find a spanning tree over the component's subgraph, and then compute the minimum spanning tree.
As for the message complexity, in case of small components the total of edges is bounded roughly by O(n) and the worst case is to have O( √ n) small components.(By adding to the number of components the total of the edges in such components will drop.)Therefore, using GHS on small components, which has message complexity proportional to the number of edges, is harmless.Moreover, if we are dealing with big components, the message complexity is bounded by our previous algorithm for MST.
In order to implement this idea, we need a set of rules to handle the collision between protocols.Here, we do not consider an exchange of messages between two nodes that are running the GHS protocol to be a collision.The GHS protocol can deal with these cases itself.
In this section, we assume that fragments which grow using the FindST-leader, each have a fragment ID.This ID is the node ID of the star node that initiated the protocol.In order to resolve collisions, there are three cases that we should consider.Imagine that node a sends a message regarding the protocol it is running to node b.The collision resolution rules are as follows: 1.When a is running the FindST-leader protocol and b is running the GHS protocol: in this case b will stop participating in the GHS protocol and will become a part of the FindST-leader protocol that a is running.2. When a is running GHS and b is running FindST-leader: b will never respond to the message; therefore, a's GHS protocol will never terminate.3. When a and b are both running the FindST-leader protocols with different fragment IDs : in this case if a's fragment ID is higher than b's fragment ID, it can proceed and take over node b.Otherwise, b tells a that a's fragment should stop running the protocol.(We will elaborate on this later.) Having this set of rules, we can always preserve the following invariant: Invariant 2: In a component with at least one star node, the star node with maximum ID (among all star nodes in that component) will become responsible for computing the MST.Description of the algorithm: First, all nodes follow the initialization protocol (Algorithm 1) as in the old algorithm.Then, each star node runs the FindST-Leader protocol to expand its fragment tree via expansion, search and sampling, and waiting where all of the messages exchanged during these three phases are labeled by the fragment ID, i.e., the ID of the star node that is the leader of the fragment.
All low-degree non-star nodes run the GHS protocol.Note that our assumption is that all nodes are awakened simultaneously.
If a component is composed of only low-degree non-star nodes, these nodes, which are all running the GHS protocol, will find the minimum spanning tree in that component directly.However, in order to obtain sublinear message complexity, we ensure that no high-degree node participates in a GHS protocol.To this end, when a high-degree node receives a message from a node running the GHS protocol, it will never respond to the message; hence, delaying the protocol forever.Note that existence of a high-degree node guarantees the existence of a star node w.h.p.Therefore, a star node will eventually find the MST in this component.
As mentioned before, in order to resolve collisions we require each fragment to have an ID.Initially, each star node belongs to a singleton fragment with an ID equal to that of the star node itself.Although initially non-star nodes do not belong to any fragment, we assume that they belong to a fragment with an ID of 0. This assignment allows fragments that are lead by a star node to take over the nodes that have not joined a fragment yet, using the third collision resolution rule (prioritizing higher fragment IDs).
It is worth mentioning that a node may be contacted by a node in a different fragment through initialization messages, messages for querying the degree, or expansion messages.We do not label initialization and degree-querying messages.Therefore, a node that receives these types of messages will not consider it a collision.This will not affect the analysis of the algorithm.
In order to enforce the collision resolution rules and to keep the message complexity sublinear, we use a new method for the expansion phase.Expand-MultiLeader (Algorithm 7) allows the fragments IDs to be updated without using a lot of messages.Expand-MultiLeader will replace the old Expand algorithm in Sect.3.

Implementation of Expand-Multileader
The expansion messages used in Expand-MultiLeader are accompanied by the fragment identities ( E x pand, I D ).Every node v keeps a variable v I D which is the ID of the fragment it belongs to at the moment.We also use v I D to refer to the whole fragment whose ID is equal to v I D. As mentioned before, for all non-star nodes v I D is initialized to 0. We define the reject list data structure as follows: Reject(v): Contains the list of edges over which v rejected an expansion message from another fragment for the first time.An edge is only added to this list if the reason of rejection is lower ID value of the other fragment.We emphasize that the edge is added only on the first occurrence of this event for each fragment.
When node x (currently in fragment x I D) receives an expansion message of E x pand, t I D from some node t in fragment t I D, the algorithm handles this message by comparing x I D and t I D. There are three cases: ).The leader of fragment t I D will eventually be notified that its fragment has contacted a fragment with higher ID when the Rejected-lower-ID,t I D message reaches the leader via a convergecast (line 28).This causes fragment t I D to stop running the FindST-Leader protocol (line 27).
Moreover, fragment x I D should take over the fragment t I D. However, since fragment x I D may not be running an expansion at the moment, node x has to remember to take over fragment t I D in the next expansion.For this, x adds the edge (x, t) to Reject(x) only if this is the first time that x sees an expansion message with identity t I D. The reason for the first time condition is that since all nodes of fragment t I D are already connected via a tree structure, having access to at least one of those tree nodes would suffice to allow fragment x I D to take over the whole fragment later.During the next expansion, x will forward the expansion messages over the edges in Reject(x), as well.
Notice that in this case x responds to an expansion message immediately even if it is participating in another expansion at the moment.This prevents fragments from waiting in a loop for each others' expansion to finish.

t I D > x I D:
In this case, x joins fragment t I D by updating its fragment identity from x I D to t I D and setting the first node from which it has received E x pand, t I D as its parent (line 8).
Notice that unlike the previous case, x, if participating in an expansion, first waits to hear the response to all expansion messages it has sent, then updates its children, and only after that it handles the E x pand, t I D message.This will ensure that the expansion messages are always forwarded over a tree structure when it is updating the ID of another fragment.Figure 1 shows that without this wait, the algorithm needs Ω(n 2 ) messages to finish.Imagine that in Fig. 1  does not wait for the last expansion to finish, it has to forward E x pand, s k−1 to nodes in C again.Besides, these are all low-degree nodes and will forward the message over all of their incident edges which requires Ω(n 3/2 ) messages.Repeating this for s k−2 to s 1 will result in Ω(n 2 ) messages.Now, there are two sub-cases for Case 2, based on whether or not x is part of some fragment upon receiving E x pand, t I D : 2.a If x is part of some other fragment X (line 9), fragment X should also become a part of fragment t I D. So, x forwards E x pand, t I D to all of its neighbours in X except the one that it has received the expansion message from.This will result in all neighbours of x to do the same recursively and all nodes in fragment X will update their fragment identity to t I D and become part of fragment t I D.Moreover, x forwards the expansion message over edges in Found(x) and Reject(x).2.b If x did not belong to any fragment before (line 11), the expansion message is handled just like the old Expand algorithm.Note that in this case Reject(x) is an empty list.If the node is high-degree and is not a star node (line 12), it waits to receive a star message, updates its Found O list, and then forwards the message to the edges in its Found lists.Else, if x is a low-degree or star node, it forwards the message to all of its neighbours in G.

t I D = x I D:
In this case, x and t are in the same fragment.If t is x's parent in fragment t I D, x forwards the expansion message to its children in the fragment, over the edges in Found lists and also over the edges in Reject(x).Otherwise, the sender of the message is not x's parent; therefore, x responds back Reject-sametree,t I D .
Once the fragment identities are compared and the expansion message is handled, x waits to hear back from all the nodes it has forwarded to.Then, x removes from Reject(x) and the Found lists any edges it has forwarded over.Afterwards, x updates its children to be all of the nodes that it has received Accept, t I D from (line 26) in this expansion.A node only sends up an Accept, t I D message in response to E x pand, t I D if either it is a leaf in the fragment tree or it has not received any Rejected-lower-ID,t I D from the nodes it has sent to in this expansion.If a node receives a Rejected-lower-ID,t I D , it sends up Rejected-lower-ID,t I D to its parent.As a result, if any node in the fragment is rejected because of its low ID, the leader will be notified and will stop running the FindST-Leader protocol (line 27).

Correctness
We argue about the correctness of the algorithm for the following two cases: -If a component has at least one star node: in this case, because of the way we defined the collision resolution rules, eventually, the star node with the highest ID among other possible star nodes in that component will take over all other fragments and proceeds by running the FindST-leader protocol.Therefore, the correctness of the algorithm follows by the correctness of the old algorithm.-If a component does not have a star node: In this case, w.h.p. the component is small.Therefore, all nodes are low-degree and will run the GHS protocol.So, the correctness of the algorithm follows from the correctness of the GHS algorithm.

Analysis
As before, the overall number of initialization messages is still bounded by O(n 3/2 log 3/2 n).Also, GHS spends asymptotically the same number of messages as the number of edges in the graph running the protocol.Since no high-degree node participates in a GHS, the overall number of messages used for the GHS protocol is bounded by O(n 3/2 log 3/2 n).Now, we show that the overall number of messages used for running FindST-Leader's is also bounded by O(n 3/2 log 3/2 n).
We define a successful expansion to be one that completes without any node receiving a Rejected-lower-ID message, which does not cause the leader to stop the FindST-Leader protocol.

Lemma 8 The number of successful expansions over all fragments is O(
In any fragment, each successful expansion is followed by one search and sampling and at most one wait where each of which these parts uses O(n log n) messages (proof in Lemma 6).Therefore, from Lemma 8 , the overall number of messages used in the algorithm apart from expansion is bounded by O(n 3/2 log 3/2 n).
Finally, we prove in the following claims that the overall number of messages used for expansion is bounded by the same amount.

Claim 1
The number of forwards over edges in the Found lists, over all nodes, is bounded by O(n 3/2 log 3/2 n).
Proof After an E x pand, I D is forwarded over an edge in the Found list, regardless of the result, that edge is removed from the Found list (line 24).Therefore, we only need to show that the overall number of edges added to Found lists of all nodes is bounded by O(n 3/2 log 3/2 n).An edge is added to the Found list of a node either because of a Low-degree message, a Star message, or an edge found by Find-Any in FindST-Leader.The first two types of messages are bounded by O(n 3/2 log 3/2 n).According to Lemma 8, there are Õ( √ n) successful expansions over all fragments and each of them is followed by at most O(log n) calls to Find-Any.Therefore, FindAny is responsible for at most Õ( √ n) edges in the Found lists and the claim follows.

Claim 2
The number of forwards over edges in the Reject lists, over all nodes, is bounded by O(n 3/2 / log 1/2 n).
Proof A node x that receives E x pand, t I D over edge e, and rejects it because t I D < x I D, may only add e to its Reject list if this is the first time it receives an expansion message with identity t I D. Therefore, a node x adds O( √ n/ log 1/2 n) (the initial number of fragments) edges to its Reject list over the course of the algorithm.Also, upon forwarding over some edge e in the Reject list, the node removes e from the list; therefore, the overall number of such forwards is O(n 3/2 / log 1/2 n).

Claim 3
The overall number of expansion messages forwarded, when a node receives an expansion message for the first time, is bounded by O(n 3/2 log 3/2 n) over all nodes.
Proof The first time that a node receives an Expand, ID message, if it is high-degree, it forwards only over its Found list, and if it is a low-degree node, it forwards to up to √ n log 3/2 n nodes.Using Claim 1, the claim follows.
Finally, the following claim will bound the number of forwards after the first time and allows us to bound the message complexity of the algorithm.

Claim 4
The number of forwards over branches of the old fragment in case that t I D > x I D (line 10), and also the number of forwards over branches of the current fragment in case that t I D = x I D (line 21) is bounded by O(n 3/2 log 1/2 n).
Proof Forwards over incident edges in the old fragment when t I D > x I D: Over the whole algorithm, O( √ n/ log 1/2 n) leaders may have grown their fragments to a tree of size O(n).Assume that each node had a set of incident edges (including the one to its parent) in each of the fragments it belonged to over the course of the algorithm.Let C be the collection of all of the incident edges of all nodes in these fragments.Note that in C, the same edge is repeated twice for each of its endpoints and could also be repeated up to O( √ n/ log 1/2 n) times as part of different fragments.Since there are O( √ n/ log 1/2 n) fragment trees and each of them has size at most n, size of C is the sum of the degrees of all nodes in these trees which is bounded by O(n 3/2 / log 1/2 n).
Consider node x that is part of a fragment X with identity x I D. When x receives E x pand, t I D it forwards this message to its neighbours in X except the one it has received the expansion message from (line 10).Whether the result of the forward is accept or reject, this is the last time that x forwards over a part of the fragment X , as a node in X .The reason is that right after this x joins fragment T and updates its children (line 26).Now, any future expansion message that x receives, will be forwarded as a part of fragment T (and not X ).Therefore, the overall number of expansion messages that nodes forward over their incident edges, immediately after updating their identity, could not exceed the size of C which is O(n 3/2 / log 1/2 n).Forwards to children when t I D = x I D: In this case, x only forwards the message if the sender is its parent in T .In fact, if x receives and forwards E x pand, t I D messages k times, it has to be the case that T has performed at least k − 1 successful expansions.Otherwise, T would have stopped before starting the k th expansion.Since the overall number of successful expansions is O( √ n log 1/2 n), the overall number of forwards over incident edges when t I D = x I D is O(n 3/2 log 1/2 n).
Putting together Claims 1 to 4, we obtain the following lemma.
Lemma 9 Expand-MultiLeader will result in no more than O(n 3/2 log 3/2 n) forwards of E x pand, I D messages over all fragments, before a spanning forest is constructed.
Therefore, we have the following theorem on building a minimum spanning forest in general input graphs.
Theorem 2 A minimum spanning forest can be constructed using O(n 3/2 log 3/2 n) messages with asynchronous communication.
A note on analysis: Here, we provide an example that shows that even when all star nodes are running the protocol in parallel, the time and the message complexity could still be as high as Θ(n 3/2 log 3/2 n).Since we do not assume that we know initially whether the graph G is a connected graph or not, our example here is a connected graph.Consider the graph in Fig. 2 where a complete graph K n/2 is connected to two path graphs P n/4 on the left and on the right, named P L and P R respectively.Assume that node IDs are v 1 > v 2 > . . .> v n .There have to be Θ( √ n log n) star nodes in P L and in K n/2 w.h.p.As a result, Θ(n 3/2 log 3/2 n) messages are guaranteed since the star nodes in K n/2 send initialization messages to all of their neighbours.
We show that time complexity is Θ(n 3/2 log 3/2 n), as well.Let the star nodes in P L be s 1 , s 2 , . . ., s k from left to right, where k = Θ( √ n log n).Let δ = 1 time step be the max delay.Suppose s k 's expansion messages go all the way to the right in one time step, and span K n/2 and P R .Now, s k−1 's expansion reaches to s k and updates the identity of all of the nodes on the right in O(n) time steps.Meanwhile, s k−2 is expanding to the right but according to the algorithm (line 6) s k−1 waits to finish its expansion before passing on the expansion of s k−2 , so s k−2 waits O(n) time steps.Similarly each s k−i (1 ≤ i ≤ k − 1) must wait O(n) time for s k−i+1 to finish its expansion for a cost of O(n).Moreover, each of these expansions is followed by a search and sampling that takes O(n log n) time; hence, time complexity of Θ(n 3/2 log 3/2 n).

Conclusion
We presented the first asynchronous algorithm for computing the MST in the CONGEST model with Õ(n 3/2 ) communication when nodes have initial knowledge of their neighbours' Algorithm 7 Leader initiates Expand by sending E x pand, t I D to all of its children, and over edges in its Found L list.Here, x is any node.
1: procedure Expand-MultiLeader(t I D) 2: When node x receives the message E x pand, t I D from node t over an edge e = (x, t): 3: if t I D < x I D then //x responds immediately 4: x sends back Rejected-lower-ID, t I D over e.

5:
If this is the first expansion message received from the fragment with identity t I D, it adds e to Reject(x).6: else //x waits to finish its current expansion before handling these cases 7: if t I D > x I D then 8: x updates its fragment identity to t I D and the first node that x receives E x pand, t I D from, becomes x's parent in T .//x joins fragment t I D 9: if x is part of some fragment X upon receiving the expansion message then 10: It forwards E x pand, t I D to its neighbours in X except the node x has received the expansion message from, to the nodes in Reject(x), and over edges in its Found lists.If the sender of E x pand, t I D is not x's parent in T , it sends back Reject-same-tree, t I D .Else, it only forwards E x pand, t I D to its children, nodes in Reject(x), and over edges in its Found lists.

22:
end if 23: x waits to hear back from all of the nodes it has forwarded to.24: x removes from the Found lists all the edges it has forwarded E x pand, t I D over.25: x removes from Reject(x) any edge is has forwarded over.26: x updates its children to be all nodes that it has received Accept, t I D from, in this Expand.

27:
If x is a leader, and receives a Rejected-lower-ID, t I D , it stops running the FindST-Leader.

28:
If x has received at least one Rejected-lower-ID, t I D , it sends Rejected-lower-ID, t I D to its parent.Else, x sends up Accept, t I D .29: end if 30: end procedure identities.This shows that the KT1 model is significantly more communication efficient than KT0 even in the asynchronous model.Open problems that are raised by these results are: (1) Does the asynchronous KT1 model require substantially more communication than the synchronous KT1 model?(2) Can we improve the time complexity of the algorithm while maintaining the message complexity?

1 .
t I D < x I D: Fragment x I D refuses to join fragment t I D, and signals fragment t I D to stop running the FindST-Leader protocol.To this end, x responds to t's expansion message by sending back Rejected-lower-ID, t I D (line 4

Fig. 1
Fig. 1 Example of quadratic message complexity

Fig. 2
Fig. 2 Example of worst case time and message complexity the nodes have IDs v 1 > v 2 > . . .> v n .Let C be the set of nodes {v n/2 , . . ., v n } and all nodes in C are low-degree and have √ n edges to other nodes in C.There have to be Θ( √ n log n) star nodes on the path from v 1 to v n/2 , w.h.p.Let us name these star nodes s 1 to s k from left to right, where k = Θ( √ n log n).Assume s k 's expansion message reaches to v n/2 and is forwarded to the nodes in C, but before any expansion message is answered, s k−1 's expansion message reaches to v n/2 .Therefore, if v n/2 11: else 12: if x is a high-degree node and x is not a star node then 13: If it has not received any Star message yet, it waits to receive one, and 14: then adds the corresponding edge to Found O (x). 15: It forwards E x pand, t I D message over edges in Found L (x) and Found O (x).