Distributed MIS in O(log log n) Awake Complexity

Maximal Independent Set (MIS) is one of the fundamental and most well-studied problems in distributed graph algorithms. Even after four decades of intensive research, the best known (randomized) MIS algorithms have O(log n) round complexity on general graphs [Luby, STOC 1986] (where n is the number of nodes), while the best known lower bound is [EQUATION] [Kuhn, Moscibroda, Wattenhofer, JACM 2016]. Breaking past the O(log n) round complexity upper bound or showing stronger lower bounds have been longstanding open problems. Energy is a premium resource in various settings such as battery-powered wireless networks and sensor networks. The bulk of the energy is used by nodes when they are awake, i.e., when they are sending, receiving, and even just listening for messages. On the other hand, when a node is sleeping, it does not perform any communication and thus spends very little energy. Several recent works have addressed the problem of designing energy-efficient distributed algorithms for various fundamental problems. These algorithms operate by minimizing the number of rounds in which any node is awake, also called the (worst-case) awake complexity. An intriguing open question is whether one can design a distributed MIS algorithm that has significantly smaller awake complexity compared to existing algorithms. In particular, the question of obtaining a distributed MIS algorithm with o(log n) awake complexity was left open in [Chatterjee, Gmyr, Pandurangan, PODC 2020]. Our main contribution is to show that MIS can be computed in awake complexity that is exponentially better compared to the best known round complexity of O(log n) and also bypassing its fundamental [EQUATION] round complexity lower bound exponentially. Specifically, we show that MIS can be computed by a randomized distributed (Monte Carlo) algorithm in O(log log n) awake complexity with high probability.1 However, this algorithm has a round complexity that is O(poly(n)). We then show how to drastically improve the round complexity at the cost of a slight increase in awake complexity by presenting a randomized distributed (Monte Carlo) algorithm for MIS that, with high probability computes an MIS in O((log log n) log* n) awake complexity and O((log3 n)(log log n) log* n) round complexity. Our algorithms work in the CONGEST model where messages of size O(log n) bits can be sent per edge per round.


Maximal Independent Set Problem
Computing the maximal independent set (MIS) is one of the fundamental and most wellstudied problems in distributed graph algorithms.Given a graph with n nodes, each node must (irrevocably) commit to being in a subset M ⊆ V (called the MIS) or not such that (i) every node is either in M or has a neighbor in M and (ii) no two nodes in M are adjacent to each other.
Because of the importance of MIS, distributed algorithms for MIS have been studied extensively for the last four decades mainly with a focus on improving the time complexity (i.e., the number of rounds).In 1986, Alon, Babai, and Itai [1] and Luby [38] presented a randomized distributed MIS algorithm that takes O(log n) rounds (n is the number of nodes in the graph) with high probability.Since these seminal results, there has been a lot of significant progress in recent years in designing progressively faster distributed MIS algorithms.For n-node graphs with maximum degree ∆, Ghaffari [24] presented a randomized MIS algorithm running in O(log ∆) + 2 O( √ log log n) rounds, improving over the algorithm of Barenboim, Elkin, Pettie and Schneider [6] that runs in O(log 2 ∆) + 2 O( √ log log n) rounds.We note that these two results assume the LOCAL model.The run time was further improved by Rozhon and Ghaffari [44,Corollary 3.2] to O(log ∆ + poly(log log n)) rounds, which is currently the best known bound for randomized algorithms in the LOCAL model.The currently best known randomized algorithm in the CONGEST model takes O(log ∆ log log n + poly(log log n)) rounds [25].Thus, the currently known best algorithms of MIS ( [44,25,24]) are dependent on ∆ (the maximum degree), and hence still take O(log n) rounds (even in the LOCAL model) for graphs with O(poly(n)) degree.As far as deterministic algorithms are concerned, the best known algorithms take O(poly(log n)) rounds in the LOCAL as well as CONGEST models [44,25].
There are faster distributed algorithms known for special classes of graphs such as trees [24,37] and Erdos-Renyi random graphs [35,24], but they still take Ω( log n/ log log n) rounds.There are also MIS algorithms that run faster on graphs with low arboricity, but they nevertheless take O(log n) rounds on high arboricity graphs [24,5].
While the above results make significant progress in the round complexity of the MIS problem for some specific graphs, however, in general graphs, the best known running time is still O(log n) (even for randomized algorithms and even in the LOCAL model).Furthermore, there is a fundamental lower bound of Ω min log ∆ log log ∆ , log n log log n rounds due to Kuhn, Moscibroda, and Wattenhofer [36] that also applies to randomized algorithms and holds even in the LOCAL model.Thus, for example, say, when ∆ = 2 Ω( √ log n log log n) , it follows that one cannot hope for algorithms faster than log n/ log log n rounds.Balliu, Brandt, Hirvonen, Olivetti, Rabie, and Suomela [3] showed that one cannot hope for algorithms that run within o(∆) + O(log * n) rounds for the regimes where ∆ ≪ log log n (for randomized algorithms) [3,Corollary 5] and ∆ ≪ log n (for deterministic algorithms) [3,Corollary 6].(See also results on an improved lower bound [4].)

Awake Complexity
Energy is a premium resource in various settings such as battery-powered wireless networks and sensor networks.The bulk of the energy is used by the nodes (devices) when they are "awake", i.e., when they are sending, receiving, and even just listening for messages.It is well-known that the energy used by a node when it is idle and just listening (waiting to hear from a neighbor) is only slightly smaller than the energy used in a transmitting or receiving state [47,21].On the other hand, the energy used in the "sleeping" state, i.e., when a node has switched off its communication devices and is not sending, receiving or listening, is significantly less than in the transmitting/receiving/idle (listening) state [47,21,33,45,46].A node may choose to enter and exit this sleeping mode in a judicious way to save energy during the course of an algorithm. 3here has been a lot of recent theoretical interest in designing energy-efficient distributed algorithms for various fundamental problems such as maximal independent set, maximal matching, coloring, broadcasting, spanning tree construction, breadth-first tree construction, etc. (see e.g., [15,16,26,7,11,12,18,2]).These algorithms operate by minimizing the number of rounds in which any node is awake, also called the awake complexity.An intriguing question is whether one can design distributed algorithms for various problems that have significantly smaller awake complexity compared to existing algorithms.However, this is challenging, since a node can only communicate with a neighboring node that is awake (note that a sleeping node does not send or receive messages and also messages sent to it are lost).As a result, coordinating (or scheduling) such communication in an efficient manner (without keeping any node awake for a long time) becomes non-trivial.

Model and Complexity Measures
Distributed Computing Model.We are given an anonymous distributed network of n nodes, modeled as an undirected graph G = (V, E).Each node hosts a processor with limited initial knowledge.We assume that each node has ports (each port having a unique port number); each incident edge is connected to one distinct port.We assume that each node knows a common value N , a polynomial upper bound on n.
Nodes are allowed to communicate through the edges of the graph G and it is assumed that communication is synchronous and occurs in rounds.In particular, we assume that each node knows the current round number (starting from round 0).In each round, each node can perform some local computation (which finishes in the same round) including accessing a private source of randomness, and can exchange messages of size O(log n) bits with each of its neighboring nodes.
This standard model of distributed computation is called the CONGEST model [43].We note that our algorithms also, obviously, apply to the LOCAL model, another standard model [43] where there is no restriction on the size of the messages sent per edge per round.Though the CONGEST and LOCAL models do not put any constraint on the computational power of the nodes, our algorithms perform only light-weight computations (each node processes only poly(log n) bits per round and takes computation time essentially linear in the number of bits processed).

