Algorithms for the Minimum Dominating Set Problem in Bounded Arboricity Graphs: Simpler, Faster, and Combinatorial
aa r X i v : . [ c s . D S ] F e b Simple Combinatorial Algorithms for the Minimum DominatingSet Problem in Bounded Arboricity Graphs
Adir Morgan * Tel Aviv University Shay Solomon † Tel Aviv University Nicole Wein ‡ MIT
Abstract
We revisit the minimum dominating set problem on graphs with arboricity bounded by α . In the(standard) centralized setting, Bansal and Umboh [BU17] gave an O ( α ) -approximation LP roundingalgorithm. Moreover, [BU17] showed that it is NP-hard to achieve an asymptotic improvement. On theother hand, the previous two non-LP-based algorithms, by Lenzen and Wattenhofer [LW10], and Joneset al. [JLR + O ( α ) in linear time.There is a similar situation in the distributed setting: While there are poly log n -round LP-based O ( α ) -approximation algorithms [KMW06, DKM19], the best non-LP-based algorithm by Lenzen andWattenhofer [LW10] is an implementation of their centralized algorithm, providing an O ( α ) -approximationwithin O (log n ) rounds with high probability; they also gave a faster deterministic algorithm but with aworse approximation guarantee.We address the question of whether one can achieve a simple, elementary O ( α ) -approximation algo-rithm not based on any LP-based methods, either in the centralized setting or in the distributed setting.We resolve these questions in the affirmative. More specifically, our contribution is two-fold:1. In the centralized setting, we provide a surprisingly simple combinatorial algorithm that is asymp-totically optimal in terms of both approximation factor and running time: an O ( α ) -approximationin linear time.2. Based on our centralized algorithm, we design a distributed combinatorial O ( α ) -approximationalgorithm in the CONGEST model that runs in O ( α log n ) rounds with high probability. Our roundcomplexity outperforms the best LP-based distributed algorithm for a wide range of parameters. * [email protected] † [email protected] ‡ Supported by NSF Grant CCF-1514339. [email protected]
Introduction
The minimum dominating set (MDS) problem is a classic problem in computer science. Given a graph G we want to find a minimums cardinality set D of vertices, such that every vertex of the graph is eitherin D or has a neighbor in D . Besides its theoretical implications, solving this basic problem efficientlyhas many practical applications in domains ranging from wireless networks to text summarizing (see, e.g.,[WAF02, NA16, SL10]).The MDS problem was one of the first problems recognized as NP-complete [Gar79]. It was also one ofthe first problems for which an approximation algorithm was analyzed: a simple greedy algorithm achievesa ln(∆ + 1) -approximation [Joh74]. This approximation factor is optimal up to lower order terms unless P = NP [DS14]. Distributed MDS
The first efficient distributed approximation algorithm for MDS was given by Jia, Ra-jaraman, and Suel [JRS02], who gave a randomized O (log ∆) -approximation in O (log n ) rounds in the CONGEST model. This was improved by Kuhn, Moscibroda and Wattenhofer [KMW16], who gave a ran-domized (1 + ε )(1 + ln(∆ + 1)) -approximation in O (log ∆ /ε ) rounds in the CONGEST model and in O (log n/ε ) rounds in the LOCAL model. Ghaffari, Kuhn, and Maus [GKM17] showed that by allowingexponential-time local computation, one can get a randomized (1 + o (1)) -approximation in a polylogarith-mic number of rounds in the LOCAL model.For deterministic distributed algorithms, Deurer, Kuhn, and Maus [DKM19] recently gave two algo-rithms in the
CONGEST model with approximation factor (1 + ε ) ln(∆ + 1) for ε > / polylog ∆ , runningin O ( √ log n log log n ) and O (∆ · polylog ∆ + polylog ∆ log ∗ n ) rounds, respectively; the runtime of the formeralgorithm is dominated by the time needed for deterministically computing a network decomposition in the CONGEST model, which, due to [GGR21], is thus reduced to O (poly log n ) . Graphs of bounded arboricity
MDS has been studied on a variety of restricted classes of graphs suchas graphs with bounded degree (e.g., [CC08]), planar and bounded genus graphs (e.g., [Bak94, CHW08,ASS19]), and graphs of bounded arboricity, which is the focus of this paper. The class of bounded arboricity graphs is a wide family of uniformly sparse graphs, defined as follows:
Definition 1.1.
The graph G has arboricity bounded by α if for every S ⊆ V , it holds that m s n s − ≤ α where m s and n s are the number of edges and vertices in the graph induced by S , respectively.Thus the arboricity is close to the maximum density | E ( S ) | / | S | over all induced subgraphs of G. Theclass of bounded arboricity graphs contains the other graph classes mentioned above as well as boundedtreewidth graphs, and in general all graphs excluding a fixed minor. Moreover, many natural and real worldgraphs, such as the world wide web graph, social networks and transaction networks, are believed to havebounded arboricity. Consequently, this class of graphs has been subject to extensive research, which led tomany algorithms for bounded arboricity graphs in both the centralized setting (e.g. [Epp94, GG06, CN85])and in the distributed setting (e.g. [CHS09, BE10, GS17, SV20]); there are also many algorithms in othersettings, such as dynamic graph algorithms, sublinear algorithms and streaming algorithms (see [BF99,HTZ14, PS16, OSSW18, ELR18, ERR19, ERS20, BPS20, MV18, BS20], and the references therein).1 ombinatorial algorithms Many problems in theoretical computer science have been efficiently solvedusing the powerful machinery of algebraic algorithms, and an area of research has emerged where thegoal is to find combinatorial algorithms that are nearly as fast as their algebraic counterparts. Often suchalgorithms are simpler and easier to implement, and they typically have smaller constants hidden in theirrunning time expressions. Moreover, in the context of distributed computing, combinatorial algorithmscould give rise to much more efficient implementation in terms of local computation power as well as local memory constraints. Combinatorial algorithms can also provide a deeper understanding of the problemstudied. This line of work includes, for example, a combinatorial proof of the PCP theorem [DR06, Mei09],a combinaotiral construction of expanders [RVW00], and combinatorial algorithms for distributed graphcoloring [BE14].While the prior works that we compare our work to do use combinatorial techniques, these techniquesare general-purpose LP-based primal/dual methods. Our algorithms are not only combinatorial, but alsosimple and elementary. We believe that these attributes provide similar benefits over LP-based methods ascombinatorial algorithms provide compared to algebraic algorithms. α Centralized setting
In the centralized setting, there are two combinatorial non-LP-based algorithms forMDS for graphs of arboricity (at most) α (for brevity, in what follows we may write graphs of “arboricity α ” instead of arboricity at most α ). One is by Lenzen and Wattenhofer [LW10], the other is by Jones,Lokshtanov, Ramanujan, Saurabh, and Such`y [JLR + O ( α ) -approximation in de-terministic linear time . There is also an LP rounding algorithm by Bansal and Umboh that gives a α -approximation [BU17]. The algorithm of [BU17] also translates into a near-linear time algorithm usinga general-purpose approximation result for explicit packing and covering LPs [You14, AZO19, Qua20];specifically, one can get a deterministic O ( α ) -approximation LP-based algorithm within O ( m log n ) time.Bansal and Umboh [BU17] also proved that achieving asymptotically better approximation is NP-hard. Perhaps one can get a linear time O ( α ) -approximation algorithm for MDS using LP-based approaches, butsuch a result has not been stated in the literature. Distributed setting
In the distributed setting, there are two combinatorial non-LP-based algorithms forMDS for graphs of arboricity α , both by Lenzen and Wattenhofer [LW10]. The first is a randomized O ( α ) -approximation algorithm in the CONGEST model that runs in O (log n ) rounds with high probability. Thisalgorithm is deterministic except for a subroutine for maximal independent set (MIS), so one can apply therecent network decomposition based MIS algorithm by Ghaffari, Grunau, and Rozhoˇn [GGR21] to get adeterministic MIS algorithm. This yields an O ( α ) -approximation algorithm for MDS in the CONGEST model that runs in O (log n ) rounds. The second algorithm of Lenzen and Wattenhofer is a deterministic O ( α log ∆) -approximation algorithm in the CONGEST model that runs in O (log ∆) rounds, where ∆ is themaximum degree.Regarding LP-based algorithms, Kuhn, Moscibroda, and Wattenhofer [KMW06] developed a general-purpose method for solving LPs of a particular structure in the distributed setting. It seems that by applying Note that the theorem statement of [LW10] has a typo suggesting that the approximation factor is O ( α ) . More specifically, achieving an ( α − − ε ) -approximation is NP-hard for any ε > and any fixed α ; achieving an ( ⌊ α/ ⌋− ε ) -approximation is NP-hard for any ε > and any α = 1 , . . . , log δ n , for some constant δ [BU17, DGKR05]. These hardness ofapproximation results are achieved by applying a reduction by [BU17] from the k -hypergraph vertex cover ( k -HVC) problem(where we need to find a minimum vertex cover of a k -uniform hypergraph) to the MDS problem in arboricity- k graphs, inconjunction with NP-hardness results by [DGKR05] for the k -HVC problem. O ( α ) -approximation algorithm for MDSin the CONGEST model that runs in O (log ∆) rounds, but such a result has not been explicitly claimed inthe literature. A natural question
The aforementioned results demonstrate a significant gap for MDS algorithms inbounded arboricity graphs when comparing LP-based methods to elementary combinatorial approaches. Itis natural to ask whether this gap can be bridged:• In the centralized setting, is there any efficient non-LP-based O ( α ) -approximation algorithm for MDS(even one that is slower than the O ( m log n ) -time LP-based algorithm)? Further, can one achieve an O ( α ) -approximation in linear time using any (even LP-based) algorithm?• In the distributed setting, is there any efficient non-LP-based distributed O ( α ) -approximation algo-rithm for MDS? Further, can one achieve an O ( α ) -approximation in the CONGEST model within o (log ∆) rounds using any (even LP-based) algorithm? We answer the above question in the affirmative. In particular, we give simple combinatorial algorithms thatachieve the asymptotically optimal approximation factor of O ( α ) , and run faster than all known algorithms,including LP-based algorithms. Our core contribution is a non-LP-based asymptotically optimal algorithm in the centralized setting.
Theorem 1.2.
For graphs of arboricity α , there is an O ( m ) time O ( α ) -approximation algorithm for MDS. Our algorithm is asymptotically optimal in both running time and approximation factor: it runs in lin-ear time, and asymptotically improving the approximation factor it gets is proved to be NP-hard [BU17].Furthermore, our algorithm is combinatorial and elementary, in contrast to the only other known O ( α ) -approximation, which is LP-based; the improvement in running time over the LP-based algorithm is ad-mittedly minor (only a logarithmic factor), but still getting a truly linear time algorithm seems qualitativelydifferent than an almost-linear time.We demonstrate the applicability of our simple centralized algorithm, by using its core ideas to developa distributed algorithm. Theorem 1.3.
For graphs of arboricity α , there is a randomized distributed algorithm in the CONGEST model that gives an O ( α ) -approximation for MDS and runs in O ( α log n ) rounds. The bound on the numberof rounds holds with high probability (and in expectation). This is the first non-LP-based distributed O ( α ) -approximation algorithm. For the “interesting” parame-ter regime where ∆ is polynomial in n , and α = o (log n ) , the number of rounds in our algorithm beats eventhe LP-based algorithm obtained by combining [KMW06] and [BU17] which appears to run in O (log ∆) rounds; as noted already, such an algorithm has not been claimed explicitly before. We note the caveat thatour algorithm is randomized while their algorithm appears to be deterministic.In the process of obtaining our distributed algorithm, we also obtain a deterministic non-LP-based al-gorithm in the LOCAL model (with polynomial message sizes) in a polylogarithmic number of rounds, viareduction to the maximal independent set (MIS) problem: O ( α ) is the asymptotically optimal approximation factor for polynomial time algorithms in the centralized and distributedsettings i.e. assuming processors have polynomially-bounded processing power. heorem 1.4. Suppose there is a deterministic (resp., randomized) distributed algorithm in the
LOCAL model for computing an MIS on a general graph in R rounds. Then, for graphs of arboricity α , thereis a deterministic (resp., randomized) distributed algorithm in the LOCAL model that gives an O ( α ) -approximation for MDS in O ( Rα log n ) rounds. While Theorem 1.4 is the first deterministic non-LP-based algorithm to achieve an O ( α ) -approximation,we note that the LP-based approach obtained by combining [KMW06] and [BU17] appears to achieve fewerrounds and work in the CONGEST model. Theorem 1.4 is not our main result and is used as a stepping stonetowards our O ( α log n ) round algorithm in the CONGEST model.
Wider applicability
We demonstrated the applicability of our centralized combinatorial algorithm to thedistributed setting. We anticipate that the core idea behind our centralized algorithm could be applied morebroadly, to other settings that involve locality. Perhaps the prime example in this context is the standardsetting of dynamic graph algorithms, where the graph undergoes a sequence of edge updates (a single edgeupdate per step), and the algorithm should maintain the graph structure of interest ( O ( α ) -approximate MDSin our case) with a small update time — preferably poly log( n ) and ideally O (1) . Centralized algorithm
As a starting point, we consider the algorithm of Jones, Lokshtanov, Ramanujan,Saurabh, and Such`y [JLR + O ( α ) -approximation in linear time. Their algorithmis as follows. They iteratively build a dominating set D and maintain a partition of the remaining verticesinto the dominated vertices B (the vertices that have a neighbor in D ), and the undominated vertices W .The basic property of arboricity α graphs used by their algorithm is that every induced subgraph contains avertex of degree O ( α ) . They begin by choosing a vertex v with degree O ( α ) and adding v along with v ’sentire neighborhood N ( v ) to D . The intuition behind this is that at least one vertex in { v } ∪ N ( v ) must bein OP T (an optimal dominating set), since
OP T must dominate v . Hence, they add at least one vertex in OP T and use that to pay for adding O ( α ) vertices not in OP T . We say that a vertex w witnesses v and thevertices in N ( v ) that are added to D , if w ∈ OP T ∩ ( { v } ∪ N ( v )) . Now, the goal of the algorithm is toiteratively choose vertices v to add to D along with O ( α ) many of v ’s neighbors so that each vertex in OP T witnesses O ( α ) vertices v along with O ( α ) neighbors for each such vertex v . That is, each vertex in OP T witnesses O ( α ) vertices in D , which yields an O ( α ) -approximation.To choose which vertices v and which O ( α ) of v ’s neighbors to add to D , they partition the set B intotwo subsets B low and B high , which are the sets of vertices in B with low and high degree to W , respectively,where the degree threshold is δα for some constant δ . Then, they choose a vertex v with degree O ( α ) in thegraph induced by W ∪ B high , and add v to D along with v ’s O ( α ) neighbors that are in W ∪ B high . In theinterest of brevity, we will not motivate why this scheme achieves the desired outcome that each vertex in OP T witnesses O ( α ) vertices in D .The key innovation in our algorithm that allows us to reduce the approximation factor from O ( α ) to O ( α ) is a simple but powerful idea. After choosing a vertex v to add to D , we do not immediately add O ( α ) of v ’s neighbors to D . Instead v casts a “vote” for these O ( α ) neighbors, and only once a vertex gets δα many votes (for a constant δ ) is it added to D . With this modification, we can argue that each vertex in OP T still witnesses O ( α ) such vertices v as in the previous approach, but the catch here is that each such vertex v contributes only O (1) neighbors to D on average, so each vertex in OP T only witnesses a total of O ( α ) vertices in D , rather than O ( α ) . Moreover, it is straightforward to implement this algorithm in linear time.4 istributed algorithms using MIS This section concerns the proof of Theorem 1.4: our reduction fromMDS to MIS in the
LOCAL model. This section also concerns a modification of this reduction that gives an O ( α log n ) round algorithm in the CONGEST model. We use this algorithm as a stepping stone towardsobtaining our main distributed algorithm (Theorem 1.3) which runs in O ( α log n ) rounds in the CONGEST model.We adapt our centralized algorithm to the distributed setting as follows. Recall that in our centralizedalgorithm, we repeatedly choose a vertex v that has low degree with respect to the graph induced by W ∪ B high , add v to D , and cast a vote for each vertex in N ( v ) ∩ ( W ∪ B high ) . For our distributed algorithms,we would like to choose many such vertices v and process them in parallel . In fact, a constant fraction ofthe vertices in W ∪ B high could be chosen as our vertex v since a constant fraction of vertices in a graphof arboricity α have degree O ( α ) . However, we cannot simply process all of these vertices in parallel. Inparticular, if a vertex u has many neighbors being processed in parallel, u might accumulate many votesduring a single round. This would invalidate the analysis of the algorithm, which relies on the fact that oncea vertex u receives δα votes, u enters D .To overcome this issue, we compute an MIS with respect to a 2-hop graph built from a carefully chosensubgraph of “candidate” vertices, and only process the vertices in this MIS in parallel. This MIS has twouseful properties: 1. Its maximality implies that in any 2-hop neighborhood of a candidate vertex thereis a vertex in the MIS; this helps to bound the number of rounds, and 2. Its independence implies thatevery vertex has at most one neighbor in the MIS, which ensures that any vertex can only receive one voteper round. To conclude, this approach gives a reduction from distributed MDS to distributed MIS in the LOCAL model. This approach can be made to work in the
CONGEST model by replacing the black-boxMIS algorithm with a 2-hop version of Luby’s algorithm.
Faster randomized distributed algorithm
In the
CONGEST model, our distributed algorithm using MISruns in O ( α log n ) rounds with high probability. We devise a new, more nuanced algorithm that decreasesthe number of rounds to O ( α log n ) with high probability. Our new algorithm is based on our previousalgorithm, but with two key modifications, which save factors of log n and α , respectively.Our first key modification, which shaves a log n factor from the number of rounds, is that we do not runan MIS algorithm as a black box. Instead, we run only a single phase of a Luby-like MIS algorithm beforeupdating the data structures. Intuitively, this saves a log n factor because we are running just one phaseof a O (log n ) -phase algorithm, but it is not clear a priori whether we achieve the same progress as Luby’salgorithm in a single phase. We demonstrate that this is indeed the case via more refined treatment of thebehavior of each edge.Our second key modification, which shaves an α factor from the number of rounds, concerns the Luby-like algorithm. Recall that in Luby’s algorithm, each vertex v picks a random value p ( v ) and then joins theMIS if p ( v ) is the local minimum. In our algorithm, a vertex v instead joins the dominating set if p ( v ) isan α -minimum, which roughly means that p ( v ) is among the α smallest values that it is compared to. Weshow that with this relaxed definition, we still have the desired property that no vertex receives more than δα votes in a single round.The main technical challenge is the analysis of the number of rounds. It is tempting to use an analysissimilar to that of Luby’s algorithm, where we count the expected number of “removed edges” over time.However, our above modifications introduce several complications that preclude such an analysis. Instead,we use a carefully chosen function to measure our progress. Throughout the algorithm, we add “weight”to particular edges, and our function measures the “total available weight”. Specifically, whenever a vertex v is added to the dominating set, v adds weight to a particular set of edges in its 2-hop neighborhood. We5how that the total amount of weight added in a single iteration of the algorithm decreases the total availableweight substantially, which allows us to bound the total number of iterations. Section 2 is for preliminaries. In Section 3, we present our centralized algorithm (Theorem 1.2). In Section 4,we present our distributed algorithms using MIS: in the
LOCAL model we prove Theorem 1.4, and in the
CONGEST model we give a randomized algorithm with O ( α log n ) rounds that serves as a warm-up forthe faster algorithm of Theorem 1.3. In Section 5, we prove Theorem 1.3. Let G = ( V, E ) be an unweighted undirected graph. For any S ⊆ V , let G [ S ] be denote the graph inducedby S . For any v ∈ V , N G ( v ) denotes the neighborhood of v , and deg G ( v ) = | N G ( v ) | denotes the degree of v . When the graph G is clear from context, we omit the subscript.We define the LOCAL and
CONGEST models (cf. [Lin87, Lin92, Pel00]):
Definition 2.1.
The
LOCAL model: given a graph G on n vertices, every vertex is a separate processorrunning one process. Every vertex starts knowing only n and it’s own unique identifier. The algorithmworks in synchronous rounds, and in every round each vertex performs some computation based on its owncurrent information, then it sends a message to its neighbors, and finally it receives the messages sent to itby its neighbors in that round. Definition 2.2.
The
CONGEST model: given a graph G on n vertices, every vertex is a separate processorrunning one process. Every vertex starts knowing only n and it’s own unique identifier. The algorithm worksin synchronous rounds, and in every round each vertex performs some computation based on its own currentinformation, then it sends a message to its neighbors, of at most B = O (log n ) bits on each of its edges, andfinally it receives the messages sent to it by its neighbors in that round.The following two claims about graphs of bounded arboricity will be useful. A simple proof of both canbe found in [AMZ97]. Claim 2.3.
In a graph of arboricity α , every induced subgraph contains a vertex of degree at most α . Claim 2.4.
In a graph G with arboricity α , at least half of the vertices in any induced subgraph have degreeat most α . O ( α ) -approximation for MDS In this section we will prove Theorem 1.2, which we recall:
Theorem 1.2.
For graphs of arboricity α , there is an O ( m ) time O ( α ) -approximation algorithm for MDS. .1 Algorithm A description of our algorithm is as follows. See Algorithm 1 for the pseudocode.We first introduce some notation. We define a constant δ and let δα be our degree threshold . We will set δ = 2 , but we use the variable δ so that our analysis also applies to our distributed algorithms, where δ is adifferent constant. Following the terminology of [JLR + D , B , and W , where initially D = ∅ , B = ∅ , and W = V . The set D is our current dominating set,the set B is the vertices not in D with at least one neighbor in D , and the set W is the remaining vertices,i.e. the undominated vertices. The set B is further partitioned into two sets based on the degree of eachvertex to W . Let B low = { v ∈ B : | N ( v ) ∩ W | ≤ δα } and let B high = B \ B low . Also, each vertex v hasa counter c v initialized to 0. (The counter c v counts the number of “votes” that v receives, for the notion of“votes” introduced in the technical overview.)The algorithm proceeds as follows. While there still exists an undominated vertex (i.e. while W = ∅ ),we do the following. First, we find a vertex w ∈ W such that | N ( w ) ∩ ( W ∪ B high ) | ≤ δα . Such a vertex w exists since δ = 2 : by Claim 2.3, G [ W ∪ B high ] contains a vertex of degree at most δα , and this vertexcannot be in B high by the definition of B high , so it must be in W . Then, for all v ∈ N ( w ) ∩ ( W ∪ B high ) ,we increment c v , and if c v = δα , then we add v to D . Lastly, we add w to D . This concludes the descriptionof the algorithm. Algorithm 1
Linear time O ( α ) -approximation for MDS Initialize partition: D ← ∅ , B = ∅ , B high ← ∅ , B low ← ∅ , W ← V Initialize counters: ∀ v ∈ V : c v ← while W = φ do w ← a vertex in W with | N ( w ) ∩ ( W ∪ B high ) | ≤ δα for each v ∈ N ( w ) ∩ ( W ∪ B high ) do c v ← c v + 1 if c v = δα then D ← D ∪ v Update partition: D ← D ∪ w B = { v : N ( v ) ∩ D = ∅} B low = { v ∈ B : | N ( v ) ∩ W | ≤ δα } B high = B \ B low W = V \ ( D ∪ B ) Return D
First, we note that D is indeed a dominating set because the algorithm only terminates once the set W ofvertices that are not dominated, is empty. Let
OP T be an optimal MDS. We will prove that the set D returned by Algorithm 1 is of size at most δα · | OP T | . 7e first make the following simple claim about the behavior of the partition of vertices over time. Claim 3.1.
1. No vertex can ever leave D .2. No vertex can ever enter W from another set.3. No vertex can ever leave B low .Proof. Item 1 is by definition. Item 2 follows from item 1 combined with the fact that W is defined as theset of vertices with no neighbors in D . Now we prove item 3. A vertex from B low cannot enter W by item2. A vertex from B low cannot enter B high since the degree partition of B is based on degree to W , andby item 2 the degree of any vertex to W can only decrease over time. A vertex from B low cannot enter D because there are two ways a vertex can enter D : on Line 8 a vertex can only enter D from W ∪ B high , andon Line 10 a vertex can only enter D from W .We partition D into two sets, D active and D passive . The set D active consists of the vertices added to D due to being chosen as the vertex w ; that is, the vertices added to D in Line 10 of Algorithm 1. The set D passive consists of the vertices added to D as a result of their counters reaching δα ; that is, the verticesadded to D in Line 8 of Algorithm 1. To bound | D | , we will individually bound | D active | and | D passive | .We first bound | D active | . Claim 3.2. | D active | ≤ δα · | OP T | .Proof. For each vertex v ∈ D active , we assign v to an arbitrary vertex u ∈ N ( v ) ∩ OP T . Such a vertex u exists since OP T is a dominating set. For each vertex u ∈ OP T , let D u ⊆ D active be the set of verticesassigned to u . Our goal is to show that for each u ∈ OP T , | D u | ≤ δα .Fix a vertex u ∈ OP T . We partition the vertices v ∈ D u into two sets D u [ B low ] and D u [ B high ∪ W ] .Let D u [ B low ] ⊆ D u be the vertices that enter D while u is in B low . Let D u [ B high ∪ W ] ⊆ D u bevertices that enter D while u is in B high ∪ W . We note that no vertex in D u can enter D while u is in D , because by definition, every vertex in D active ⊇ D u moves directly from W to D . Therefore, D u = D u [ B low ] ∪ D u [ B high ∪ W ] .We first bound (cid:12)(cid:12) D u [ B low ] (cid:12)(cid:12) . By definition, while u is in B low , u has at most δα neighbors in W . Sinceno vertex can ever enter W by Claim 3.1, no vertex can ever enter N ( u ) ∩ W . Therefore, starting from thetime that u first enters B low , the total number of vertices ever in N ( u ) ∩ W is at most δα . Every vertex v ∈ D u [ B low ] is in N ( u ) ∩ W right before moving to D , so (cid:12)(cid:12) D u [ B low ] (cid:12)(cid:12) ≤ δα .Now, we bound D u [ B high ∪ W ] . By the specification of the algorithm, whenever a vertex v ∈ D u [ B high ∪ W ] enters D , the counter x u is incremented. Once x u reaches δα , u is added to D . Therefore, (cid:12)(cid:12) D u [ B high ∪ W ] (cid:12)(cid:12) ≤ δα .Putting everything together, we have | D u | = (cid:12)(cid:12) D u [ B low ] (cid:12)(cid:12) + (cid:12)(cid:12) D u [ B high ∪ W ] (cid:12)(cid:12) ≤ δα .Now we bound D passive . Claim 3.3. | D passive | ≤ | D active | .Proof. We will show that every vertex in D passive has at least δα neighbors in D active , while every vertex in D active has at most δα neighbors in D passive . Then, by the pigeonhole principle, it follows that | D passive | ≤| D active | .First, we will show that every vertex in D passive has at least δα neighbors in D active . By definition,every vertex v ∈ D passive has had its counter c v incremented δα times. Every time c v is incremented, one8f v ’s neighbors (the vertex w from Algorithm 1) is added to D , joining D active . Each such neighbor of v that joins D active is distinct since every vertex can be added to D at most once by Claim 3.1. Therefore,every vertex in D passive has at least δα neighbors in D active .Now we will show that every vertex in D active has at most δα neighbors in D passive . Fix a vertex w ∈ D active . By definition, when w enters D , w is moved straight from W to D . Thus, by Claim 3.1, w is never in B . Therefore, w is added to D before any of its neighbors are added to D , as otherwise w would enter B . Therefore, when w enters D , all of w ’s neighbors that will enter D passive are in B ∪ W . ByClaim 3.1, no vertex in B low can ever enter D , so actually, when w enters D all of w ’s neighbors that willenter D passive are in B high ∪ W . By definition, when w enters D , w has at most δα neighbors in B high ∪ W .Therefore, w has at most δα neighbors in D passive .Combining Claim 3.2 and Claim 3.3, we have that | D | = | D active | + | D passive | ≤ δα · | OP T | . Our goal is to prove that Algorithm 1 runs in O ( m ) time.Throughout the execution of the algorithm, we maintain a data structure that consists of the following:• The partition of V into D , B low , B high , W • The induced graph G [ W ∪ B high ] represented as an adjacency list• For each vertex v ∈ W ∪ B high , the quantities | N ( v ) ∩ W | and | N ( v ) ∩ ( W ∪ B high ) | • A set W low = { v ∈ W : | N ( v ) ∩ ( W ∪ B high ) | ≤ δα } First, we show that the data structure can be initialized in O ( m ) time. Initially D ∪ B high ∪ B low = ∅ , W = V , and the induced graph G [ W ∪ B high ] = G . For every vertex v ∈ V , initially | N ( v ) ∩ W | = | N ( v ) ∩ ( W ∪ B high ) | = deg( v ) . Initially W low = { v ∈ V : deg( v ) ≤ δα } .Now, we show that the data structure can be maintained in O ( m ) time. In particular, we will show thatto maintain this data structure, it suffices to scan the neighborhood of a vertex every time it either leaves W ∪ B high (and enters B low ∪ D ), enters D , or leaves W . Note that by Claim 3.1, each of these eventsonly happens once per vertex. As a consequence, the total amount of time spent scanning neighborhoods is O ( m ) .We assume inductively that we have maintained the data structure so far, and we consider the nextiteration of the for each loop. First, we consider maintenance of the partition of V into D , B low , B high , and W . During an iteration, the only changes made to the partition are the addition of at least one vertex to D (on Line 8 and/or Line 10), and the resulting update of the rest of the partition. To maintain the partition wedo the following. When we add a vertex v to D , we remove v from whichever set it was previously in. Then,we update B by scanning N ( v ) and adding every vertex u ∈ N ( v ) \ D to B , removing u from whicheverset it was previously in. Updating D and B automatically updates W since W = V \ ( D ∪ B ) . Beforeupdating B low and B high , we first need to update | N ( v ) ∩ W | . To do this, whenever a vertex v leaves W ,we scan N ( v ) and for each u ∈ N ( v ) , we decrement | N ( u ) ∩ W | . Whenever we decrement | N ( u ) ∩ W | down to δα for a vertex u ∈ B high , we move u to B low . This concludes the maintenance of the partition of V into D , B low , B high , and W .It remains to update G [ W ∪ B high ] , | N ( v ) ∩ ( W ∪ B high ) | , and W low . Whenever we remove a vertex v from W ∪ B high , we scan N ( v ) and for each vertex u ∈ N ( v ) , we remove the edge ( u, v ) from G [ W ∪ B high ] and decrement | N ( u ) ∩ ( W ∪ B high ) | . Whenever we decrement | N ( u ) ∩ ( W ∪ B high ) | down to δα for u ∈ W , we add u to W low . This concludes the running time analysis for maintaining the data structure.9ow we will show that maintaining the data structure allows the algorithm to run in time O ( m ) . First,each iteration of the while loop adds at least one vertex to D (on Line 10), and by Claim 3.1, each vertex isadded to D at most once, so the total number of iterations of the while loop is at most n . Now we will goline by line through the body of the while loop. On Line 4, we let w be a vertex in W with | N ( w ) ∩ ( W ∪ B high ) | ≤ δα . Such a vertex w can be found in constant time since we maintain a set W low of precisely thevertices that satisfy this condition. On Line 5, we loop through every vertex in | N ( w ) ∩ ( W ∪ B high ) | . Thenumber of iterations of this loop is at most δα by choice of w . Furthermore, identifying all of the verticesto loop through takes time O ( α ) since our data structure explicitly maintains G [ W ∪ B high ] . In Line 6through Line 10, we update counters and then add vertices to D , which takes constant time per iteration ofthe loop. In Line 11 through Line 14 we update B , B low , B high , and W , which takes constant time sincewe store these sets in our data structure. Thus, given access to the data structure, the algorithm runs in time O ( nα ) = O ( m ) .Previously we showed that maintaining the data structure takes time O ( m ) , so we have that the entirealgorithm takes time O ( m ) . O ( α ) -approximation for MDS using MIS In this section we will prove Theorem 1.4, which we recall:
Theorem 1.4.
Suppose there is a deterministic (resp., randomized) distributed algorithm in the
LOCAL model for computing an MIS on a general graph in R rounds. Then, for graphs of arboricity α , thereis a deterministic (resp., randomized) distributed algorithm in the LOCAL model that gives an O ( α ) -approximation for MDS in O ( Rα log n ) rounds. In this section we also show how to modify of the proof of Theorem 1.4 to get a bound in the
CONGEST model:
Theorem 4.1.
For graphs of arboricity α , there is a randomized distributed algorithm in the CONGEST model that gives an O ( α ) -approximation for MDS that runs in O ( α log n ) rounds with high probability. In the next section, we will use the algorithm of Theorem 4.1 as a starting point to get an improvedalgorithm with O ( α log n ) rounds. Overview
Our algorithm is an adaptation of our centralized algorithm from Theorem 1.2 to the distributedsetting. Recall that in our centralized algorithm, we repeatedly choose a vertex w that has low degree withrespect to the graph induced by W ∪ B high , add w to the dominating set, and increment the counter of w ’sneighbors that are in W ∪ B high . For our distributed algorithms, we would like to choose many such vertices w and process them in parallel. There are in fact many vertices that we could choose as our vertex w sinceClaim 2.4 implies that at least half of the vertices in any induced subgraph has degree at most α . However,we cannot simply process all of these vertices at once. In particular, if a vertex v has many neighborsbeing processed in parallel, v might have its counter incremented once for each of these neighbors. Thisis undesirable because the analysis of our centralized algorithm relies on the fact that once a vertex has itscounter incremented to δα , it is added to the dominating set. Therefore, we would like to guarantee thatonly a limited number of v ’s neighbors are processed in parallel.10his is where the MIS problem becomes relevant: we ensure that no vertex has more than one neighborbeing processed in parallel by taking an MIS I with respect to the graph G low defined as follows: the vertexset of G low is the set of candidates for w , that is, the set of vertices v in W with | N ( v ) ∩ ( W ∪ B high ) | ≤ α .There is an edge ( u, v ) in G low if there is a path of length 2 between u and v in G [ W ∪ B high ] . Note thatbecause no vertex has more than one neighbor in I , we can process all vertices in I in parallel and onlyincrease the counter of each vertex by at most one.The algorithms for Theorem 1.4 and Theorem 4.1 are identical except for the MIS subroutine. Theorem 1.4is for the LOCAL model so we can simply run any distributed MIS algorithm that works in the
LOCAL modelon G low as a black box. On the other hand, Theorem 4.1 is for the CONGEST model and because G low canhave higher degree than G , running an MIS algorithm directly on G low could result in messages that becometoo large after translating the algorithm to run on G . To bypass this issue, we use a simple modification ofLuby’s algorithm that computes I using only small messages, without increasing the number of rounds. Algorithm description
We provide a description of the algorithms here, and include the pseudocode inAlgorithm 2. The only difference between the algorithms for Theorem 1.4 and Theorem 4.1 is the MISsubroutine, which we will handle separately later.The sets D , B , W , B high , B low , and W low are defined exactly the same as in our centralized algorithm,except we set δ = 4 instead of δ = 2 so that we can apply Claim 2.4 instead of Claim 2.3. We repeat thedefinitions here for completeness. The set D is our current dominating set, the set B is the vertices not in D with at least one neighbor in D , and the set W is the remaining vertices, i.e. the undominated vertices. Theset B is further partitioned into two sets based on the degree of each vertex to W . Let B low = { v ∈ B : | N ( v ) ∩ W | ≤ δα } and let B high = B \ B low . Also, let W low = { v ∈ W : | N ( v ) ∩ ( W ∪ B high ) | ≤ δα } .Lastly, each vertex v has a counter c v .Each vertex v maintains the following information:• The set(s) among D , B , W , B high , B low , and W low that v is a member of.• The quantity | N ( v ) ∩ W | .• The quantity | N ( v ) ∩ ( W ∪ B high ) | .• The counter c v .At initialization, every vertex v is in W (so D and B are empty). Consequently, the quantities | N ( v ) ∩ W | and | N ( v ) ∩ ( W ∪ B high ) | are both equal to deg( v ) . For each vertex v , if deg( v ) ≤ δα , then v ∈ W low .Each counter c v is initialized to 0.It will be useful to define the graph G low , which changes over the execution of the algorithm: Definition 4.2.
Let G low be the graph with vertex set W low such that there is an edge ( u, v ) in G low if thereis a path of length 2 between u and v in G [ W ∪ B high ] .The algorithm proceeds as follows. Repeat the following until W is empty. Compute an MIS I withrespect to G low . This step is implemented differently for Theorem 1.4 and Theorem 4.1, and we describethe details of this step later.Then, each vertex in I adds itself to D and tells its neighbors to increment their counters. Whenever thecounter of a vertex reaches δα , it enters D . (Note that if a vertex u enters D as a result of c u reaching δα , c u does not tell its neighbors to increment their counters.)Whenever a vertex moves from one set of the partition to another, it notifies each of its neighbors v sothat v can update the quantities | N ( v ) ∩ W | and | N ( v ) ∩ ( W ∪ B high ) | , and move to the appropriate set.11hen no more vertices are left in W , B high is also empty, and all processors terminate. This concludes thedescription of the algorithm. See Algorithm 2 for the precise ways that vertices react to the messages thatthey receive. MIS subroutine
Theorem 1.4 is a reduction from MDS to MIS, while Theorem 4.1 is not, so we need todescribe the MIS subroutine (in the
CONGEST model) only for Theorem 4.1. Recall that we cannot use areduction to MIS in the
CONGEST model because running an MIS algorithm directly on G low could resultin messages that become too large after translating the algorithm to run on G .Our goal is to compute an MIS with respect to G low , using small messages sent over G . We use asimple adaptation of Luby’s algorithm. Recall that Luby’s algorithm builds an MIS I as follows. While thegraph is non-empty, do the following: Add all singletons to I . Then, each vertex v picks a random value p ( v ) ∈ [0 , . Then, all vertices whose value is less than that of all of their neighbors are added to I . Then,all vertices that are in I or have a neighbor in I are removed from the graph for the next iteration of the loop.We use the following adaptation of Luby’s algorithm. See Algorithm 3 for the pseudocode. Initially,the set L of live vertices is the set W low . While L = ∅ , do the following: Each vertex v ∈ L picks arandom value p ( v ) ∈ [0 , . In the first round each v ∈ L sends p ( v ) to its neighbors. In the secondround, each vertex that receives one or more values p ( v ) , forwards to its neighbors the minimum value thatit received. Then, for each vertex v ∈ W low , if p ( v ) is equal to the minimum value that v receives in thesecond round, v is added to I . When v is added to I , v notifies its neighbors, and each neighbor of v that isin W ∪ B high forwards this notification to their neighbors. Note that each vertex has at most one neighbor in I , so forwarding this notification only takes one round. Now, every vertex knows whether it has a neighborwith respect to G low that is in I , and every vertex that does is removed from L for the next iteration of theloop.The proof that this algorithm runs in O (log n ) rounds with high probability and produces an MIS withrespect to G low is the same as the analysis of Luby’s algorithm and we will not include it here. The proof that Algorithm 2 achieves an O ( α ) -approximation is precisely the same as that of the centralizedalgorithm (see Section 3.2.1) given that no counter c v ever exceeds δα . This is true because in a singleiteration of the while loop each vertex can only have its counter incremented once since only vertices in theMIS I send INCREMENT COUNTER messages, and each vertex in W ∪ B high only has at most one neighborin I . This bound on the number of neighbors in I holds, since otherwise there is a path of length 2 betweentwo vertices in G [ W ∪ B high ] , making I not an independent set in G low . Once c v reaches δα , the vertex v enters D , which prevents c v from increasing in the future.Our goal in this section is to prove that if the MIS subroutine takes R rounds, then Algorithm 2 takes O ( Rα log n ) rounds. First, we note that the body of the while loop besides the MIS subroutine takes aconstant number of rounds. Thus, our goal is to show that the number of iterations of the while loop is O ( α log n ) .We begin with a simple claim about the behavior of the partition of vertices over time: Claim 4.3.
1. No vertex can ever enter W from another set.2. No vertex can ever enter W low from another set. lgorithm 2 Distributed O ( α ) -approximation for MDS using MIS Initialize partition: D ← ∅ , B high ← ∅ , B low ← ∅ , W ← V , W low ← { v ∈ W : | N ( v ) ∩ ( W ∪ B high ) | ≤ δα } Initialize counters: ∀ v ∈ V : c v ← Initialize degrees: ∀ v ∈ V : | N ( v ) ∩ W | = deg( v ) , | N ( v ) ∩ ( W ∪ B high ) | = deg( v ) while W = ∅ do Find an MIS I with respect to the graph G low Each vertex v runs the following procedure: if v ∈ I then Move v to D Send
INCREMENT COUNTER message to neighbors
Send
MOVED FROM W TO D message to neighbors if v ∈ W ∪ B high and v receives INCREMENT COUNTER then
Increment c v if c v = δα then if v ∈ W then Send
MOVED FROM W TO D message to neighbors if v ∈ B high then Send
MOVED FROM B high TO D message to neighbors Move v to D // The rest of the algorithm is bookkeeping if v receives MOVED FROM W TO D then Decrement | N ( v ) ∩ W | if v ∈ B high and | N ( v ) ∩ W | = δα then Move v to B low if v receives MOVED FROM W TO D or MOVED FROM B high TO D then Decrement | N ( v ) ∩ ( W ∪ B high ) | if v ∈ W and | N ( v ) ∩ W | ≤ δα then Move v to B low Send
MOVED FROM W TO B low message to neighbors else if v ∈ W and | N ( v ) ∩ W | > δα then Move v to B high Send
MOVED FROM W TO B high message to neighbors if v receives MOVED FROM W TO B low or MOVED FROM W TO B high then Decrement | N ( v ) ∩ W | if v ∈ B high and | N ( v ) ∩ W | = δα then Move v to B low if v receives MOVED FROM W TO B low then Decrement | N ( v ) ∩ ( W ∪ B high ) | if v ∈ W and | N ( v ) ∩ ( W ∪ B high ) | = δα then Add v to W low lgorithm 3 Distributed MIS with respect to G low in the CONGEST model L = W low while L = ∅ do Each vertex v runs the following procedure: if v ∈ L then p ( v ) ← a value in [0 , chosen uniformly at random Send p ( v ) message to neighbors Send m v = min y ∈ N ( v ) ∩ L p ( y ) message to neighbors if p ( v ) = min y ∈ N ( v ) m y then Add v to I Send
ADDED message to neighbors if v ∈ W ∪ B high and v receives ADDED then
Send
NEIGHBOR ADDED message to neighbors if v receives NEIGHBOR ADDED and v ∈ L then Remove v from L Proof.
The proof of item 1 is the same as in the proof of Claim 3.1. For item 2, we have that by item 1, novertex can ever enter W low from any set other than W high . However, it is impossible for a vertex to movefrom W high to W low since the quantity N ( v ) ∩ ( W ∪ B high ) can only decrease over time (in Algorithm 2,this quantity is only decremented).We begin with the following claim, which when combined with Claim 4.3, implies that each vertex onlyspends a limited number of rounds in W low . Claim 4.4.
For every vertex v that is ever in W low , within ( δα ) iterations of the while loop after v joins W low , v leaves W .Proof. First we note that by Claim 4.3 no vertex can ever enter W low from another set. Suppose v is in W low at the beginning of an iteration of the while loop. Because I is an MIS with respect to G low , if v does notjoin I during this iteration, then v has a neighbor y ∈ W ∪ B high such that a neighbor z of y joins I . As aresult, z immediately joins D and c y is incremented. Thus, during every iteration that v remains in W low ,a vertex in N ( v ) ∩ ( W ∪ B high ) has its counter incremented. Recall that whenever a vertex has its counterincremented δα times, it joins D . Because v ∈ W low , we have that | N ( v ) ∩ ( W ∪ B high ) | ≤ δα . Therefore,the event that a vertex in N ( v ) ∩ ( W ∪ B high ) has its counter incremented can only happen at most ( δα ) times. Thus, v can only remain in W low for ( δα ) iterations of the while loop.We will complete the analysis using the fact that many vertices are in W low at any given point in time.In particular, Claim 2.4 implies that at least half of the vertices in W ∪ B high are in W low . This implies thatat least half of the vertices in W are in W low . Formally, we divide the execution of the algorithm into phaseswhere each phase consists of ( δα ) iterations of the while loop. At the beginning of any phase, at least halfof the vertices in W are in W low . By the end of the phase, all of these vertices have left W by Claim 4.4.Therefore, each phase witnesses at least half of the vertices in W leaving W . By Claim 4.3, no vertex canre-enter W , so there can only be O (log n ) phases.Putting everything together, there are O (log n ) phases, each consisting of ( δα ) iterations of the while loop, and one iteration of the while loop takes O ( R ) rounds. Therefore, the total number of rounds is O ( Rα log n ) . 14or Theorem 4.1, R = O (log n ) , so the number of rounds is O ( α log n ) . O ( α ) -approximation for MDS In this section we will prove Theorem 1.3, which we recall:
Theorem 1.3.
For graphs of arboricity α , there is a randomized distributed algorithm in the CONGEST model that gives an O ( α ) -approximation for MDS and runs in O ( α log n ) rounds. The bound on the numberof rounds holds with high probability (and in expectation). Overview
We use our O ( α log n ) round algorithm from Theorem 4.1 as a starting point (though thealgorithm description and analysis are self-contained). Our goal is to shave both a log n factor and an α factor from the number of rounds. To do so, we use a combination of two key modifications, whichrespectively address the two factors that we wish to shave.Our first key modification, which shaves a log n factor from the number of rounds, is that instead of usinga Luby-style algorithm as a black box, we open the box and run only one phase of a Luby-style algorithm ata time. Here, one phase means that each participating vertex v picks a single random value p ( v ) and enters D if p ( v ) is a local minimum. Between each such phase, we update the dominating set D as well as theinformation stored by each vertex. This way, we can embed the analysis of the Luby-style algorithm intoour analysis instead of repeatedly paying for for all log n phases of a black-box algorithm.Our second key modification, which shaves an α factor from the number of rounds, is that instead ofadding v to D only when p ( v ) is the single local minimum, we allow v to be added to D when p ( v ) is an α -minimum . The definition of an α -minimum is slightly nuanced due to the fact that we need to be ableto compute it using small messages, but it roughly means that p ( v ) is among the α smallest values thatit is compared to. Using this modification we can ensure that during each iteration of our algorithm eachvertex only has its counter incremented by O ( α ) . Even though each vertex in our previous O ( α log n ) -round algorithm only had its counter incremented by at most 1 during each iteration, this change does notasymptotically increase the approximation factor.The main technical part of the argument is the probabilistic analysis of the number of rounds. We wouldlike to use an analysis similar to that of Luby’s algorithm, however there are a few obstacles. Recall thatto analyze Luby’s algorithm, one can argue that after a single phase, a constant fraction of the edges in thegraph are removed in expectation. Our first obstacle is that we are running a phase of a Luby-style algorithmon an auxiliary graph that is different from our original graph; in particular, an edge in the auxiliary graphcan represent a 2-hop path in the original graph, and it is not clear how removing an edge from the auxiliarygraph translates to the original graph. That is, if a constant fraction of edges are removed in the auxiliarygraph, this doesn’t necessarily mean that a constant fraction of edges in the original graph are removed. Asecond obstacle is that we need a more nuanced notion than “removing an edge” as in Luby’s algorithm sincedue to our second modification, up to α vertices could all affect the same edge simultaneously. To addressthese obstacles, we use a carefully chosen function to measure our progress. Throughout the algorithm,we add “weight” to particular edges, and our function measures the “total available weight”. Specifically,whenever a vertex v is added to the dominating set, v adds weight to a particular set of edges in its 2-hopneighborhood. We show that the total amount of weight added in a single iteration of the algorithm decreasesthe expected total available weight substantially, which allows us to bound the total number of iterations.15 lgorithm Description We include a description of the algorithm here, and include the pseudocode inAlgorithm 4.The partition of the vertices is exactly the same as in Algorithm 2, with the addition of the set W high .We repeat all of the definitions for completeness. The set D is our current dominating set, the set B isthe vertices not in D with at least one neighbor in D , and the set W is the remaining vertices, i.e. theundominated vertices. The set B is further partitioned into two sets based on the degree of each vertex to W . Let B low = { v ∈ B : | N ( v ) ∩ W | ≤ δα } , where δ = 4 , and let B high = B \ B low . Also, let W low = { v ∈ W : | N ( v ) ∩ ( W ∪ B high ) | ≤ δα } . We additionally define W high = W \ W low . Lastly, eachvertex v has a counter c v .Each vertex v maintains the following information:• The set(s) among D , B , W , B high , B low , W high , and W low that v is a member of.• The quantity | N ( v ) ∩ W | .• The quantity | N ( v ) ∩ ( W ∪ B high ) | .• The counter c v .At initialization, every vertex v is in W (so D and B are empty). Consequently, the quantities | N ( v ) ∩ W | and | N ( v ) ∩ ( W ∪ B high ) | are both equal to deg( v ) . For each vertex v , if deg( v ) ≤ δα , then v ∈ W low .Each counter c v is initialized to 0.It will be useful to define the graph G bi ⊆ G that changes over the course of the execution of thealgorithm: Definition 5.1. G bi is a bipartite graph on the vertex set B high ∪ W . One side of the bipartition is B high ∪ W high and the other side is W low . The edge set of G bi is the set of edges in G with one endpoint in eachside of the bipartition.The algorithm proceeds as follows. Repeat the following until W is empty. In the first round, eachvertex v ∈ W low picks a value p ( v ) ∈ [0 , uniformly at random and sends p ( v ) to its neighbors. Thenext step is for v to determine whether p ( v ) is an α -minimum . p ( v ) is said to be an α -minimum if for every u ∈ N G bi ( v ) , p ( v ) is among the α smallest values of vertices in N G bi ( u ) . To determine which values are α -minima, in the second round each vertex u ∈ B high ∪ W high sends ACK to each vertex v ∈ N G bi ( u ) suchthat p ( v ) is among the α smallest values that u received. If v ∈ W low receives ACK from all u ∈ N G bi ( v ) ,then v is added to D (if N G bi ( v ) is empty then v is added to D ) and v tells its neighbors to increment theircounters (in the third round). Whenever the counter c u of a vertex u reaches δα , u enters D . (Note that if u enters D as a result of c u reaching δα , c u does not tell its neighbors to increment their counters.)Whenever a vertex v moves from one set of the partition to another, v notifies each vertex u ∈ N ( v ) sothat u can update the quantities | N ( u ) ∩ W | and | N ( u ) ∩ ( W ∪ B high ) | , and move to the appropriate set. Thebookkeeping for updating this information is identical to that of Algorithm 2. When no more vertices areleft in W , B high is also empty, and all processors terminate. This concludes the description of the algorithm. We begin with a simple claim about the behavior of the partition of vertices over time:
Claim 5.2.
1. No vertex can ever leave D . lgorithm 4 Faster Randomized Distributed O ( α ) -approximation for MDS Initialize partition: D ← ∅ , B high ← ∅ , B low ← ∅ , W ← V , W low ← { v ∈ W : | N ( v ) ∩ ( W ∪ B high ) | ≤ δα } , W high ← W \ W low Initialize counters: ∀ v ∈ V : c v ← Initialize degrees: ∀ v ∈ V : | N ( v ) ∩ W | = deg( v ) , | N ( v ) ∩ ( W ∪ B high ) | = deg( v ) while W = ∅ do Each vertex v runs the following procedure: if v ∈ W low then p ( v ) ← a value in [0 , chosen uniformly at random Send p ( v ) message to neighbors if v ∈ B high ∪ W high then Send
ACK to each u ∈ N G bi ( v ) such that p ( u ) is among the α smallest values v received if v ∈ W low and v receives ACK from all u ∈ N G bi ( u ) then Move v to D Send
INCREMENT COUNTER message to neighbors
Send
MOVED FROM W TO D message to neighbors Run Algorithm 2 starting from Line 11
2. No vertex can ever enter W ∪ B high from another set.3. No vertex in W low can ever at a later point be in B high ∪ W high .Proof. The proofs of items 1 and 2 follow from the proof of Claim 3.1. Item 3 holds because if a vertex v is in B high then | N ( v ) ∩ W | > δα and if v is in W high then | N ( v ) ∩ ( W ∪ B high ) | > δα . For any v , thequantities | N ( v ) ∩ W | and | N ( v ) ∩ ( W ∪ B high ) | can only decrease over time (they are only decrementedin Algorithm 4).Next, we prove a simple claim that upper bounds the counter of each vertex: Claim 5.3.
For all v ∈ V , at all times c v < δα .Proof. If for any v ∈ V , it happens that c v ≥ δα , then during the same iteration of the while loop, v enters D (on Line 18), after which point v never leaves D (by Claim 5.2) so c v cannot ever change again. Thus,it suffices to show that for all vertices v ∈ V \ D , during a single iteration of the while loop, c v can beincremented at most δα times, leading to a maximum value of at most δα − . This is true for v ∈ W low because | N ( v ) ∩ ( W ∪ B high ) | ≤ δα , and only vertices in | N ( v ) ∩ ( W ∪ B high ) | can tell v to increment c v . On the other hand, if v ∈ W ∪ B high , then a neighbor u of v only sends INCREMENT COUNTER if p ( u ) is among the α smallest values in v ’s neighborhood, so c v is only incremented α times during a singleiteration.The analysis of correctness is the same as that of our centralized algorithm (see Section 3.2.1), with onetechnicality: By Claim 5.3, the counter of each vertex has maximum value δα instead of δα , causing anincrease in the leading constant in the O ( α ) approximation factor.Our goal in the rest of this section is to prove that Algorithm 4 runs in O ( α log n ) rounds with highprobability. Note that one iteration of the while loop takes a constant number of rounds. Thus, our goal isto show that there are O ( α log n ) total iterations of the loop.17or any vertex v ∈ V ( G bi ) , let N ( v ) be the set of vertices in the 2-hop neighborhood of v with respectto G bi , and let E ( v ) be the set of edges within 2 hops of v with respect to G bi ; that is, E ( v ) contains theedge ( v, u ) for all u ∈ N G bi ( v ) , and the edge ( u, y ) for all y ∈ N G bi ( u ) .We divide the iterations of the while loop into two types. We say that an iteration is of type low degree if at least half of the vertices v ∈ W low have | N ( v ) | ≤ α . Otherwise, we say that an iteration is of typehigh degree .It is simple to deterministically bound the number of iterations of type low degree: Claim 5.4.
The total number of iterations of type low degree is O (log n ) .Proof. By the specification of the algorithm, all vertices v with | N ( v ) | ≤ α are added to D (on Line 12).Thus, during an iteration of type low degree, at least half of the vertices in W low enter D . By Claim 2.4, atleast half of the vertices in W ∪ B high are in W low . Thus, during an iteration of type low degree, at least / of the vertices in W ∪ B high enter D . By Claim 5.2, no vertex can ever enter W ∪ B high from anotherset. Therefore, during every iteration of type low degree, W ∪ B high shrinks by a factor of at least . Thus,there are only O (log n ) iterations of type low degree.It remains to bound the number of iterations of type high degree. Fix an iteration I of type high degree.For the purpose of analysis, we assign each edge e ∈ E a weight w ( e ) that increases over the executionof the algorithm. The rule for updating the weight of edges is as follows. Whenever a vertex v ∈ W low ismoved to D on Line 12 (as a result of p ( v ) being an α -minimum), v increments the weight of every edge in E ( v ) .We will define the available weight at iteration I as a function that will capture the total amount ofweight that could ever be added over all iterations starting from iteration I . Our goal is to provide:1. an upper bound of α · | V ( G bi ) | / for the available weight at iteration I , and2. a lower bound of δα · | V ( G bi ) | for the expected total weight added to edges during iteration I .Combining these upper and lower bounds yields the result that in each iteration the expected total amountof weight added is a /O ( α ) fraction of the total available weight. This allows us to bound the number ofiterations by O ( α log n ) with high probability. Definition 5.5.
The available weight at iteration I , denoted A ( I ) is given by A ( I ) = X e ∈ E ( G [ W ∪ B high ]) δα − w ( e ) where the parameters in the expression are taken to be their values at the beginning of iteration I .Giving an upper bound on A ( I ) , which is item 1 of our above goal, is simple: Claim 5.6. A ( I ) ≤ δα · | V ( G bi ) | .Proof. By definition all edge weights are non-negative, so A ( I ) ≤ P e ∈ E ( G [ W ∪ B high ]) δα . Since G [ W ∪ B high ] has arboricity at most α , | E ( G [ W ∪ B high ]) | ≤ α · | W ∪ B high | = α · | V ( G bi ) | . This completes theproof.Now, we consider item 2 of our above goal. Let w ( I ) be a random variable denoting the aggregatetotal weight added to edges during iteration I . The randomness is over the choice of p ( v ) for each vertex v ∈ W low . Towards lower bounding w ( I ) , for every vertex v ∈ W low we define the random variable R v asthe number of edges whose weight is incremented by v during iteration I . That is, w ( I ) = P v ∈ W l ow R v .We now calculate E [ R v ] . 18 laim 5.7. For all v ∈ W low with | N ( v ) | ≥ α , it holds that E [ R v ] ≥ α .Proof. Note that E ( v ) and N ( v ) are taken to mean these value at the beginning of iteration I . A vertex v ∈ W low increments the weight of each edge in E ( v ) if v is an α -minimum, and otherwise v does notincrement the weight of any edges. A sufficient condition for v to be an α -minimum is that p ( v ) is amongthe α smallest values in N ( v ) . Since | N ( v ) | ≥ α , the probability that p ( v ) is among the α smallest valuesin N ( v ) is α/ | N ( v ) | ≥ α/ | E ( v ) | since each vertex chooses its value uniformly at random. Therefore, P [ R v = | E ( v ) | ] ≥ α/ | E ( v ) | . Thus, E [ R v ] ≥ α .We now give a lower bound on the expected aggregate weight E [ w ( I )] : Claim 5.8. E [ w ( I )] ≥ α · | V ( G bi ) | / Proof.
Recall that w ( I ) = P v ∈ W l ow R v . Thus, E [ w ( I )] = E h X v ∈ W low R v i = X v ∈ W low E [ R v ] ≥ X v ∈ W low , | N ( v ) |≥ α E [ R v ] ≥ X v ∈ W low , | N ( v ) |≥ α α (by Claim 5.7) ≥ α · | W low | / (since iteration I is of type high degree) ≥ α · | B high ∪ W | / (by Claim 2.4) = α · | V ( G bi ) | / . Before combining the above upper and lower bounds, we need to show that our function A ( I ) accuratelymeasures the progress of our algorithm by proving the following properties: Claim 5.9.
1. If I ′ is the iteration right after I , then A ( I ′ ) ≤ A ( I ) − w ( I ) .2. A ( I ) > .Proof. For item 1, it suffices to observe that the weight of an edge can only increase and the set of edges wesum over in the definition of A ( I ) can only decrease. This is true because by Claim 5.2, no vertex can everenter W ∪ B high from another set.For item 2, it suffices to show that δα − w ( e ) is always positive. Suppose for contradiction that there isan edge ( u, v ) with w ( u, v ) ≥ δα . Consider the point at which w ( u, v ) was incremented to δα . Consider G bi at this point in time. Only the weight of edges in G bi can be incremented, so ( u, v ) ∈ E ( G bi ) . Withoutloss of generality, u ∈ B high ∪ W high and v ∈ W low . Ever since the edge ( u, v ) entered G bi , u has been in B high ∪ W high and v has been in W low , since no vertex in W low can later be in B high ∪ W high by Claim 5.2.Each time w ( u, v ) is incremented, it is caused by an INCREMENT COUNTER message sent by some vertex y that moved from W low to D , for which ( u, v ) ∈ E ( y ) . Then since y was in W low , u ∈ B high ∪ W high ,19nd ( u, v ) ∈ E ( y ) , we have y ∈ N ( u ) . Thus y sends INCREMENT COUNTER to u . Therefore, everytime w ( u, v ) is incremented, c u is also incremented. Since w ( u, v ) = 2 δα , we have c u = 2 δα , which is acontradiction by Claim 5.3.We are now ready to put everything together to complete the analysis. For all j , let I j denote the j th iteration of type high degree. Then, by Claim 5.6 we have that for all j , A ( I j ) ≤ δα · | V ( G bi ) | , andby Claim 5.8 we have that for all j , E [ w ( I j )] ≥ α · | V ( G bi ) | / (where G bi is taken to be its value at thebeginning of iteration I j ). Thus, E [ w ( I j )] ≥ A ( I j ) / (8 δα ) .Thus, by item 1 of Claim 5.9, we have that if for all j , A ( I j +1 ) ≤ A ( I j ) − w ( I j ) , so for all j , we have E [ A ( I j +1 )] ≤ E [ A ( I j ) − w ( I j )] ≤ (1 − δα ) E [ A ( I j )] ≤ (1 − δα ) j · A ( I )= (1 − δα ) j · m (2 δα )= (1 − α ) j · α n. Let j = 50 cα log n . For any constant positive integer c , we have E [ A ( I j +1 )] < /n c . By Markov’sinequality and the fact that the available weight is always integral and non-negative, we have that A ( I j ) = 0 with high probability. By item 2 of Claim 5.9, the algorithm terminates before it reaches an iteration I ∗ with A ( I ∗ ) = 0 . Thus, the number of iterations of type high degree is O ( α log n ) with high probability. Acknowledgements
The authors would like to thank Quanquan Liu and Yosi Hezi for fruitful discussions.
References [AMZ97] Srinivasa R Arikati, Anil Maheshwari, and Christos D Zaroliagis. Efficient computation ofimplicit representations of sparse graphs.
Discrete Applied Mathematics , 78(1-3):1–16, 1997.[ASS19] Saeed Akhoondian Amiri, Stefan Schmid, and Sebastian Siebertz. Distributed dominating setapproximations beyond planar graphs.
ACM Transactions on Algorithms (TALG) , 15(3):1–18,2019.[AZO19] Zeyuan Allen-Zhu and Lorenzo Orecchia. Nearly linear-time packing and covering lp solvers.
Mathematical Programming , 175(1):307–353, 2019.[Bak94] Brenda S Baker. Approximation algorithms for np-complete problems on planar graphs.
Jour-nal of the ACM (JACM) , 41(1):153–180, 1994.[BE10] Leonid Barenboim and Michael Elkin. Sublogarithmic distributed mis algorithm for sparsegraphs using nash-williams decomposition.
Distributed Computing , 22(5-6):363–379, 2010.[BE14] Leonid Barenboim and Michael Elkin. Combinatorial algorithms for distributed graph coloring.
Distributed Computing , 27(2):79–93, 2014.20BF99] Gerth Stølting Brodal and Rolf Fagerberg. Dynamic representation of sparse graphs. In FrankK. H. A. Dehne, Arvind Gupta, J¨org-R ¨udiger Sack, and Roberto Tamassia, editors,
Algorithmsand Data Structures, 6th International Workshop, WADS ’99, Vancouver, British Columbia,Canada, August 11-14, 1999, Proceedings , volume 1663 of
Lecture Notes in Computer Science ,pages 342–351. Springer, 1999.[BPS20] Suman K. Bera, Noujan Pashanasangi, and C. Seshadhri. Linear time subgraph counting, graphdegeneracy, and the chasm at size six. In Thomas Vidick, editor, ,volume 151 of
LIPIcs , pages 38:1–38:20. Schloss Dagstuhl - Leibniz-Zentrum f¨ur Informatik,2020.[BS20] Suman K. Bera and C. Seshadhri. How the degeneracy helps for triangle counting in graphstreams. In Dan Suciu, Yufei Tao, and Zhewei Wei, editors,
Proceedings of the 39th ACMSIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems, PODS 2020, Port-land, OR, USA, June 14-19, 2020 , pages 457–467. ACM, 2020.[BU17] Nikhil Bansal and Seeun William Umboh. Tight approximation bounds for dominating set ongraphs of bounded arboricity.
Information Processing Letters , 122:21–24, 2017.[CC08] Miroslav Chleb´ık and Janka Chleb´ıkov´a. Approximation hardness of dominating set problemsin bounded degree graphs.
Information and Computation , 206(11):1264–1275, 2008.[CHS09] Andrzej Czygrinow, Michał Ha´n´ckowiak, and Edyta Szyma´nska. Fast distributed approxima-tion algorithm for the maximum matching problem in bounded arboricity graphs. In
Interna-tional Symposium on Algorithms and Computation , pages 668–678. Springer, 2009.[CHW08] Andrzej Czygrinow, Michal Ha´n´ckowiak, and Wojciech Wawrzyniak. Fast distributed approxi-mations in planar graphs. In
International Symposium on Distributed Computing , pages 78–92.Springer, 2008.[CN85] Norishige Chiba and Takao Nishizeki. Arboricity and subgraph listing algorithms.
SIAM Jour-nal on computing , 14(1):210–223, 1985.[DGKR05] Irit Dinur, Venkatesan Guruswami, Subhash Khot, and Oded Regev. A new multilayered PCPand the hardness of hypergraph vertex cover.
SIAM J. Comput. , 34(5):1129–1146, 2005.[DKM19] Janosch Deurer, Fabian Kuhn, and Yannic Maus. Deterministic distributed dominating setapproximation in the congest model. In
Proceedings of the 2019 ACM Symposium on Principlesof Distributed Computing , pages 94–103, 2019.[DR06] Irit Dinur and Omer Reingold. Assignment testers: Towards a combinatorial proof of the pcptheorem.
SIAM Journal on Computing , 36(4):975–1024, 2006.[DS14] Irit Dinur and David Steurer. Analytical approach to parallel repetition. In
Proceedings of theforty-sixth annual ACM symposium on Theory of computing , pages 624–633, 2014.[ELR18] Talya Eden, Reut Levi, and Dana Ron. Testing bounded arboricity. In Artur Czumaj, edi-tor,
Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms,SODA 2018, New Orleans, LA, USA, January 7-10, 2018 , pages 2081–2092. SIAM, 2018.21Epp94] David Eppstein. Arboricity and bipartite subgraph listing algorithms.
Information processingletters , 51(4):207–211, 1994.[ERR19] Talya Eden, Dana Ron, and Will Rosenbaum. The arboricity captures the complexity of sam-pling edges. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi,editors, , volume 132 of
LIPIcs , pages 52:1–52:14. SchlossDagstuhl - Leibniz-Zentrum f¨ur Informatik, 2019.[ERS20] Talya Eden, Dana Ron, and C. Seshadhri. Faster sublinear approximation of the number of k -cliques in low-arboricity graphs. In Shuchi Chawla, editor, Proceedings of the 2020 ACM-SIAMSymposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020 ,pages 1467–1478. SIAM, 2020.[Gar79] Michael R Garey. A guide to the theory of np-completeness.
Computers and intractability ,1979.[GG06] Gaurav Goel and Jens Gustedt. Bounded arboricity to determine the local structure of sparsegraphs. In
International Workshop on Graph-Theoretic Concepts in Computer Science , pages159–167. Springer, 2006.[GGR21] Mohsen Ghaffari, Christoph Grunau, and V´aclav Rozhoˇn. Improved deterministic networkdecomposition. In
Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms(SODA) , pages 2904–2923. SIAM, 2021.[GKM17] Mohsen Ghaffari, Fabian Kuhn, and Yannic Maus. On the complexity of local distributedgraph problems. In
Proceedings of the 49th Annual ACM SIGACT Symposium on Theory ofComputing , pages 784–797, 2017.[GS17] Mohsen Ghaffari and Hsin-Hao Su. Distributed degree splitting, edge coloring, and orienta-tions. In Philip N. Klein, editor,
Proceedings of the Twenty-Eighth Annual ACM-SIAM Sympo-sium on Discrete Algorithms, SODA 2017, Barcelona, Spain, Hotel Porta Fira, January 16-19 ,pages 2505–2523. SIAM, 2017.[HTZ14] Meng He, Ganggui Tang, and Norbert Zeh. Orienting dynamic graphs, with applications tomaximal matchings and adjacency queries. In Hee-Kap Ahn and Chan-Su Shin, editors,
Al-gorithms and Computation - 25th International Symposium, ISAAC 2014, Jeonju, Korea, De-cember 15-17, 2014, Proceedings , volume 8889 of
Lecture Notes in Computer Science , pages128–140. Springer, 2014.[JLR +
13] Mark Jones, Daniel Lokshtanov, MS Ramanujan, Saket Saurabh, and Ondˇrej Such`y. Parame-terized complexity of directed steiner tree on sparse graphs. In
European Symposium on Algo-rithms , pages 671–682. Springer, 2013.[Joh74] David S Johnson. Approximation algorithms for combinatorial problems.
Journal of computerand system sciences , 9(3):256–278, 1974.[JRS02] Lujun Jia, Rajmohan Rajaraman, and Torsten Suel. An efficient distributed algorithm for con-structing small dominating sets.
Distributed Computing , 15(4):193–205, 2002.22KMW06] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. The price of being near-sighted. In
SODA , volume 6, pages 1109557–1109666. Citeseer, 2006.[KMW16] Fabian Kuhn, Thomas Moscibroda, and Roger Wattenhofer. Local computation: Lower andupper bounds.
Journal of the ACM (JACM) , 63(2):1–44, 2016.[Lin87] Nathan Linial. Distributive graph algorithms global solutions from local data. In , pages 331–335. IEEE, 1987.[Lin92] Nathan Linial. Locality in distributed graph algorithms.
SIAM Journal on computing ,21(1):193–201, 1992.[LW10] Christoph Lenzen and Roger Wattenhofer. Minimum dominating set approximation in graphsof bounded arboricity. In
International symposium on distributed computing , pages 510–524.Springer, 2010.[Mei09] Or Meir. Combinatorial pcps with efficient verifiers. In , pages 463–471. IEEE, 2009.[MV18] Andrew McGregor and Sofya Vorotnikova. A simple, space-efficient, streaming algorithm formatchings in low arboricity graphs. In Raimund Seidel, editor, , volume 61 of
OASICS ,pages 14:1–14:4. Schloss Dagstuhl - Leibniz-Zentrum f¨ur Informatik, 2018.[NA16] Jose C Nacher and Tatsuya Akutsu. Minimum dominating set-based methods for analyzingbiological networks.
Methods , 102:57–63, 2016.[OSSW18] Krzysztof Onak, Baruch Schieber, Shay Solomon, and Nicole Wein. Fully dynamic MIS inuniformly sparse graphs. In Ioannis Chatzigiannakis, Christos Kaklamanis, D´aniel Marx, andDonald Sannella, editors, , volume 107 of
LIPIcs ,pages 92:1–92:14. Schloss Dagstuhl - Leibniz-Zentrum f¨ur Informatik, 2018.[Pel00] David Peleg.
Distributed computing: a locality-sensitive approach . SIAM, 2000.[PS16] David Peleg and Shay Solomon. Dynamic (1+ ǫ )-approximate matchings: A density-sensitiveapproach. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12,2016 , pages 712–729. SIAM, 2016.[Qua20] Kent Quanrud. Nearly linear time approximations for mixed packing and covering problemswithout data structures or randomization. In
Symposium on Simplicity in Algorithms , pages69–80. SIAM, 2020.[RVW00] Omer Reingold, Salil Vadhan, and Avi Wigderson. Entropy waves, the zig-zag graph product,and new constant-degree expanders and extractors. In
Proceedings 41st Annual Symposium onFoundations of Computer Science , pages 3–13. IEEE, 2000.[SL10] Chao Shen and Tao Li. Multi-document summarization via the minimum dominating set. In
Proceedings of the 23rd International Conference on Computational Linguistics (Coling 2010) ,pages 984–992, 2010. 23SV20] Hsin-Hao Su and Hoa T. Vu. Distributed dense subgraph detection and low outdegree ori-entation. In Hagit Attiya, editor, , volume 179 of
LIPIcs , pages 15:1–15:18.Schloss Dagstuhl - Leibniz-Zentrum f¨ur Informatik, 2020.[WAF02] Peng-Jun Wan, Khaled M Alzoubi, and Ophir Frieder. Distributed construction of connecteddominating set in wireless ad hoc networks. In
Proceedings. Twenty-First Annual Joint Confer-ence of the IEEE Computer and Communications Societies , volume 3, pages 1597–1604. IEEE,2002.[You14] Neal E Young. Nearly linear-work algorithms for mixed packing/covering and facility-locationlinear programs. arXiv preprint arXiv:1407.3015arXiv preprint arXiv:1407.3015