Sleeping Model.
We assume the sleeping model [16], where a node can be in either of the two states -sleeping or awake.(At the beginning, we assume that all nodes are awake.)This is a simple generalization of the standard distributed computing model, where nodes are always assumed to be awake.In the sleeping model, each node decides to be either awake or asleep in each round (till it terminates), corresponding to whether the node can receive/send messages and perform computations in that round or not, respectively.That is, any node v can decide to sleep starting at any (specified) round of its choice.We assume that all nodes know the correct round number whenever they are awake.A node can wake up again later at any specified round and enter the awake state.We note that the model allows a node to cycle through the process of sleeping in some round and waking up at a later round as many times as it wants.To summarize, distributed computation in the sleeping model proceeds in synchronous rounds and each round consists of the following steps: (1) Each awake node can perform local computation.(2) Each awake node can send a message to its adjacent nodes.
(3) Each awake node can receive messages sent to it in this round (in the previous step) by other awake nodes.
In the sleeping model, let A v denote the number of awake rounds for a node v before it terminates (i.e., finishes the execution of the algorithm, locally).We define the (worst-case) awake complexity as max v∈V A v .For a randomized algorithm, A v will be a random variable and our goal is to obtain high probability bounds on the awake complexity.While the main goal is to reduce awake complexity, we also strive to minimize the round complexity, where both, sleeping and awake rounds, are counted.
This paper assumes the sleeping model in the CONGEST setting, which we call the SLEEPING-CONGEST model.
Several recent works (see Section 2) have designed distributed algorithms in the SLEEPING-CONGEST model for fundamental problems such as MIS, approximate matching and vertex cover, spanning tree, minimum spanning tree, coloring, and other problems [16,26,7,2,27].

Our Contributions
In light of the difficulty in breaking the o(log n) round barrier of MIS and the lower bound of Ω( log n/ log log n) rounds in the standard model (that applies even for LOCAL algorithms), as well as motivated by resource considerations discussed above, a fundamental question that we address in this paper is:

Can we design a distributed MIS algorithm with o(log n) awake complexity?
We answer the above question in the affirmative and actually show a much stronger bound.Our main contribution is that we show that MIS can be computed in (worst-case) awake complexity of O(log log n) rounds, bypassing the Ω( log n/ log log n) lower bound on the round complexity in an exponentially better fashion.Specifically, we present the following results.

1.
We present a randomized distributed (Monte Carlo) algorithm for MIS that with high probability computes an MIS and has O(log log n) awake complexity.This is the first distributed MIS algorithm with O(log log n) awake complexity.This algorithm has round complexity O(log 7 n log log n).Our bounds hold even in the CONGEST model where messages of O(log n) bits can be sent per edge per round.2. We show that we can reduce the round complexity at the cost of a slight increase in awake complexity by presenting a randomized MIS algorithm with O((log log n) log * n) awake complexity and O((log 3 n)(log log n) log * n) round complexity in the CONGEST model.[16], namely whether one can design MIS algorithms with (even) o(log n) (worst-case) awake complexity.We note that prior results [16,26] presented algorithms in the sleeping model with O(log n) awake complexity (see Section 2).Our results show that we can compute an MIS in an awake complexity that is exponentially better compared to the best known round complexity of O(log n).Since a node spends a significant amount of energy only in its awake rounds, our algorithms are highly energy-efficient compared to the existing algorithms.

Related Work and Comparison
Prior Work in the Sleeping Model for MIS.Chatterjee, Gmyr, and Pandurangan [16] posit the sleeping model and showed that MIS in general graphs can be solved in O(1) nodeaveraged awake complexity.Node-averaged awake complexity is measured by the average number of rounds a node is awake.They also defined worst-case awake complexity (used in this paper) which is the worst-case number of rounds a node is awake until it finishes the algorithm.The worst-case awake complexity of their MIS algorithm is O(log n), while the worst-case complexity (that includes all rounds, sleeping and awake) is O(log 3.41 n) rounds.
An important question left open in [16] is whether one can design an MIS algorithm with o(log n) worst-case awake complexity (even in the LOCAL model). 4haffari and Portmann [26] subsequently improved the round complexity bound of Chatterjee, Gmyr, and Pandurangan [16].They present a randomized MIS algorithm that has worst-case awake complexity of O(log n), round complexity of O(log n), while having O(1) node-averaged awake complexity (all bounds hold with high probability).They also present algorithms for (1 + ε) approximation of maximum matching and (2 + ε) approximation of minimum vertex cover with the same bounds on round complexity and node-averaged awake complexity.Hourani, Pandurangan, and Robinson [30] presented randomized MIS algorithms that have O(poly(log log n)) awake complexity for certain special classes of random graphs, including random geometric graphs (of arbitrary dimension).These algorithms work only in the LOCAL model as linear (in n) sized messages need to be sent per edge per round.This result is subsumed by the results of the current paper.
Subsequent to the publication of the arxiv version of our paper [20], Ghaffari and Portmann [27] presented a distributed MIS algorithm with the same worst-case awake complexity of O(log log n), but a better round complexity of round complexity O(log 2 n).They also present a second algorithm that has worse awake complexity of O((log log n) 2 ) but with a better round complexity of O(log n log log n log * n).
Other Works in the Sleeping Model.Barenboim and Maimon [7] showed that many problems, including broadcast, construction of a spanning tree, and leader election can be solved deterministically in O(log n) awake complexity in the sleeping model.They construct a spanning tree called Distributed Layered Tree (DLT) in O(log n) awake complexity deterministically.In this tree, broadcast and convergecast can be accomplished in O(1) awake rounds.They also showed that fundamental symmetry breaking problems such as MIS and (∆ + 1)-coloring can be solved deterministically in O(log ∆ + log * n) awake rounds in the LOCAL model, where ∆ is the maximum degree.(Note that, in general, this can take O(log n) awake rounds when ∆ = Ω(poly n).) Their algorithm only works in the LOCAL model (as opposed to the CONGEST model), as it needs large-sized (polynomial number of bits) messages to be sent over an edge.They also define the class of O-LOCAL problems (that includes MIS and coloring), where such a problem is one that can be solved sequentially according to some acyclic orientation of the edges of the input graph where the decision of a node depends on the decisions of the nodes in the subtree rooted at it.They showed that problems in this class admit a deterministic algorithm that runs in O(log ∆) awake time and O(∆ 2 ) round complexity.Maimon [39] presents trade-offs between awake and round complexity for O-LOCAL problems.
Augustine, Moses Jr., and Pandurangan [2] give an O(log n) awake complexity algorithm for the minimum spanning tree (MST) problem (in the CONGEST model).They use a spanning tree construction called the Labelled Distance Tree (LDT) which we also use in our algorithm.

Other Prior Works on Distributed Energy-Efficient Algorithms.
There has been significant research on energy-efficient distributed algorithms over the years -more than we can survey here -and we restrict ourselves to those that are most relevant.
A first, closely linked line of work is that of Chang, Kopelowitz, Pettie, Wang, and Zhan [15] on radio networks (inspired by earlier work on energy efficient algorithms in radio networks e.g., [42,31,32]).Unlike our paper (and the other papers mentioned in the previous paragraph) that use the SLEEPING-CONGEST model, this line of work assumes a model with additional communication restrictions that reflect the behavior of radio networks; we refer to it as the SLEEPING-RADIO model.More concretely, in this model, nodes can only broadcast messages; hence the same message is sent to all neighbors.Additionally, collisions can occur at a listening node if two neighboring nodes transmit simultaneously in the same round.There are a few variants depending on how collisions are handled.)In this model, they study the energy complexity measure, which is defined identically to (worst-case) awake complexity (i.e., both measures count only the rounds that a node is awake.
Energy-efficient algorithms for several problems such as broadcast, leader election, breadthfirst search, maximal matching, diameter and minimum-cut computation have been studied in the SLEEPING-RADIO model [15,11,12,18,19,14,13,10].An interesting open problem is whether our sub-logarithmic bounds on MIS awake complexity in the SLEEPING-CONGEST can be obtained in the SLEEPING-RADIO model.
King, Phillips, Saia, and Young [33] also study a similar model where nodes can be in two states: sleeping or awake (listening and/or sending).They present an energy-efficient algorithm in this model to solve a reliable broadcast problem.We also refer to the literature on resource competitive algorithms where there is limited energy available both to the algorithm and the (jamming) adversary (e.g., [29,28,8]).
Finally, Fraigniaud, Montealegre, Rapaport and Todinca [23] consider energy-efficiency from a slightly different angle.They do not assume nodes have a sleeping capability, but instead seek to minimize the maximum, taken over all nodes (or all edges), of the number of rounds in which these nodes (or edges) are active in sending messages (or transmitting messages).These two complexity measures are called respectively node-activation and edge-activation complexity, and the authors show that every Turing-computable problem can be solved with O(1) node-and edge-activation complexity in the CONGEST setting, at the cost of possibly exponential in n round complexity.In the LOCAL setting, the round complexity can be reduced to polynomial in n.

High-level Overview and Techniques
The best known distributed MIS algorithms ( [44,25,24]) in the traditional setting suffer from a log ∆ dependency in the round complexity, where ∆ is the maximum degree (see Section 1).Prior to this work, that was also the case in the sleeping model as well. 5Rather than improve these algorithms to remove this dependency (which appears very difficult), we improve a different algorithm: the well-known randomized greedy MIS algorithm [17,9,22], a variant of Luby's algorithm [38].The (sequential) randomized greedy MIS algorithm considers nodes (of some graph G = (V, E)) in random order and adds them to the output set unless one of their neighbors is already in it.If v 1 , . . ., v n is the random node ordering considered by the algorithm, then it is well-known that the output is the lexicographically first MIS (LFMIS) [17] with respect to that (random) ordering. 6Fischer and Noever [22] showed that the randomized greedy MIS can be implemented in the (traditional) distributed computing model in O(log n) rounds with high probability and also that this bound is tight.On the other hand, we show that randomized greedy MIS can be implemented in O(log log n) awake complexity.We build to this result in three steps.
Algorithm VT-MIS.First, we give a simple awake-efficient variant (Algorithm VT-MIS in Subsection 5.3) of the naive distributed implementation of the above (sequential) algorithm.Let I be an upper bound on the randomly chosen IDs.Then, the naive distributed implementation works as follows.In each round i ∈ [1, I], all nodes transmit whether they have joined the MIS or not to their neighbors.After which, the node with ID i (if it exists) enters the MIS if none of its neighbors already have.Clearly, the naive implementation has an excessive O(I) awake complexity.However, we can reduce the awake complexity exponentially, that is, to O(log I).
To reduce the awake complexity, we use a virtual binary tree structure (see Subsection 5.1), similar to that of [7], to carefully coordinate the communication between the nodes.More precisely, a (virtual) tree with t leaves (where the same tree is locally determined by each node using the parameter t = 2 ⌈log I⌉ ) tells each node in which round to be awake and communicate to its neighbors whether it is in the MIS or not.This virtual tree ensures that for any two neighboring nodes v, v ′ with id v < id v ′ , v and v ′ are both awake in some round i that satisfies id v < i ⩽ id v ′ .As a result, a node needs to be awake in only O(log I) well-chosen rounds (where log t = O(log I) is the depth of the virtual tree) to correctly implement randomized greedy MIS.This virtual tree coordination framework is reused in our third algorithm, Awake-MIS, and we believe it can be useful in general for designing awake-efficient algorithms.
Algorithm LDT-MIS.Second, we give a more awake-efficient variant (Algorithm LDT-MIS in Subsection 5.3) with an improved dependency on the ID upper bound I.This improved dependency comes into play when I is super-polynomial (or even worse) in the number of nodes n.Having good awake complexity in this particular scenario, which happens in Awake-MIS, is crucial for our O(log log n) awake complexity main result.
To obtain an improved dependency on I, we use a spanning tree structure, called a labeled distance tree (LDT), introduced in [2] (an improvement on a similar structure, introduced previously in [7]).Crucially, these trees can be used to broadcast and rank nodes (i.e, assign IDs in [1, n]) in O(1) awake complexity, while the LDT itself can be constructed in O(log n) awake complexity deterministically [2].Hence, one can first build a LDT and rank the nodes in O(log n) awake complexity.Since nodes are ranked arbitrarily, we can then have the root broadcast a uniformly random permutation of [1, n] in O((n log n)/ log I) consecutive broadcasts (recall that messages can be of size O(log I) = O(log n) bits, and thus can be sent in CONGEST).Consequently, nodes obtain new IDs in [1, n] that correspond to a uniformly random ordering.It remains only to run Algorithm VT-MIS, which now takes O(log n) awake complexity (due to the smaller IDs).
Algorithm Awake-MIS.For our main result, we use the previously described techniques as well as the following two key properties of the randomized greedy MIS algorithm.The first is the composability property.One can run the randomized greedy MIS algorithm on the first k > 0 nodes, then run that algorithm again but on the remaining nodes, that is, those which are not neighbors of the first computed MIS.The union of the two computed MIS's is the output of the randomized greedy MIS algorithm on G.The second is the residual sparsity property -stated formally in Lemma 2 in Subsection 4.3 -which shows that after processing the first k nodes in the random ordering, the degree of the residual graph (i.e., the subgraph induced by the rest of the nodes minus the neighbors of MIS nodes among the first k nodes) is reduced (essentially) to O(n/k) with high probability.
In Algorithm Awake-MIS (described in Section 6), nodes are partitioned into O(log 2 n) batches.More precisely, each node picks a pair (i, with some well-chosen probabilities, where ℓ = O(log n) and ∆ ′ = O(log n) are two parameters.To compute the MIS, we consider batches sequentially in phases (according to the lexicographical ordering).During the first "communication" round of each phase, nodes inform their neighbors whether they are already in the MIS or not.Moreover, just as in VT-MIS, nodes use a virtual binary tree structure to coordinate in which of these rounds to be awake or to sleep.(Hence, any given node is awake for at most O(log log n) communication rounds.)For the remaining rounds of some phase (i, j), nodes of batch (i, j) with no neighbors already in the MIS run Algorithm LDT-MIS to compute an MIS over the batch's nodes.Crucially, we show that the subgraph induced by the nodes running Algorithm LDT-MIS is shattered: that is, it consists only of O(log n)-sized components with high probability.Hence, nodes run LDT-MIS using O(log log n) awake complexity only.(Here, it is important that the second term of LDT-MIS, caused by the CONGEST bandwidth, adds up to O(log log n).) From this, it is easy to see that Algorithm Awake-MIS has O(log log n) awake complexity.
However, how do we ensure that the subgraph induced by the nodes running Algorithm LDT-MIS is shattered?First, we adjust the probabilities that nodes choose a given (batch) pair to ensure that the first 2∆ ′ batches contain with high probability half as many nodes as the next 2∆ ′ , and so on.Hence, by the residual sparsity property, the subgraph induced by the nodes (with no MIS neighbors) within any of these collections of 2∆ ′ batches has small O(log n) degree.(In fact, we must first use the composability property to show that the MIS computed throughout all previous phases is the output of randomized greedy MIS on the nodes in all previous batches.)Furthermore, nodes within any such collection independently and uniformly chose any of the 2∆ ′ batches.Hence, for each node, the expected number of neighbors (themselves with no MIS neighbors) is less than 1/2.In this case, a simple branching process argument -stated formally in Lemma 3 in Subsection 4.4 -shows that the subgraph induced by a given batch's nodes (with no MIS neighbors) is shattered.

4
Preliminaries: Notation and Randomized Techniques

Notation
For any subset For any node v, let N (v) denote the union of v and the set of its neighbors.Similarly, for any set of vertices ) denote the union of V ′ and the set of neighbors of any node in V ′ .For any two integers i and j, [i, j] is used to denote the set {i, . . ., j}.

Sequential Randomized Greedy MIS
The sequential randomized greedy MIS algorithm processes each node in a sequential but random order.Each node is added to the output set if it is not a neighbor of a node already in that set.It is well-known that this algorithm outputs the lexicographically first MIS (LFMIS), with respect to the random node ordering.Given a random node ordering v 1 , v 2 , . . ., v n , Lemma 2 -a slight generalization of Lemma 1 in [34] -shows that after the first t nodes (according to the node ordering) are processed by the sequential randomized greedy order MIS, the maximum degree of the subgraph induced by the remaining nodes among the first t ′ > t nodes (those which have not been added, nor are neighbors of an already added node) has decreased (almost) linearly in t.In fact, the lemma is more general.For example, it applies to distributed algorithms that compute the LFMIS over the subgraph induced by the first t nodes, according to the random node ordering mentioned above.
The lemma statement holds by a union bound (over j).
Let j ∈ [t + 1, t ′ ].We apply the principle of deferred decisions [40].More precisely, we first fix (the random choice of) which node is in position j -that is, v j .After which, we fix (the random choices of) which nodes are in position 1 to t sequentially -that is, v 1 to v t .For any integer i ∈ [1, t], let V i denote the first i (fixed) nodes and M i be the LFMIS over The sequence (d i ) i∈ [1,t] is decreasing.If d t ⩽ t ′ t ln(n/ε), then v j has degree at most

Simple Graph Shattering
Consider some n-node graph H with maximum degree ∆ and partition the nodes into 2∆ sets uniformly at random.More precisely, each node is in set U j , for any j ∈ [1, 2∆], with probability 1/(2∆).Then, a simple branching process argument implies that the corresponding induced subgraphs H[U j ] are "shattered": that is, they are composed of small O(log n)-sized connected components with high probability.
Proof.For any j ∈ [1, 2∆], consider some node v ∈ U j .(If |U j | = 0, the lemma statement obviously holds.)We assume, by the principle of deferred decisions, that v is the only initially revealed node of U j (and for all other nodes, we do not know whether they are in U j or not) and we find out which nodes are in U j through a BFS search (over H[U j ] only) starting at v. In more detail, the BFS queue initially consists only of v.In the first step, v is dequeued and for each unrevealed neighbor w ∈ N (v), we reveal whether w is in U j .For each such w ∈ N (v), if w ∈ U j then w is added to the queue.Once all neighbors have been revealed, the first step is done.Subsequent steps are executed similarly, but with that step's dequeued node, until the queue is empty.Importantly, the number of steps executed before the queue is empty is the size C(v) of the connected component of H[U j ] containing v.Moreover, it is a random variable that depends on each revealed node -that is, whether that revealed node is in U j or not.Finally, each unrevealed node w, once revealed, is in U j with probability at most 1 2∆ .The above (BFS search) randomized process is hard to analyze since a node dequeued in some step k might have neighbors that were revealed in previous steps.Instead, we consider an easier-to-analyze but related randomized process: BFS on a branching process.Let the number of nodes in the queue at the start of step k ⩾ 0 be denoted by A t .Initially, there is a single node in the queue -that is, A 0 = 1.Subsequently, for any where the random variables (Y k ) k⩾1 are independent and binomially distributed with parameters ∆, the total number of events, and 1 2∆ , the probability of each event being successful.Then, the size of this randomized process is By union bound over all connected components of H[U j ] (of which there are at most n), the lemma statement holds.◀ 5 Auxiliary Procedures
These sets have the following property (see Observation 5 below): for any integers k, k ′ ∈ [1, i] such that k < k ′ , there exists an integer r in both S k ([1, i]) and S k ′ ([1, i]) such that k < r ⩽ k ′ .Informally, we later use the sets S k ([1, i]) to decide when nodes with IDs in [1, i] are awake or asleep.The above property allows us to decide, for any two nodes, on a common round in which they are guaranteed to be awake simultaneously (and thus communicate with each other).Remember that in rounds in which nodes are not awake simultaneously, any message sent between two neighboring nodes is lost if any one of them is asleep.
Proof.Let the lowest common ancestor node in B * ([1, i]) of the leaves labeled k and k ′ be labeled with r ′ .Then, according to the definition of a communication set, r ′ is in both Moreover, note that the corresponding nodes in B( [1, i]) are the internal (lowest common ancestor) node labeled 2(r ′ − 1) and the leaf nodes labeled 2k − 1 and 2k ′ − 1.By the property of the in-order tree traversal, 2k

Labeled Distance Trees
For any ) is an oriented node labeled spanning tree over G[V ′ ] rooted at some node r ∈ V ′ .Each node's label is its distance to r in the spanning tree.(Note that the distance to r in the spanning tree may be much larger than that in G.) In the distributed implementation, the LDT satisfies the following properties: (i) all nodes in the tree know the ID of r, called the ID of the LDT, (ii) each node knows its depth in the tree (i.e., the hop-distance from itself to the root of the tree via tree edges), and (iii) each node knows the IDs of its parent and children, if any, in the LDT.If a given graph is disconnected, one can compute a disjoint set of such LDTs, one per connected component, which we refer to as a forest of labeled distance trees (FLDT).
Multiple distributed LDT construction algorithms (both randomized and deterministic) are presented in [2].We are interested in their two deterministic construction algorithms, which give different guarantees.The first lemma below captures the worst-case awake and round complexities of their first construction algorithm: Algorithm LDT-Construct-Awake. (Here, we use the improved version of Theorem 4 in [2] which can be found in the arXiv version.)On the other hand, the second lemma captures the properties of a distributed LDT construction algorithm (Algorithm LDT-Construct-Round) with faster round complexity but larger awake complexity; Corollary 1 of [2] states such an algorithm exists, and we give a full construction procedure in Appendix A.
▶ Lemma 6 (Theorem 4, [2]).For any connected V ′ ⊆ V of at most n ′ nodes with unique IDs in [ Next, we define two operations over a labeled distance tree.
▶ Definition 8.For any connected V ′ ⊆ V and an LDT spanning V ′ ⊆ V : The broadcast operation consists of sending the root's (input) message, denoted by m r , to all of the LDT's nodes.The ranking operation consists of having the nodes of V ′ compute a total ordering -more precisely, each node knows its rank in the ordering -as well as the size |V ′ |.
[2] provides a distributed algorithm for broadcasting over an LDT (see Observation 2 in [2]).A distributed algorithm for ranking over an LDT is presented in Appendix A. The properties of these two algorithms are captured by the following lemma.
▶ Lemma 9.For any LDT over at most n ′ nodes, where n ′ is known to all nodes, with unique IDs in [1, I], broadcast and ranking can be executed deterministically with O(1) awake complexity, O(n ′ ) round complexity and the size of the messages are O(|m r |) bits and O(log I) bits respectively.

Simple Awake-Efficient MIS Algorithms
We provide two simple deterministic distributed lexicographically first MIS (LFMIS) algorithms with good awake complexity.Note that it is important for our main result (see Section 6) that these algorithms compute the LFMIS rather than any arbitrary MIS.
The first algorithm (VT-MIS) runs in O(log I) awake time, where I is an upper bound on the nodes' IDs, and illustrates how to use the virtual binary tree technique (see Section 5.1).At a high-level, VT-MIS is an awake-efficient version of the naive distributed implementation of sequential greedy MIS.Recall that the naive algorithm runs in I rounds, and in the ith round, the node with ID i (if it exists) communicates with all neighbors to check if any neighbor with smaller ID is already in the MIS.If not, it joins the MIS.Although VT-MIS also has poor O(I) round complexity, its O(log I) awake complexity is exponentially smaller.
The second algorithm (LDT-MIS) runs in O(log n ′ ) awake time, where n ′ is the number of nodes.Of particular interest to us is when log n ′ may be much smaller than the length of the node's IDs.This naturally happens if LDT-MIS is run on a subgraph obtained after shattering a much larger graph (e.g., with exponentially more nodes n) whose nodes had unique IDs.At a high-level, we compute labeled distance trees, then the root computes n ′ and assigns uniformly random and small enough O(log n ′ )-length IDs to each node, all in O(log n ′ ) awake time.All nodes then compute the LFMIS using VT-MIS and these new IDs in O(log n ′ ) awake time.

VT-MIS: MIS in O(log I) awake time. We assume nodes are given unique IDs in [1, I],
for some known value I. Initially, each node starts in the undecided state and computes the virtual binary tree B * ([1, I]) locally (for the description, see Subsection 5.1).Then, nodes compute the LFMIS in I rounds.In round r, the node that has ID r as well as all nodes u for which r ∈ S idu ([1, I]) wake up -where S idu ([1, I]) is the communication set defined using B * ([1, I]), see Figure 2 for an example.Intuitively, the additional nodes wake up to communicate information on their state (i.e., undecided, in MIS or not in MIS), and the use of communication sets results in low awake time.All awake nodes send their state to all neighbors.Any awake undecided node that learns one of its neighbors is in the MIS sets its state to "not in MIS".If the node with ID r remains undecided despite the received messages, then it joins the MIS and sets its state to "in MIS".

▶ Lemma 10. VT-MIS computes the LFMIS with O(log I) awake complexity, O(I) round complexity and O(log I) bit messages.
Proof.We first prove the correctness.The main difference with the naive distributed implementation of sequential greedy MIS is that here, in any round r ∈ [1, I], not all nodes may be awake and thus the node v with ID r may be unaware that one of its neighbors is already in the MIS.However, by Observation 5, there exists for any node u with ID r ′ < r, a round r * such that r ′ < r * ⩽ r and both u and v are awake in r * .Since u can only decide to join the MIS in round r ′ by the algorithm's definition, u successfully communicates whether it joins the MIS or not to v in round r * .It follows that VT-MIS implements sequential greedy MIS, and thus correctly computes an LFMIS.
As for the awake complexity, note that by Observation 4, each communication set of B * ([1, I]) is of size O(log I).Since each node u is only awake in rounds r ∈ S idu ([1, I]), each node is awake for O(log I) rounds.◀

LDT-MIS: MIS in O(log n ′
) awake time.We assume that each node knows the value n ′ , an upper bound on the number of nodes of the connected subgraph to which the node belongs.We also assume that the (at most) n ′ nodes are given unique IDs in [1, I], for some known value I (where I may be exponentially larger than n ′ ), and that messages can contain up to O(log I) bits.First, all nodes participate in the construction of an LDT.
(The correctness is guaranteed by the fact that all nodes know the same bound n ′ .)Second, all nodes participate in an operation to (i) compute the exact number of nodes n ′′ in the LDT, and (ii) allow each node to know its rank in a given total ordering of the nodes.(a) S3( [1,6]) consists of the circle nodes' labels.(b) S5( [1,6]) consists of the circle nodes' labels.

Figure 2
For the example, consider I = 6 and two nodes u, v with IDs 3 and 5 respectively.Node u is awake in rounds 3, 4 and 5 and v is awake in rounds 5 and 6 (but not in round 7, since there are only I rounds).It can be seen that u communicates whether it has joined the MIS to v in round 5.
Third, the root of the LDT locally computes a uniformly random permutation of [1, n ′′ ] and broadcasts it in O((n ′ log n ′ )/ log I) consecutive broadcasts over the LDT.(In each broadcast, we can transmit O(log I) bits of the total O(n ′′ log n ′′ ) bits.Once all of these bits have been transmitted, "null" messages are sent for the remaining broadcasts, if any.)Each node uses its previously computed rank to retrieve its ID in the permutation.Finally, all nodes run VT-MIS using these smaller IDs.

complexity and O(log I) bit messages.
Proof.First, note that LDT-MIS implements (sequential) randomized greedy MIS.Indeed, constructing the LDT, computing n ′ and sending down smaller IDs is simply equivalent to computing a uniformly random node ordering on the n ′ nodes.After which, VT-MIS implements sequential greedy MIS with respect to that order by Lemma 10. ◀ By replacing the awake efficient LDT construction (Algorithm LDT-Construct-Awake) with the round efficient one (Algorithm LDT-Construct-Round, whose properties are described in Lemma 7), we obtain a round efficient version of LDT-MIS, which we call LDT-MIS-ROUND.Its properties -a faster round complexity but larger awake complexity than LDT-MIS -are formally stated in the following corollary.

▶ Corollary 12. LDT-MIS-ROUND computes an LFMIS with respect to some uniformly random node ordering with O((log n
at random (but not uniformly) which decides what batch the node falls in-that batch is denoted by B i,j .Batches are ordered via lexicographical order (of the pairs).Next, we describe precisely how nodes choose a batch.Each node chooses i ∈ [1, ℓ − 1] with probability (10 • 2 i log n)/n and i = ℓ with the remaining probability.Moreover, each node chooses j ∈ [1, 2∆ ′ ] uniformly at random, that is, with probability 1/(2∆ ′ ).
After the batches have been decided, there are 2ℓ∆ ′ = O(log 2 n) phases.(The number of rounds per phase is determined in the analysis, allowing some nodes to sleep through the phase.)In each phase (i, j) ∈ [1, ℓ] × [1, 2∆ ′ ], the first communication round is used to update which of the batch's nodes have a neighbor in the MIS.(Let g : be the natural bijection that preserves lexicographic order.)In more detail, node v ∈ V is awake if g(i, j) ∈ S g(p(v)) ([1, 2ℓ∆ ′ ]), and is asleep otherwise-see Subsection 5.1 for the formal definition of the communication set S g(p(v)) ([1, 2ℓ∆ ′ ]) and Subsection 5.3 for an example.Awake nodes send their state to their neighbors.At the end of the round, awake nodes that received a inM IS message from a neighboring node set their state to notInM IS (thus becoming decided).After which, the remaining rounds are used by all undecided batch nodes (i.e., with p(v) = (i, j) and in the "undecided" state) to execute LDT-MIS described in Subsection 5.3.(In the analysis, we show that w.h.p., the remaining rounds are sufficient for this algorithm to terminate.)Analysis of Awake-MIS.Next, we show correctness and complexity bounds of Awake-MIS.Note that we assume nodes know n exactly (or at least some constant factor approximation) in the above description and below analysis for clarity.This assumption can be removed through straightforward changes, so that nodes can use instead a polynomial upper bound N on n.

▶ Theorem 13. MIS can be solved (w.h.p.) in O(log log n) awake complexity and O(log 7 n log log n) round complexity in CONGEST.
Proof.Let us start with some notations.For any (i, j) ∈ [1, ℓ] × [1, 2∆ ′ ], denote by V i,j the union of all batches up to, and including, batch (i, j), and for any i ∈ [1, ℓ], let V i = V i,2∆ ′ .Then, we bound the size of V i for any i ∈ [1, ℓ].Recall that each node is  We show by induction that by the end of phase (i, , the algorithm has computed the LFMIS over G[V i,j ] with respect to a uniformly random ordering of V i,j and with probability at least 1 − 1/n.Consider the base case.During the first phase, different connected components Given the upper bound on V 1 shown above, these components are of size O(log n) with probability at least 1 − 1/n 3 .By setting the number of rounds within the first phase accordinglyto O(log 5 n log log n) rounds -all LDT-MIS executions terminate.Thus, by Lemma 11, the output of LDT-MIS for each component C h is an LFMIS with respect to a uniformly random node ordering (of C h ), which we denote M h .Note that M = k h=1 M h is exactly the set of nodes with state inM IS when the first phase ends.Clearly, M is an MIS since two nodes from different connected components are non-adjacent.It remains to show that M is also a LFMIS with respect to a uniformly random ordering of V 1,1 .Consider the following node ordering.First, pick some node w uniformly at random among all |V 1,1 | nodes and then choose the first node of the ordering uniformly at random among all nodes of the component w belongs to.Next, pick some node w ′ uniformly at random among the remaining |V 1,1 | − 1 nodes and then choose the second node of the ordering uniformly at random among all nodes in the component w ′ belongs to (excluding the first node in the ordering).Repeat this process until all nodes in V 1,1 have been ordered.It is straightforward to show that this node ordering is a uniformly random ordering of V 1,1 .Moreover, two nodes u, v from different components are not connected in G[V 1,1 ] and thus whether u is ordered before v (or inversely) does not influence the resulting LFMIS over ] with respect to that uniformly random ordering of V 1,1 , concluding the base case.Now, consider some phase (i, j) ̸ = (1, 1) and assume that the induction hypothesis holds for the (lexicographically) previous phase (i ′ , j ′ ).By the induction hypothesis, the algorithm has computed the LFMIS M ′ over G[V i ′ ,j ′ ] with respect to some uniformly random order of V i ′ ,j ′ by the end of phase (i ′ , j ′ ).Since V i ′ ,j ′ = V i,j \ B i,j , the induction step follows if we show that the algorithm computes a LFMIS over G[B * i,j ] with respect to a uniformly random ordering of B * i,j , where B * i,j are the nodes of B i,j with no neighbors in M ′ .To do so, we first note that nodes know whether they are in B * i,j or not by the end of the communication round of phase (i, j).This can be shown using properties of the communication sets (as in the proof of Lemma 10).In the remainder of the phase, different connected components ] run independent LDT-MIS executions.If i = 1, then just as in the base case, these connected components have size O(log n) with probability at least 1 − 1/n 3 , and thus O(log 5 n log log n) rounds are sufficient for the LDT-MIS executions to terminate with probability at least 1 − 1/n 3 .Otherwise, if i > 1, let M i−1 be the MIS computed by the end of phase (i − 1, 2∆ ′ ).Due to the induction hypothesis, we can apply Lemma 2 and thus G[V i \ N (M i−1 )] has maximum degree upper bounded by |Vi| |Vi−1| ln(n 4 ) with probability at least 1 − 1/n 3 .Using the above bounds on V i and V i−1 , this is at most 9 ln(n 4 ).By choosing ∆ ′ = 9 ln(n 4 ) (and using the principle of deferred decisions), Lemma 3 implies that ] also consists of small O(log n)-sized connected components with probability at least 1−1/n 3 .And thus, O(log 5 n log log n) rounds are sufficient for the LDT-MIS executions to terminate with probability at least 1 − 1/n 3 .Next, we point out that one can show, using an argument similar to that of the base case, that the union M ′′ of the computed MIS-which is exactly the set of nodes whose state becomes inM IS during phase (i, j)-is a LFMIS with respect to a uniformly random order of B * i,j .Moreover, it is straightforward to extend this ordering of B * i,j to a uniformly random order of V i,j , as long as all nodes in B i,j are ordered after those in V i ′ ,j ′ .(In which case, no matter how some node z ∈ B i,j \ B * i,j is ordered, z is not in the LFMIS.)Consequently, when phase (i, j) ends, the set M ′ ∪ M ′′ is a LFMIS over G[V i,j ] with respect to some uniformly random order of V i,j with probability at least 1 − 1/n 2 and the induction step follows.(Note that the error probability of all induction steps added together is at most 1/n.) To conclude, we note that all communication is done through O(log n) bit messages, and in particular the communication within the LDT-MIS calls.Next, we upper bound the awake complexity.Each node v ∈ V is awake for at most O(log log n) communication rounds over all O(log 2 n) phases.Moreover, within v's chosen phase p(v), recall that the subgraph induced by the awake nodes is composed of O(log n)-sized connected components with high probability.Then, by Lemma 11, v is awake for at most O(log log n + ((log n) log log n)/ log n) = O(log log n) rounds (w.h.p.) during the LDT-MIS execution.Finally, a simple modification of LDT-MIS limiting the number of rounds a node can be awake to O(log log n) (where the precise value can be obtained from the analysis and the desired error probability) implies any failure affects correctness rather than the awake complexity.Therefore, the awake complexity of Awake-MIS is (deterministically) upper bounded by O(log log n).As for the round complexity, the above analysis implies that each phase takes O(log 5 n log log n) rounds.Hence, the algorithm's round complexity is O(log 7 n log log n).◀ By using the more round efficient LDT-MIS-ROUND (see Corollary 12) instead of LDT-MIS, an MIS can be computed with a better round complexity, but at the cost of a small O(log * n) overhead to the awake complexity.

Conclusion
In this paper, we show that the fundamental MIS problem on general graphs can be solved in O(log log n) awake complexity, i.e., the worst-case number of awake (non-sleeping) rounds taken by all nodes is O(log log n).This is the first such result that we are aware of where we can obtain even a o(log n) bound on the awake complexity for MIS.A long-standing open question is whether a similar bound (i.e., o(log n)) can be shown for the round complexity.Several open problems arise from our work.An important one is determining whether one can improve the awake complexity bound of O(log log n), or showing that is optimal by showing a lower bound.Another one is whether one can obtain an O(log log n) awake complexity MIS algorithm that has O(log n) round complexity.More generally, can one obtain good trade-offs between awake and round complexity of MIS?
Finally, it would be useful to design algorithms for other symmetry breaking problems such as maximal matching, coloring, etc., that have better awake complexity compared to the traditional round complexity.

A Labeled Distance Tree (LDT) and a Faster Round Complexity
In this section, we describe a useful data structure called a labeled distance tree (LDT), introduced in [2].We first describe the structure and relevant procedures needed to construct it in Section A.1.Subsequently, we give an informal description on how one might construct an LDT in Section A.2, i.e., we describe algorithm LDT-Construct-Round.Finally, in Section A.3 we give a few useful procedures that can be run once an LDT is constructed.

A.1 LDT Description and Relevant Procedures
For a given graph, a labeled distance tree (LDT) is spanning tree of that graph such that (i) all nodes in the tree know the ID of the root of the tree, called the ID of the LDT, (ii) each node knows its depth in the tree (i.e., the hop-distance from itself to the root of the tree via tree edges), and (iii) each node knows the IDs of its parent and children, if any, in the tree.If a given graph can be partitioned into a disjoint set of such LDTs, we refer to that graph as a forest of labeled distance trees (FLDT).
In order to construct an LDT over a given graph, we start from a situation where all nodes are considered LDTs of their own (i.e., the overall graph is an FLDT) and we successively merge LDTs together in phases until we arrive at a situation where all nodes in the graph belong to the same LDT.In the course of this process, we utilize several simple procedures (e.g., upcast, broadcast) that are modified to be efficient in awake complexity.We first describe those procedures before explaining how to construct an LDT in the next section.
For the procedures described below, it is assumed that the initial graph has already been divided into an FLDT where each node u knows the ID of the root, root, of the LDT it belongs to, u's distance to root within the LDT, as well as u's parent and children, if any, in the LDT it belongs to.First of all, we define a transmission schedule that is used in each of the procedures and will be directly utilized in the algorithms.Then we describe the procedures themselves.
Transmission schedule of nodes in an LDT.Consider an LDT rooted at the node root and a node u in that tree at distance i from the root.Let n be an upper bound on the number of nodes in the LDT.We describe a transmission schedule and an upper bound on the number of nodes in the LDT n.The transmission schedule T ransmission − Schedule(root, u, n) assigns a set of rounds to u to be awake in from a block of 2n + 1 possible rounds.For ease of explanation, we assign names to each of these rounds as well.For all non-root nodes u, the set of rounds that T ransmission − Schedule(root, u) assigns to u includes rounds i, i + 1, n + 1, 2n − i + 1, and 2n − i + 2 with corresponding names Down-Receive, Down-Send, Side-Send-Receive, Up-Receive, and Up-Send, respectively.T ransmission − Schedule(root, root, n) assigns to root the set containing only the rounds 1, n + 1, and 2n + 1 with names Down-Send, Side-Send-Receive, and Up-Receive, respectively. 7his transmission schedule can be used to modify typical procedures on a tree (e.g., upcast, broadcast) to procedures that have small awake complexity.During one instance of T ransmission − Schedule(root, u, n), by having each node wake up in a carefully selected non-empty subset of its at most 5 named rounds, we guarantee that all nodes in the LDT have woken up at least once and that information is propagated in the correct "direction" in the LDT as needed.We name useful procedures to construct an LDT and give guarantees on these procedures below.
Broadcasting a message in an LDT.Procedure Fragment-Broadcast(n), run by all nodes in a given LDT, allows the root node of that LDT to transmit a given message to all nodes in the LDT in O(1) awake complexity and O(n) round complexity.
Upcasting the minimum value in an LDT.Procedure Upcast-Min(n), run by all nodes in a given LDT, allows the smallest value among all values by the nodes of that LDT, to be propagated to the root of the tree in O(1) awake complexity and O(n) round complexity.
Transmitting a message between nodes of adjacent LDTs.Procedure Transmit-Adjacent(n), run by all nodes in an LDT, allows each node in the LDT to transfer a message, if any, to neighboring nodes belonging to other LDTs in O(1) awake complexity and O(n) round complexity.

A.2 Construction of an LDT
In this we describe how to deterministically construct an LDT in algorithm LDT-Construct-Round.We note that the original process [2] was designed to construct a minimum spanning tree while simultaneously constructing an LDT over the original graph.We describe a simplified version of the process that focuses on just constructing an LDT over the original graph.
Algorithm.At a high level, we first spend a single round so that each node is aware of the IDs of each of its neighbors and each edge can be assigned a unique ID known to both endpoints (the ID can be the composition of the edge's endpoints' IDs in increasing order).Subsequently, we run a version of the classical GHS algorithm, modified to ensure that the awake complexity of nodes is small and to also ensure that at the beginning of each phase of the algorithm, an FLDT is maintained.Initially, each node is considered to be its own LDT (and so the overall graph is an FLDT) and we describe how to merge LDTs together in O(log n) phases until all nodes in the graph belong to the same LDT.
In each phase, we perform the following sequence of steps in three stages.Recall that at the beginning of the phase, we have a forest of LDTs.We explain each phase of the algorithm from a bird's eye perspective with the details of what each LDT does as bullet points.Fragment-Broadcast(n) a constant number of times, the nodes in both of these LDTs identify that they belong to such LDTs in the connected component and can identify if they are in the LDT that forms the root of the tree in H. b.Subsequently, each remaining LDT in C i identifies its outgoing edge as leading to its parent in the spanning tree T i .This does not require communication between nodes as this is just local computation performed by the roots of the LDTs.c.Now, a Cole-Vishkin style coloring algorithm to 6-color the LDTs of each T i (i.e., each LDT in T i is colored a single color in [1,6], known to all nodes within that LDT) can be easily simulated.Each round of the O(log * n) algorithm consists of some local computation and then having each node communicate with each of its children.One round of local computation can be simulated by the roots of each of the LDTs in one round.One round of communication can be simulated in O( 1) awake complexity and O(n) round complexity via a constant number of uses of the procedures Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n). d.Previously, a spanning tree was constructed over each connected component of the supergraph H and each of the LDTs, constituting nodes in this spanning tree, were colored in via a 6-coloring.Now, in order to obtain a maximal matching on these components, the following process is run for 6 phases.We maintain the invariant that at the beginning of each phase, each LDT (all nodes belonging to that LDT) knows if it is matched or not and for every inter-LDT edge, both nodes of that edge know the matching status of both LDTs.In phase i, each unmatched LDT of color i chooses one of its unmatched children, if any, arbitrarily (say by performing procedure Upcast-Min(n) to return the smallest inter-LDT edge among edges leading to unmatched children).Subsequently the LDT informs the child of being matched to it and informs all adjacent LDTs that it is no longer unmatched.Each phase can be simulated through a constant number of uses of Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n). e.Each LDT that remains unmatched in T i (except the root LDT of T i ) now informs its parent LDT in T i that the inter-LDT edge between them also belongs to F .This can be done through a constant number of uses of Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n). f.Finally, if the parent LDT in T i is unmatched, it chooses one of its children in T i and informs that child (really the node within that LDT at the other end of the edge) that the inter-LDT edge between them is also in F .This can be done through a constant number of uses of Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n).

Stage 3.
At the end of the previous stage, a forest F of small-depth trees SDT i was formed.(These trees consist of the LDTs and any edges added to F .While all nodes within an LDT may not be aware of these edges in F , the endpoints (nodes within LDTs) of every such edge are aware of it.)The final part of each phase consists of merging together the LDTs in each small-depth tree SDT i into one large LDT.Care must be taken to ensure that each node of a resulting merged LDT has the correct ID for that LDT (i.e., the ID of the root of the LDT) and furthermore, each node in the merged LDT maintains the correct distance-from-root value.Additionally, each node may need to be re-oriented, i.e., each node may need to update information about who its parent and children in the LDT are.
a. Notice that every tree SDT i in F is of diameter at most 4 (i.e., any two LDTs in the same tree SDT i in F are at most distance 4 apart).9First, for each SDT i , we choose its constituent LDT with the smallest ID to be the core of the merged LDT, around which we re-orient the nodes of the other LDTs.It is easy to see that, for any tree SDT i in F , the smallest LDT ID in SDT i can be progagated to every LDT in SDT i through a constant number of instances of Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n). b.Now, all nodes within a given tree SDT i in F know the ID that will become the ID of the final merged LDT.Let LDT L have this ID.Consider an LDT L ′ that is adjacent to the LDT L in SDT i .The nodes in L ′ must re-align themselves and update their distance-to-root values in the merged LDT consisting of L and L ′ .Suppose the edge (u, v) is the inter-LDT edge between L and L ′ such that u ∈ L and v ∈ L ′ .Now, the nodes in L ′ update their values by utilizing two instances of a transmission schedule parameterized by n.Recall that v is aware of u's distance-to-root and so knows its own distance-to-root.In the first instance of the transmission schedule the nodes in the branch from v to the root of L ′ update their distance-to-root values and re-orient themselves using the Up-Send and Up-Receive rounds.In the second instance, the remaining nodes in L ′ update their values in the Down-Send and Down-Receive rounds and can re-orient themselves.This process allows all LDTs at distance 1 from LDT L in SDT i to update their values.By running this process 4 times, we guarantee that all LDTs up to and including distance 4 from LDT L in SDT i can update their values and re-orient themselves.
Analysis.We briefly analyze the algorithm above to give the intuition of correctness and complexities of the construction.We note that the full analysis was already given in [2].The correctness comes from the fact that we maintain a forest of LDTs at the beginning of each phase.The construction of the forest F in the final part of each phase and the merging of LDTs in F guarantees that a constant number of the LDTs are merged together in each phase.To see this, notice that, in every phase, every tree SDT i in F consists of at least two LDTs, resulting in at least a constant fraction of the LDTs "disappearing" in the phase (but really just being merged into one another). 10As a result, after O(log n) phases, all LDTs are merged together into one single LDT.
Regarding the awake complexity and round complexity, we see that the first and third stage each use a constant number of transmission schedules parameterized by n, as well as a constant number of calls to Upcast-Min(n), Fragment-Broadcast(n), and Transmit-Adjacent(n). Totally, all of these contribute O(1) awake complexity and O(n) round complexity.However, in the second stage, the process of simulating the Cole-Vishkin style coloring takes a total of O(log * n) awake complexity and O(n log * n) round complexity.Since, there are a total of O(log n) phases, we see that the total awake complexity is O((log n) log * n) and the total round complexity is O(n(log n) log * n).
The following lemma captures the above guarantees.

A.3 Useful Procedures
Once an LDT is constructed, we can then leverage it to run fast awake complexity procedures.
In particular, we describe the operations of broadcast and ranking from Definition 8.
Broadcasting in an LDT.We describe Procedure LDT-Broadcast, run by each node v of an LDT, which takes the message msg r of the root of the LDT as input and results in all nodes of the LDT receiving msg r .Consider an LDT of size at most n ′ , where the root of the LDT wants to broadcast a message of size at most m r bits to all nodes in the LDT.Assume that messages of size O(m r ) can be sent over each edge.Broadcast can be performed by having all nodes in the LDT participate in one instance of a transmission schedule parameterized by n ′ , where each node receives this message in their Down-Receive round and propagates the message to its children in its Down-Send round.This takes O(1) awake complexity and O(n ′ ) round complexity.
Ranking in an LDT.We describe Procedure LDT-Ranking, run by each node v of an LDT, which calculates v's rank in some overall total order of the nodes of the LDT, and additionally allows v to learn the size of the LDT.(The given total ordering may be intuitively understood as the in-order ranking of a binary tree, when extended to an n-ary tree.For an n-ary tree, one possible generalization, that we use here, would be to recursively do the following: visit the leftmost subtree, then the root, then the remaining subtrees in some arbitrary order.)Consider an LDT of size at most n ′ .The procedure consists of 10 Notice that each tree SDT i in F is formed from the LDTs in H as well as edges added to F in stage two.In stage two, every LDT in each tree T i is either unmatched or matched with another LDT.Each LDT that is matched ensures that the small-depth tree its belongs to comprises of at least two LDTs.
For each LDT that remained unmatched, it is still guaranteed to merge with another LDT because it will either add an edge to its parent in T i to F (if it is not the root of T i ) or else add an edge to one of its children in T i to F (if it is the root of T i ).
two instances of a transmission schedule parameterized by n ′ .In the first instance of a transmission schedule, each node listens in its Up-Receive round for the number of nodes in each of its children's subtrees and remembers these values, and then in its Up-Send round it sends the sum of these values plus one to its parent.At the end of this instance of a transmission schedule, the root will know the total number of nodes in the tree n ′′ .In the second instance of the transmission schedule, each node v receives in its Down-Receive round the value of n ′′ and a value from its parent, which v uses to calculate its rank in a manner described below, and subsequently sends down the value of n ′′ and unique values to each of v's children in its Down-Send round.For a given node v that receives a value x and has k children c 1 , c 2 , . . ., c k with corresponding number of nodes in their subtrees n 1 , n 2 , . . ., n k , do the following.We assume that the root of the LDT "receives" x = 0.The guarantees on constructing the LDT as well as the procedures described above are reflected in the following lemma.
▶ Lemma 16.For any connected V ′ ⊆ V of at most n ′ nodes, where n ′ is known to all nodes, with unique IDs in [1, I]:

▶ Lemma 7 .
1, I], where n ′ and I are known to all nodes, LDT-Construct-Awake deterministically constructs an LDT over G[V ′ ] with O(log n ′ ) awake complexity, O(n ′ (log n ′ ) log 4 I) round complexity and O(log I) bit messages.For any connected V ′ ⊆ V of at most n ′ nodes, where n ′ is known to all nodes, with unique IDs in [1, I], LDT-Construct-Round deterministically constructs an LDT over G[V ′ ] with O((log n ′ ) log * I) awake complexity, O(n ′ (log n ′ ) log * I) round complexity and O(log I) bit messages.
Now we prove the rest of the lemma statement.Constructing the LDT takes O(log n ′ ) awake complexity, O(n ′ (log n ′ ) log 4 I) round complexity and O(log I) bit messages (by Lemma 6).The ranking operation takes O(1) awake complexity, O(n ′ ) round complexity, and O(log I) bit messages (by Lemma 9).The O((n ′ log n ′ )/ log I) consecutive broadcasts used to transmit the permutation chosen by the root (at most O(n ′ log n ′ ) bits), via messages of O(log I) bits, take altogether O((n ′ log n ′ )/ log I) awake complexity and O(((n ′ ) 2 log n ′ )/ log I) round complexity (by Lemma 9).Finally, computing the LFMIS (via VT-MIS) with respect to the new node ordering (from the new IDs in [1, n ′ ]) takes O(log n ′ ) awake complexity, O(n ′ ) round complexity, and O(log n ′ ) = O(log I) bit messages.

1. Stage 1 .
Each LDT finds its "minimum" outgoing edge and both nodes of an outgoing edge are made aware of it.(Since the edges are unweighted, this is just the outgoing edge whose ID is smallest among all outgoing edges.)Also, all nodes of an a given LDT should know both the name of the outgoing edge and the ID of the LDT that edge leads to.a. (The nodes in) each LDT run procedure Upcast-Min(n) to collect the ID of the "minimum" outgoing edge at the root of the LDT.b.Each LDT runs procedure Fragment-Broadcast(n) to let all nodes in the LDT know the ID of the chosen outgoing edge.c.Each LDT L runs Transmit-Adjacent(n) to let nodes from other LDTs know if they are part of the chosen outgoing edge from L.
can be constructed deterministically with O(log I) bit messages, with O((log n ′ ) log * I) awake complexity and O(n ′ (log n ′ ) log * I) round complexity.Broadcast over an LDT -in which the LDT root v r has a message of size at most m rcan be executed deterministically with O(m r ) bit messages, with O(1) awake complexity and O(n ′ ) round complexity.Ranking over an LDT -in which each node v ∈ V ′ learns its rank in some total ordering of the tree and also learns |V ′ | -can be executed deterministically with O(log I) bit messages, with O(1) awake complexity and O(n ′ ) round complexity.
We present our main result: an O(log log n) awake complexity randomized MIS algorithm.We first give a high-level description.Algorithm Awake-MIS computes the lexicographically first MIS, with respect to some uniformly random ordering, in "batches".More precisely, the LFMIS is computed over the first t nodes, then over the next t ′ nodes, and so on.To (energy efficiently) ensure all batches know which nodes (of prior batches) are in the MIS, we coordinate communication using the virtual binary tree technique with only O(log log n) awake complexity.Moreover, by batching nodes we can leverage the following "graph shattering" property: the subgraph induced by the yet undecided nodes within each batch can be decomposed into small O(log n)-sized connected components.Finally, for each such component, it suffices to run LDT-MIS from Section 5 to compute the LFMIS with respect to a uniformly random ordering (of the component's nodes) in O(log log n) awake time.Let ℓ = ⌈log n−log log n⌉ and ∆ ′ = O(log n) be some parameters decided in the analysis.The output variable state takes value in {undecided, inM IS, notinM IS}.The MIS problem is said to be solved if all nodes have chosen a state in {inM IS, notinM IS} and the set of all nodes with the inM IS output forms an MIS.Initially, each node starts in the "undecided" state.Moreover, each node v ∈ V picks a pair p round complexity and O(log I) bit messages.6RandomizedGreedy MIS in O(log log n) Awake Rounds

Algorithm 1
Awake-MIS for node v 1: Input: n 2: v chooses i ∈ [1, ℓ] with probability (10 • 2 i log n)/n and j ∈ [1, 2∆ ′ ] with probability 1/(2∆ ′ ) 3: p(v) := (i, j), statev := undecided 4: for phase p = 1 to 2ℓ∆ ′ do C 2 , . .., C p .Our final goal is to decompose the connected components in H in to a forest F of small-depth trees SDT 1 , SDT 2 , . .., SDT k . 8This is done as follows.For each connected component C i in H, the LDTs that make up C i work together to construct a spanning tree T i on top of C i .Then the LDTs in T i simulate a Cole-Vishkin style coloring of T i and use this coloring to then perform a maximal matching.Each edge of this maximal matching is added to F .Finally, after the maximal matching, if there exist isolated LDTs (i.e., unmatched LDTs), those LDTs add their outgoing edge to their parent LDT to F .If the isolated LDT is a root of some T i , then it will not have a parent.In this case, this isolated LDT chooses an outgoing edge to one of its children in T i .Notice that in each connected component C i of the supergraph H, there will exist exactly two LDTs with outgoing edges into each other.The LDT with the smaller ID becomes the root of the tree T i for that connected component and the other LDT becomes its child.By having all LDTs use procedures Upcast-Min(n) and 2. Stage 2. Consider the supergraph H where each LDT is a node and the outgoing edges identified in the previous step are the edges.Denote the connected components in H as C 1 , a.
Lemma 15.For a given graph of at most n nodes, where n is known to all the nodes, LDT-Construct-Round deterministically constructs an LDT over the given graph in the CONGEST setting in O((log n) log * n) awake complexity and O(n(log n) log * n) round complexity.
11Set v's rank to x + n 1 .During v's Down-Send round, it sends down x to c 1 , and for i ∈ [2, k], v sends the value 1 + i−1 j=1 n j to c i .This procedure takes O(1) awake complexity and O(n ′ ) round complexity.