On the Complexity of Local Distributed Graph Problems
OOn the Complexity of Local Distributed Graph Problems
Mohsen GhaffariETH Zurich, Switzerland [email protected]
Fabian Kuhn ∗ University of Freiburg, Germany [email protected]
Yannic Maus ∗ University of Freiburg, Germany [email protected]
Abstract
This paper is centered on the complexity of graph problems in the well-studied
LOCAL modelof distributed computing, introduced by Linial [FOCS ’87]. It is widely known that for many of theclassic distributed graph problems (including maximal independent set (MIS) and (∆ + 1)-vertexcoloring), the randomized complexity is at most polylogarithmic in the size n of the network, whilethe best deterministic complexity is typically 2 O ( √ log n ) . Understanding and potentially narrowingdown this exponential gap is considered to be one of the central long-standing open questions inthe area of distributed graph algorithms.We investigate the problem by introducing a complexity-theoretic framework that allows us toshed some light on the role of randomness in the LOCAL model. We define the
SLOCAL modelas a sequential version of the
LOCAL model. Our framework allows us to prove completeness results with respect to the class of problems which can be solved efficiently in the
SLOCAL model,implying that if any of the complete problems can be solved deterministically in poly log n roundsin the LOCAL model, we can deterministically solve all efficient
SLOCAL -problems (including MISand (∆ + 1)-coloring) in poly log n rounds in the LOCAL model.Perhaps most surprisingly, we show that a rather rudimentary looking graph coloring problemis complete in the above sense: Color the nodes of a graph with colors red and blue such thateach node of sufficiently large polylogarithmic degree has at least one neighbor of each color. Theproblem admits a trivial zero-round randomized solution. The result can be viewed as showing thatthe only obstacle to getting efficient determinstic algorithms in the
LOCAL model is an efficientalgorithm to approximately round fractional values into integer values .In addition, our formal framework also allows us to develop polylogarithmic-time randomizeddistributed algorithms in a simpler way. As a result, we provide a polylog-time distributed approx-imation scheme for arbitrary distributed covering and packing integer linear programs. ∗ Supported by ERC Grant No. 336495 (ACDC) a r X i v : . [ c s . D S ] O c t Introduction & Related Work
The question of whether a given distributed problem can be solved locally has been at the center ofthe theory of distributed graph algorithms since the 1980s, especially starting with the seminal work ofAwerbuch, Goldberg, Luby, and Plotkin [AGLP89], Linial [Lin92], and Naor and Stockmeyer [NS95].The locality of distributed computations is captured by the
LOCAL model [Lin92, Pel00], defined asfollows: a network is modeled as an undirected graph G = ( V, E ), the nodes V are the networkdevices, and the edges E are bidirectional communication links. Time is divided into synchronouscommunication rounds. In each round, each node can perform some arbitrary internal computation,send a message of possibly arbitrary size to each of its neighbors, and receive the messages sent toit by its neighbors. A typical objective in this setting is to solve some given graph problem on thenetwork G by a distributed algorithm. For example, classic problems include computing a vertex oran edge coloring with a given number of colors [AGLP89,BE10,BEPS12,BE13,BEK15,Bar15,CKP16,CV86, FHK16, GPS88, Lin92, HMKS16, HSS16, SV93], computing a maximal independent set (MIS)or a maximal matching [ABI86, BEPS12, HKP01, KMW16, Lub86, Lin92, Gha16], or approximatingclassic optimization problems with local constraints such as maximum matching, minimum vertexcover, or minimum dominating set [CHS04, DMP +
05, GS14, JRS02, KMW06, KMW16, Suo13]. In any r -round algorithm in the LOCAL model, the output of a node v can depend only on the initial statesof nodes in the r -hop neighborhood of v , but it can be an arbitrary function of this neighborhood[Lin92]. Therefore, the LOCAL model captures a core issue of distributed computations in a precisemathematical sense: What global goals can be achieved based on only local information.
The Role of Randomness:
A major challenge in designing fast distributed algorithms in the
LOCAL model is to break symmetries and coordinate actions among nearby nodes. It is maybe not surprisingthat this has turned out much easier if the nodes are allowed to use randomization. As a result,for many important problems, there currently is an exponential gap between the time complexity ofthe best randomized and the best deterministic distributed algorithms. Typically, an algorithm in the
LOCAL model is considered efficient if its time complexity is polylogarithmic in the number of nodes n .For a large number of fundamental distributed graph problems (including MIS and (∆ + 1)-coloring),there are logarithmic or polylog-time randomized distributed algorithms (e.g., [ABI86,Gha16,KMW06,Lin92, LS93, Lub86, HSS16]), whereas the best kown deterministic distributed algorithms have timecomplexity 2 O ( √ log n ) [AGLP89, PS95]. Understanding whether this exponential separation is inherentis considered to be one of the major long-standing open problems of the area [BE13, Lin92]. Recently,in [CKP16,GS17] (see also [BFH + LOCAL model, there are problems— e.g., ∆-coloring trees or computing a sinkless orientation — with a deterministic complexity ofΘ(log ∆ n ), while the randomized complexity is Θ(log log ∆ n ). However, the classic open question ofwhether such an exponential separation also holds when ignoring polylogarithmic factors remains open.One of the main objectives of our work is to shed some light on this long-standing open problem. A Complexity-Theoretic Perspective:
In this paper, we investigate the role of randomness indistributed graph algorithms from a complexity-theoretic viewpoint. In particular, we study the class P - LOCAL of all graph problems which can be solved deterministically in polylogarithmic time in the
LOCAL model and we define a much wider class P - SLOCAL of problems which informally consists ofall problems where the output of all nodes is determined by sequentially looking at a polylog-radiusneighborhood of each node. In particular, the class P - SLOCAL contains all the above mentioned classicproblems for which polylog-time randomized distributed algorithms are known and where the currentbest deterministic solutions require time 2 O ( √ log n ) . We prove that a number of natural distributed For example when computing a coloring with ∆ + 1 colors (where ∆ is the maximum degree of the network graph G ), with high probability, it suffices to iterate the following simple randomized coloring scheme O (log n ) times: Givenany partial initial coloring, each uncolored node v picks a uniformly random color among the colors still available to v .If v randomly picks a color x not chosen by any neighbor in the same iteration, v outputs color x and otherwise the colorof v remains undecided. P - SLOCAL -complete: If any of these problems has a deterministic polylog-timedistributed algorithm, all problems in P - SLOCAL can be solved deterministically in polylog time inthe
LOCAL model and thus P - LOCAL = P - SLOCAL .Perhaps most surprisingly, we prove that the following natural and rudimentary-looking rounding problem is P - SLOCAL -complete: We are given a bipartite graph B = ( U ˙ ∪ V, E ), where the degreeof each node in U is at least log c n for a desirably large constant c ≥
2. The objective is to coloreach node in V red or blue such that for each node in U , the degree is approximately equally split.In fact any coarse but non-trivial relaxation of ‘ approximately equal ’ suffices, e.g., it is enough if theneighbors in the two colors have the same size up to poly-logarithmic factors. Using randomization,this can be done without any communication—i.e., in zero rounds—via independently coloring eachnode in V red or blue with probability 1 /
2. The problem can be seen as a basic rounding problem withlinear constraints. Hence, in a certain sense, we show that the only obstacle to efficient deterministicdistributed algorithms is an efficient deterministic algorithm for rounding fractional to integer values . Implications on Randomized Distributed Algorithms:
From our completeness results, it alsoimmediately follows that all problems in P - SLOCAL have polylog-time randomized solutions in the
LOCAL model. Thus, in addition to providing a tool to study the hardness of local symmetry breakingand coordination problems, the P - SLOCAL model provides a useful abstraction that simplifies studyingwhat can be solved efficiently in the
LOCAL model when allowing randomization. In particular, weshow that computing (1 + ε )-approximate solutions for general covering and packing integer linearprograms is in P - SLOCAL . This directly implies that covering and packing integer linear programs(such as e.g., the minimum dominating set problem or the maximum independent set problem) canbe approximated arbitrarily well in polylogarithmic time in the
LOCAL model. This significantlyimproves the best existing algorithms for these problems [BEG15, BHKK16, JRS02, KMW16].In the following, we discuss our contributions and additional related work in more detail.
As argued, one of the main challenges in the
LOCAL model is to locally coordinate the parallel actions ofnearby nodes. Such local coordination becomes significantly easier if we remove the inherent parallelismof distributed computations and if the outputs of all the nodes can be computed sequentially, one nodeat a time. This can be well illustrated by the MIS or the (∆ + 1)-coloring problem. In both cases,there is a trivial greedy algorithm which sequentially processes all the nodes in an arbitrary order. Inorder to determine the output value of a node v , the sequential MIS and (∆ + 1)-coloring algorithmsmerely need to inspect the already computed outputs of the neighbors of v .We generalize the above basic greedy algorithms and define the SLOCAL model. In the
SLOCAL model, nodes are processed in an arbitrary order. When a node v is processed, it can see the currentstate of its r -hop neighborhood for some r ≥ v can locally store an arbitrary amount of information, which can be read by laternodes as part of v ’s state. We say that r is the locality of an algorithm in the SLOCAL model. Themodel is defined precisely and discussed more thoroughly in Section 2.3.The
SLOCAL model is loosely related to other sequential models in which, when studying a graphproblem, the output of a single node has to be determined by only considering a small part of the graph.In particular, we would like to mention
Local Computation Algorithms (LCA) [RTVX11,ARVX12]. InLCAs, the focus is on bounding the local computation and the space for computing the output of eachnode to a sublinear or even poly log n . In contrast, we purposefully do not bound local computationsor space in any way. As we later show completeness w.r.t. complexity classes of SLOCAL algorithms,we would like the
SLOCAL model to be as general as possible. Unlike the
SLOCAL model, LCAs allowsome shared randomness and sometimes also some small amount of global memory. We do not allowany globally shared state as this would make the model too powerful . E.g., even one bit of global memory would allow to solve leader election , which clearly cannot be solved locally. .2 Complexity Classes We introduce two basic complexity classes which are informally defined as follows. The class
LOCAL ( t )consists of all distributed graph problems which can be solved deterministically in t rounds in the LOCAL model. The class
SLOCAL ( t ) consists of all distributed graph problems which can be solveddeterministically with locality t in the SLOCAL model. For formal definitions of all the complexityclasses, refer to Section 2.4. Note that the simple greedy algorithms show that MIS and (∆ + 1)-coloring are in the class
SLOCAL (1), whereas we only know that they are in the class
LOCAL (cid:0) c √ log n (cid:1) for some constant c > LOCAL and
SLOCAL algorithms withlocality polylogarithmic in the number of nodes n . Thus, we define P - LOCAL := LOCAL (cid:0) log O (1) n (cid:1) and P - SLOCAL := SLOCAL (cid:0) log O (1) n (cid:1) to capture algorithms with polylogarithmic locality.Our approach can be viewed as an extension of the recent fundamental work of Fraigniaud, Korman,and Peleg in [FKP13] on the complexity of distributed decision problems . In a distributed decisionproblem, every node has to output either yes or no such that for yes-instances, all nodes output yes ,whereas for no-instances, at least one node outputs no . In [FKP13], the class LD ( t ) is defined as theset all distributed decision problems which can be solved in t rounds in the LOCAL model. The class
LOCAL ( t ) extends LD ( t ) to distributed search problems and we thus have LD ( t ) ⊂ LOCAL ( t ). The workstarted in [FKP13] lead to series of insightful results [FFH16, FKPP13, FGKS13, FHS15]. We wouldhowever like to stress that while in the standard sequential setting, there are standard techniques fortransforming many standard search problems into decision problems, the situation is very different inthe distributed setting. In fact, most of the standard distributed search problems cannot be reducedto corresponding decision versions and studying decision problems is not sufficient to capture some ofthe core difficulties when developing algorithms for the LOCAL model.
We will show that all the problems in P - SLOCAL can be solved in randomized polylog time and indeterministic 2 O ( √ log n ) time in the LOCAL model. Hence, except for the potential additional powerof using randomization in the
SLOCAL model, the class (deterministic) P - SLOCAL exactly captureswhat can be solved in polylog randomized time in the
LOCAL model. To understand the separationbetween randomized and deterministic distributed algorithms, we thus need to study the deterministiccomplexity of the problems in P - SLOCAL in the
LOCAL model.For distributed graph problems P and P , we say that P is polylog-reducible to P if a polylog-timedeterministic distributed algorithm for P implies a polylog-time deterministic distributed algorithmfor P . We define a problem P to be P - SLOCAL -complete if P ∈ P - SLOCAL and any problem in P - SLOCAL is polylog-reducible to P . Hence, if any P - SLOCAL -complete problem can be solved de-terministically in polylog time in the
LOCAL model, we have P - LOCAL = P - SLOCAL and thus allproblems in P - SLOCAL have deterministic polylog-time
LOCAL algorithms.The best known deterministic algorithms for MIS and (∆ + 1)-coloring, as well as for many otherproblems in P - SLOCAL are based on a decomposition of the network into clusters of small diameter,which was defined by Awerbuch et al. in [AGLP89].
Definition 1.1 ( Network Decomposition ) . [AGLP89] A weak (strong) (cid:0) d ( n ) , c ( n ) (cid:1) -decomposition of an n -node graph G = ( V, E ) is a partition of V into clusters such that each cluster has weak (strong)diameter at most d ( n ) and the cluster graph is properly colored with colors , . . . , c ( n ) . In [AGLP89], it is shown that for d ( n ) = c ( n ) = 2 O ( √ log n log log n ) , such a decomposition can becomputed deterministically in 2 O ( √ log n log log n ) rounds in the LOCAL model. This was later improved byPanconesi and Srinivasan who managed to get rid of the log log n terms in all the above bounds [PS95].It is not hard to see that given a (cid:0) d ( n ) , c ( n ) (cid:1) -decomposition, an MIS, a (∆ + 1)-coloring, and in factmany other standard graph problems can be computed deterministically in time O (cid:0) d ( n ) c ( n ) (cid:1) in the3 OCAL model. Using the decomposition of [PS95], this results in deterministic distributed algorithmswith time complexity 2 O ( √ log n ) .In [LS93], Linial and Saks show that every graph has a (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition and thatsuch a decomposition can be computed by a randomized algorithm in O (log n ) rounds. It has com-monly been understood that the network decomposition problem takes a central role in understandingthe complexity of local distributed computations [ABCP96,AGLP89,Bar12,BEG15,EN16,LS93,PS95].We make the key significance of network decomposition formal by proving the following theorem.
Theorem 1.1.
The problem of computing a weak or strong (poly log n, poly log n ) -decomposition of agiven n -node network graph G is P - SLOCAL -complete.
Given the order π in which an SLOCAL -algorithm A processes the nodes of a graph G , there is adirect way to execute A in a distributed setting. If the locality of A is r , a node v can compute itsoutput as soon as all nodes within distance r which appear before v in π have computed their outputs.If the maximum length of such a dependency chain is T , this leads to a T r -round distributed algorithmfor A . Unfortunately, the maximum dependency chain cannot be bounded by a small function, e.g.,if G is a complete graph, there is always a dependency chain of length n . However, in the LOCAL model, for a node v to determine its output in R rounds, it suffices if v can learn all its dependencychains, i.e., if all the dependency chains of v are contained in the R -neighborhood of v in G . A given SLOCAL -algorithm thus has an efficient distributed implementation if we can find an order π on thenodes such that any dependency chain is contained in a small-diameter neighborhood. Definition 1.2 ( Low Diameter Ordering ) . Given an n -node graph G = ( V, E ) , a d ( n )-diameterordering of G is an assignment of unique labels to all nodes V such that for any path P on which thelabels are increasing along P , any two nodes of P are within distance d ( n ) in G . Note that on the complete graph, any order π is a 1-diameter ordering. We will show that every n -node graph G has an O (log n )-diameter ordering and that we get the following theorem. Theorem 1.2.
There is a constant c > such that for every function d ( n ) with c ln n ≤ d ( n ) =log O (1) n , computing a d ( n ) -diameter ordering of an n -node graph G is P - SLOCAL -complete.
Using a network decomposition or a low-diameter ordering, there is a relatively direct way of turninga given
SLOCAL -algorithm into a distributed one. In addition, we show P - SLOCAL -completeness ofthe following extremely rudimentary looking problems.
Definition 1.3 ( Local Splitting ) . Given is a bipartite graph B = ( U ˙ ∪ V, E B ) where E B ⊆ U × V .For any λ ∈ [0 , / , we define a λ -local splitting of B to be a -coloring of the nodes in V with colorsred and blue such that each node v has at least (cid:98) λ · d ( v ) (cid:99) neighbors of each color. Definition 1.4 ( Weak Local Splitting ) . Given is a bipartite graph B = ( U ˙ ∪ V, E B ) where E B ⊆ U × V . We define a weak local splitting of B to be a -coloring of the nodes in V with colors red andblue such that each node v has at least neighbor of each color. If the minimum degree of any node in U is at least c ln n for a sufficiently large constant c , then λ -local splitting (even for λ close to 1 /
2) and weak local splitting can be solved trivially in 0 roundsby using randomization: Color each node in V independently red or blue with probability 1 /
2; thiscoloring satisfies the required conditions, with high probability. The following two theorems are themain technical contribution of our paper. They show that, in some sense, the above local splittingproblems—even the weak local splitting—already capture the core of the difficulty in designing polylog-time deterministic
LOCAL algorithms. As pointed out in [LS93], the existence of a (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition essentially already follows implicitlyfrom the work of Awerbuch and Peleg [AP90]. heorem 1.3. For bipartite graphs H = ( U ˙ ∪ V, E ) where all nodes in U have degree at least c ln n fora large enough constant c , the λ -local splitting problem for any λ = n is P - SLOCAL -complete.
Theorem 1.4.
For bipartite graphs H = ( U ˙ ∪ V, E ) where all nodes in U have degree δ/ < d ( u ) ≤ δ ,for any δ such that c ln n ≤ δ = log O (1) n for a sufficiently large constant c , the weak local splittingproblem is P - SLOCAL -complete.
The local splitting problem can be viewed as a very special case of rounding , i.e., turning fractionalvalues to integral values while respecting some linear constraints: Associate a variable x v with eachvertex v ∈ V and think of each vertex u ∈ U as two linear constraints, λ ∆ ≤ (cid:80) v ∈ N ( u ) x v ≤ (1 − λ )∆.Setting each x b = 1 / λ = 1 /
2. The objective is to round these 1 / { , } while respecting much weaker constraints, which are given by λ -values assmall as λ = 1 / poly log n . Theorem 1.3 can therefore intuitively be interpreted as follows: Coarsely rounding fractional numbers is essentially all that we do not know how to perform in poly log n deterministic rounds of the LOCAL model. If one can could do even coarse roundingin P - LOCAL , we could solve all the classic problems of the
LOCAL model in P - LOCAL . As an intermediate step to prove the P - SLOCAL -completeness of the local splitting problems, weconsider distributed algorithms for the conflict-free multicoloring problem. This is a natural relaxationof the conflict-free coloring problem which was introduced in [ELRS03] in the context of frequencyassignment in cellular networks. Note that the relaxation only strengthens the completeness result.
Definition 1.5 ( Conflict-Free Multicoloring ) . [ELRS03] A q -color multicoloring of a hyper-graph H = ( V, E ) is a function φ : V → [ q ] \ ∅ which assigns a nonempty subset φ ( v ) of the colors [ q ] to each node v . A multicoloring φ is called conflict-free if for each hyperedge e ∈ E , there exists atleast one color c such that |{ v ∈ e | c ∈ φ ( v ) }| = 1 , i.e., exactly one node in e has color c ∈ φ ( v ) . If each node is assigned exactly one color, such a coloring is called a conflict-free coloring. Notethat the conflict-free coloring problem is a generalization of the standard graph coloring problem. Fora survey on various work related to conflict-free coloring, we refer to [Smo13].
Theorem 1.5.
Conflict-free multicoloring with poly log n colors in almost uniform hypergraphs with poly n hyperedges is P - SLOCAL -complete.
Because using randomization, an (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition can be computed in O (log n )time in the LOCAL model [ABCP96, LS93, EN16], the P - SLOCAL -completeness of the decompositionproblem (Theorem 1.1) directly implies that all problems in P - SLOCAL have randomized polylog-timesolutions in the
LOCAL model. In fact, something slightly stronger holds. Let
RLOCAL ε ( t ) be theproblems which can be solved by a randomized Monte Carlo algorithm with error probability at most ε in the LOCAL model in at most t rounds. Further, RSLOCAL ε ( t ) is the corresponding randomizedclass for the SLOCAL model and we use P - RLOCAL ε and P - RSLOCAL ε to denote the correspondingrandomized classes of problems with polylogarithmic complexity. Theorem 1.6. P - RSLOCAL ε ( n ) ⊆ P - RLOCAL ε ( n )+ / n c for all ε ( n ) ≥ and every constant c > . Hence, in particular, P - SLOCAL ⊆ P - RLOCAL / poly( n ) . In Section 7, we show that as long as allthe constraints are local, arbitrarily good approximations of general distributed covering and packinginteger linear programs can be computed efficiently in the SLOCAL model. This includes many im-portant classic optimization problems, such as e.g., minimum (weighted) dominating set, minimum(weighted) vertex cover, maximum (weighted) independent set, maximum (weighted) matching.5 heorem 1.7.
The problem of computing a (1 + 1 / poly log n ) -approximation of a general distributedcovering or packing integer linear program (with polynomially bounded weights) is in P - SLOCAL andhence also in P - RLOCAL / n c for every constant c > . Definition 2.1 (Distributed Graph Problem) . A distributed graph problem T is given by a set oftriples of the form ( G, x , y ) , where G = ( V, E ) is a simple, undirected graph and x and y are | V | -dimensional vectors with entries x v and y v for each node v ∈ V . We call x the input vector and y the output vector . A tuple ( G, x ) is called an instance of a graph problem T if there is an output vector y such that ( G, x , y ) ∈ T . Then y is called an admissible output for instance ( G, x ) .Whether a triple belongs to T or not depends only on the topology of the graph G . Hence, if thereis an isomorphism mapping G to ˜ G , then ( G, x , y ) ∈ T holds if and only if ( ˜ G, ˜ x , ˜ y ) ∈ T holds, where ˜ x and ˜ y are obtained from x and y by applying the graph isomorphism from G to ˜ G . Given an instance I = ( G, x ) of a graph problem T , initially each node v knows x v . We alwaysassume x v includes a unique ID for v and a global polynomial upper bound on n = | V | . In a distributedalgorithm, the nodes need to compute an admissible output vector y , where each node v ∈ V outputs y v . For instance, consider (∆ + 1)-vertex coloring, where ∆ denotes the maximum degree of G . Theproblem consists of all triples ( G, x , y ), where G = ( V, E ) is a simple, undirected graph, x containsunique IDs, and y v ∈ { , . . . , ∆ + 1 } such that for each { u, v } ∈ E , we have y u (cid:54) = y v . Remark:
For simplicity, we define inputs and outputs only for nodes. Edge related problems —e.g., edge coloring — can be easily modeled as inputs and outputs to the incident nodes. Similarly,hypergraph problems can be modeled as graph problems, where the locality is captured by a simplegraph in which two nodes u and v are adjacent iff u and v are in a common hyperedge. In a distributed graph problem T in the LOCAL model, each node v ∈ V of an instance I = ( G, x )initially learns its input x v , and must output y v by the end of the algorithm. The time complexity of a LOCAL algorithm A on I is the number of rounds until all nodes have completed the algorithm.Formally, the time complexity is a function T A : C → N , where C is the set of all possible instances.In the case of randomized LOCAL algorithms, each node can produce an arbitrarily long privaterandom bit string before it starts its computation. We focus on Monte Carlo randomized algorithms,which have fixed time complexity but may have some probability to err and produce an inadmissibleoutput. Let the random vector y denote the output vector of a randomized LOCAL algorithm A on aninstance I = ( G, x ) of T . The error probability ε A ( I ) of A on I is the probability that ( G, x , y ) / ∈ T . We define the sequential local model (
SLOCAL ) as follows: Assume a problem instance I = ( G, x )for G = ( V, E ) is given. For each node v ∈ V , there is an unbounded local memory S v to store thelocal state of v . Initially, S v contains only the private input x v of v . Then an algorithm A in the SLOCAL model processes the nodes sequentially in an order p = v , v , . . . , v n provided to A . Thealgorithm must work for any given order p . When processing node v , the algorithm can query r -hopneighborhoods of node v for different values of r , that is, A can read the values of S u for all nodes u in the r -neighborhood of v . Based on this information, node v updates its state S v and computes itsoutput y v . In doing so, node v can perform unbounded computation, i.e., the new state of S v can bean arbitrary function of the queried r -neighborhood of v . The output y v can be remembered as a part6f the new value of S v . In randomized algorithms, each node v produces an arbitrarily long privaterandom bit string at the start of the execution (independent of p ), which is stored in its initial state S v . The time complexity T A ,p ( I ) of the algorithm on I with respect to order p is defined as themaximum r over all nodes v for which the algorithm queries an r -hop neighborhood of node v . Thealgorithm’s time complexity T A ( I ) on instance I is the maximum of all T A ,p ( I ) over all orders p .Let the random vector y p denote the output of a randomized SLOCAL algorithm A on an instance I = ( G, x ) of T on node order p . The error probability ε A ( I ) of A on I is max p Pr(( G, x , y p ) / ∈ T ). Remarks:
Many of the classic problems—e.g., maximal independent set, (∆ + 1)-vertex coloring,(2∆ − SLOCAL model with locality O (1).Roughly speaking, we can say that any problem in which any correct partial solution can be extendedto a global solution using only local knowledge has a small locality in the SLOCAL model.In studying
SLOCAL algorithms, it is convenient to allow nodes to write in the local memory ofother nearby nodes. It is easy to see that this does not change the locality significantly. Concretely:
Observation 2.1.
Any
SLOCAL algorithm A with locality R in which each node v can write into thelocal memory S u of other nodes u within its radius r ≤ R can be transferred into an SLOCAL algorithm B with locality r + R in which v writes only in its own memory S v . Furthermore, as explained above, the
SLOCAL model assumes a single-phase of processing verticesin an order p = v , v , . . . , v n . One can envision a generalization to k -phase algorithms, which cango through the order k times. However, perhaps somewhat surprisingly, for any k ≤ poly log n , thisgeneralization does not significantly increase the power of the model, as we prove in Lemma 2.2. Itsproof, which is deferred to Section 8, uses some techniques that are similar to those of Section 3. Lemma 2.2.
Any k -phase SLOCAL algorithm A with locality r i in phase i = 1 , . . . , k can be trans-formed into a single-phase SLOCAL algorithm B with locality r + 2 (cid:80) ki =2 r i . We next define the complexity classes. Let C be the collection of all instances ( G, x ). A runtimefunction is a function t : C → Z + and an error function is a function ε : C → [0 , A has locality t if T A ( I ) ≤ t ( I ). We focus on (upper bound) runtime and error functionswhich depend only on the number of the graph vertices in I . Hence, we simply write t ( n ) and ε ( n ). Definition 2.2.
For any runtime function t and error function ε define: LOCAL ( t ): All graph problems T for which there exists a deterministic distributed LOCAL algorithm A such that for every instance I of T , we have T A ( I ) ≤ t ( I ) . RLOCAL ε ( t ): All graph problems T for which there exists a randomized distributed LOCAL algorithm A such that for every instance I of T , we have T A ( I ) ≤ t ( I ) and ε A ( I ) ≤ ε ( I ) . SLOCAL ( t ): All graph problems T for which there exists a deterministic distributed SLOCAL algo-rithm A such that for every instance I of T , we have T A ( I ) ≤ t ( I ) . RSLOCAL ε ( t ): All graph problems T for which there exists a randomized distributed SLOCAL algo-rithm A such that for every instance I of T , we have T A ( I ) ≤ t ( I ) and ε A ( I ) ≤ ε ( I ) . Each deterministic class is trivially contained in its randomized counterpart. Moreover, the classesrelated to the
LOCAL model are contained in their
SLOCAL model counterparts. Concretely, if in a
LOCAL -algorithm, the nodes know an upper bound r on the runtime, this can be transferred into analgorithm which first collects the r -hop neighborhood and then computes the output. Thus, we have:7 emma 2.3. LOCAL ( t ( n )) ⊆ SLOCAL ( t ( n )) and RLOCAL ε ( t ( n )) ⊆ RSLOCAL ε ( t ( n )) , for every t ( n ) . We use the O -notation for runtime in the natural way: the class of all graph problems for whichthere is a sequential O ( t ( n ))-local algorithm is denoted by SLOCAL ( O ( t ( n ))) := (cid:83) c> SLOCAL ( ct ( n )).Our focus is on algorithms with polylogarithmic locality. We thus introduce short notations for theabove classes when the locality is polylogarithmic in the number of nodes n : P - LOCAL := (cid:91) c> LOCAL (log c n ) , P - RLOCAL ε := (cid:91) c> RLOCAL ε (log c n ) , P - SLOCAL := (cid:91) c> SLOCAL (log c n ) , P - RSLOCAL ε := (cid:91) c> RSLOCAL ε (log c n ) . We now define reductions for distributed algorithms. An overlay graph of a graph G = ( V, E ) isa graph G = ( V , E ), where each node x ∈ V is mapped to a node v ( x ) ∈ V . An overlay graph G is called r -simulatable if for every edge { x, y } ∈ E , we have d G ( v ( x ) , v ( y )) ≤ r . In our reductions, LOCAL algorithms are augmented with oracles for a given graph problem T . After calling a T -oracleon overlay graph G = ( V , E ), for each x ∈ V , node v ( x ) ∈ V is provided with the output of the oraclefor node x . Definition 2.3 (Reduction) . A (randomized) reduction from a graph problem T to a graph problem T is a (randomized) LOCAL algorithm for T which can use calls to a T -oracle with instances onoverlay graphs of G . The cost of a reduction is the cost of the LOCAL algorithm where each oraclecall on an r -simulatable overlay graph contributes r rounds. In the case of a randomized reduction,the randomness of all oracle instances and the reduction algorithm are independent. As standard, a reduction from a graph problem T to a graph problem T transfers a LOCAL algorithm for T to a LOCAL algorithm of T : Observation 2.4.
If there is a reduction from T to T and a t ( n (cid:48) ) round LOCAL algorithm for T then there is a t ( n ) · t ( n (cid:48) ) round LOCAL algorithm for T , where t ( n ) is the cost of the reduction and n (cid:48) is the size of the largest overlay graph used in the reduction. Definition 2.4. (Hardness and Completeness) We say that a graph problem T is C -hard , for acomplexity class C , with respect to t O (1) ( n ) -cost reductions if every graph problem in C reduces to T and the cost of each reduction is in t O (1) ( n ) . We say that T is C -complete with respect to t O (1) ( n ) -costreductions if T is C -hard with respect to t O (1) ( n ) -cost reductions and T ∈ C . Throughout the paper we are mostly interested in poly log n cost reductions. If a problem T canbe reduced to a problem T with a polylog-cost reduction we say that T is polylog-reducible to T . In this section we prove that the problems of computing a low diameter ordering and network decom-position are P - SLOCAL -hard. See Definition 1.2 and Definition 1.1 for the definitions, respectively.
Notation:
For a graph G = ( V, E ), we use G r to denote the graph on vertex set V obtained byputting an edge between each two vertices of G with distance at most r . Lemma 3.1.
For any d ( n ) = log O (1) n , computing a d ( n ) -diameter ordering is P - SLOCAL -hard. roof. Consider an
SLOCAL algorithm A with locality r = poly log n and consider an n -node networkgraph G = ( V, E ). Assume that an (cid:96) -low diameter ordering π of the graph G r is provided by an oraclewhere (cid:96) = poly log n . We consider A when it operates on the order π .When processing the nodes according to the order π , a node v can collect its r -neighborhood andcompute its output, as soon as all nodes within distance r of v which appear before v in order π areprocessed. Hence, every path on G r which is monotonically increasing w.r.t. π induces a dependencychain for executing A . Given that π is an (cid:96) -diameter ordering of G r , each such dependency chain,which is relevant for processing v , is completely contained in the (cid:96) neighborhood of v in G r . Aftercollecting the r -neighborhoods in G of every node in the (cid:96) -neighborhood in G r , node v therefore hasenough information to locally simulate the part of the sequential execution of A which is relevant forprocessing node v . Thus, given an (cid:96) -diameter ordering of G r , algorithm A can be executed in O ( (cid:96)r )deterministic rounds in the LOCAL model.The best known deterministic algorithms for many problems in P - SLOCAL are based on networkdecompositions (cf. Definition 1.1). In fact network decompositions directly imply low-diameter or-derings and thus are sufficient to simulate polylogarithmic
SLOCAL algorithms.
Observation 3.2.
If we are given a (cid:0) d ( n ) , c ( n ) (cid:1) -decomposition and assign to each vertex v ∈ G alabel ( q v , ID v ) where q v is the color of v ’s cluster, then the lexicographically increasing order of the nodelabels ( q v , ID v ) defines a O (cid:0) d ( n ) · c ( n ) (cid:1) -diameter ordering. Lemma 3.3.
Computing a (poly log n, poly log n ) -decompositon is P - SLOCAL -hard.Proof.
The result follows with Lemma 3.1 and Observation 3.2.The completeness of low diameter orderings and network decompositions (Theorem 1.1 and The-orem 1.2) follows by an adaption of the deterministic sequential (cid:0) O (log n ) , O (log n ) (cid:1) -decompositionalgorithm from [LS93] to the SLOCAL model (cf. Section 8).The network decomposition algorithm of Awerbuch et al. [AGLP89] computes a (cid:0) O ( √ log n ) , O ( √ log n ) (cid:1) -decomposition deterministically in the LOCAL model. This algorithm combined with Observation 3.2and the same simulation as in the proof of Lemma 3.1 yields the following lemma.
Lemma 3.4.
SLOCAL (cid:0) O ( √ log n ) (cid:1) = LOCAL (cid:0) O ( √ log n ) (cid:1) . Remark.
In general, for t ( n ) ≥ log n , SLOCAL (cid:0) t O (1) ( n ) (cid:1) = LOCAL (cid:0) t O (1) ( n ) (cid:1) holds if and only ifa (cid:0) t c ( n ) , t c ( n ) (cid:1) -network decomposition can be computed deterministically in O (cid:0) t c ( n ) (cid:1) rounds in the LOCAL model for some constant c > . In the present section, we provide an outline over the proof that the local splitting problems definedin Definitions 1.3 and 1.4 are P - SLOCAL -complete. The formal proof appears in Sections 5 and 6. Weneed to show that local splitting is in the class P - SLOCAL and that local splitting is P - SLOCAL -hard,i.e., that there is a polylog-reduction, reducing one of the problems we have already shown to be P - SLOCAL -complete to local splitting. We do this reduction in two steps. We first reduce the conflict-free multicoloring problem (cf. Definition 1.5) to local splitting and we then reduce the problemof computing a (poly log n, poly log n )-decomposition to the conflict-free multicoloring problem (cf.Definition 1.1 and Theorem 1.1). 9 .1 Reducing Conflict-Free Multicoloring to Local Splitting We next sketch how to use a λ -local splitting blackbox algorithm (for λ = 1 / poly log n ) to computea poly log n -color conflict-free multicoloring of a given n -node hypergraph H = ( V, E ). A reductionto weak local splitting then follows by applying a simple reduction from λ -local splitting which wedescribe in Lemma 6.3.By using a distributed defective coloring algorithm from [Kuh09], we first show in Lemma 6.2that for hypergraphs of at most poly log n rank, a poly log n -color conflict-free multicoloring can becomputed in deterministic polylog time in the LOCAL model. The reduction then works in phases,where in each phase, we remove some hyperedges and nodes from H . We define δ := 1 /λ , note that thisimplies that δ = poly log n . In each phase, we first apply Lemma 6.2 and assign a new set of poly log n colors to make sure that for all hyperedges e of rank at most δ of the current graph H , there exists acolor x such that exactly one node in e has color x . This allows to remove all hyperedges of rank atmost δ . We then interpret the resulting hypergraph H as a bipartite graph in the obvious way and weapply our λ -local splitting oracle to this bipartite graph so that all nodes of H are either colored redor blue and so that each hyperedge e has at least (cid:98) λ | e |(cid:99) nodes of each color. We then remove all bluenodes from the graph H . Because after the removal of the low-rank hyperedges, all hyperedges haverank > δ , the λ -local splitting guarantees that each hyperedge has at least one red node. Thereforea conflict-free multi-coloring of the hypergraph after removing the blue nodes is also a conflict-freemulti-coloring of the hypergraph before removing the blue nodes. Because each hyperedge e has atleast (cid:98) λ | e |(cid:99) blue nodes which are removed, the removal of the blue nodes reduces the maximum rankof the hypergraph H by a factor 1 − / Θ( λ ). Because the maximum rank at the beginning is at most n , the number of phases is at most O (log( n ) /λ ) and thus O (poly log n ). Thus, the number of colorsthat we use for the conflict-free multicoloring is also O (poly log n ). We conclude this section by giving an overview of how to use conflict-free multicoloring to compute anetwork decomposition. The resulting decomposition algorithm bears some high-level similarities toexisting randomized graph decomposition algorithms (e.g., [LS93, BGK +
14, EN16]). Assume that wehave a q -color conflict-free multicoloring algorithm for almost uniform n -node hypergraphs for some q = poly log n and assume that we need to compute a (poly log n, poly log n )-decomposition of somegraph G = ( V, E ). As a first step, each node v ∈ V looks for a sequence of q + 1 consecutive radii r v , r v + 1 , . . . , r v + q such that all the balls B r v + i ( v ) for i ∈ { , . . . , q } have the same size up to a factor(1 ± ε ) for a given constant ε >
0. Using standard ball growing arguments [Awe85, AP90, LS93], thereexists such a radius of value r v = O ( q log( n ) /ε ) and clearly in the LOCAL model such a radius canthen also be found in O ( q log( n ) /ε ) rounds for each node.Each node now forms q +1 hyperedges for its balls B r v ( v ) , . . . , B r v + q ( v ) and the reduction constructs O (log( n ) /ε ) hypergraphs such that in each of them all hyperedges have the same size up to a (1 ± O ( ε ))-factor and such that all hyperedges of a given node v are in the same hypergraph. For each ofthese hypergraphs, we use the conflict-free multicoloring oracle to compute a q -color conflict-freemulticoloring. Because each node has q + 1 hyperedges and the nodes in these hyperedges are conflict-free colored with q colors, by the pigeonhole principle, there is a color x and two radii r v + a and r v + b for 0 ≤ a < b ≤ q such that in B r v + a ( v ) and B r v + b ( v ), there is exactly one node w colored with color x . Clearly, for both balls, it has to be the same node. Node v chooses this node w as its “clustercenter” and it chooses color x as its cluster color. Because node w is within radius r v + a of v andthere is no other node of color x within radius r v + b ≤ r v + a + 1 of v , whenever a neighbor u of v alsochooses color x , node u also has to choose w as its cluster center. Hence, for every cluster color, anytwo nodes within the same connected component have the same cluster center and are thus withinradius O ( q log( n ) /ε ) in graph G . As we assumed that q = poly log n , this implies that the computedcoloring directly induces a (poly log n, poly log n )-decomposition.10 .3 Weak Local Splitting is in P - SLOCAL
We here only discuss how to design an
SLOCAL algorithm with polylog locality to compute a weaklocal splitting for a given bipartite graph B = ( U ˙ ∪ V, E B ) where each node in U has degree c ln n for asufficiently large constant c . An algorithm for λ -local splitting can then be obtained by using a simplereduction, which is described in Lemma 6.3. Using Lemma 2.2, we can design a multi-phase SLOCAL algorithm to show that weak local splitting is in P - SLOCAL . The algorithm is based on first computinga ( O (log n ) , O (log n ))-decomposition of the graph G = ( V, E ), where there is an edge between u and v in V if and only if u and v have a common U -neighbor in B . It is shown in Lemma 9.2 that computingsuch a decomposition is in P - SLOCAL . We can use the network decomposition to compute weaklocal splitting as follows. Each cluster locally computes a red/blue-coloring of its nodes in O (log n )rounds. The probabilistic method guarantees that each cluster C can compute such a coloring suchthat for every node u of which C contains at least d ln n neighbors for a sufficiently large constant d ,the neighborhood N ( u ) becomes bichromatic. The decomposition guarantees that the neighborhoodof each node u ∈ U is partitioned among at most O (log n ) clusters. Because we assume that theminimum degree in U is at least c ln n (for c sufficiently large), for every node u ∈ U , there is acluster which contains at least d ln n neighbors of u . Hence, we get a weak local splitting of the wholegraph. In the present section, we study the distributed complexity of conflict-free multicoloring of hyper-graphs (cf. [ELRS03, Smo13] and Definition 1.5). Recall that a q -color conflict-free multicoloring of ahypergraph H = ( V, E ) is an assignment of a nonempty set φ ( v ) of colors from [ q ] to each node v ∈ V such that for every hyperedge e ∈ E , there is a color x such that there is exactly one node in e whichhas color x in its set φ ( v ). Note that in the special case of simple graphs, when each hypergraph con-tains only a pair of nodes, and if only one color is allowed per node, conflict-free coloring is equivalentto the standard definition of proper graph coloring.In the following, for a given constant 0 < ε <
1, we call a hypergraph H = ( V, E ) almost uniform if there is an arbitrary k such that for each edge e ∈ E , k ≤ | e | ≤ (1 + ε ) k . In the following, we proveTheorem 1.5. Theorem 1.5 (restated).
Conflict-free multicoloring with poly log n colors in almost uniform hy-pergraphs with poly n hyperedges is P - SLOCAL -complete.Proof.
The proof follows directly from the statements of Lemmas 5.2 and 5.3 which are proven nextin Sections 5.1 and 5.2.Before presenting the proofs of Lemmas 5.2 and 5.3, we remark that conflict-free multicoloring istrivial to solve using randomized algorithms with even zero locality.
Observation 5.1.
There is a zero round randomized
LOCAL algorithm that in any almost uniformhypergraph with poly( n ) hyperedges computes an O (log n ) -color conflict-free multi-coloring.Proof. Set q = Θ(log n ) and define a multi-coloring φ : V → [ q ] \ ∅ by including each color c ∈ [ q − φ ( v ) with probability k . If φ ( v ) = ∅ , set φ ( v ) = { q } . This is a conflict-free coloring, with highprobability: for each hyperedge e ∈ E and each color c ∈ [ q − |{ v ∈ e | c ∈ φ ( v ) }| = 1] ≥| e | k (cid:0) − k (cid:1) | e |− ≥ .
1. Hence, the probability that no color c ∈ [ q −
1] satisfies |{ v ∈ e | c ∈ φ ( v ) }| = 1is 0 . C log n = 1 / poly( n ). A union bound over all hyperedges e ∈ E completes the proof.11 .1 Conflict-Free Multicoloring is P - SLOCAL -Hard
We now first show that conflict-free multicoloring of almost uniform hypergraphs with poly log n colorsis P - SLOCAL -hard. We show this by showing that the problem of computing a (poly log n, poly log n )-decomposition of a graph is polylog-reducible to the conflict-free multicoloring problem. Lemma 5.2.
The problem of computing a q -color conflict-free multicoloring of an almost uniformhypergraph with q = poly log n colors is P - SLOCAL -hard.Proof.
Assume that for some given 0 < ε < q = log O (1) n , such that for every k ≤ n , we have anoracle to compute a q -color conflict-free multicoloring of a given n -node hypergraph H = ( V H , E H ) withpolynomially many hyperedges and where for each hyperedge e ∈ E H , k ≤ | e | ≤ (1 + ε/ k < (1 + ε ) k .We use O (log n/ε ) iterations of the q -color multicoloring oracle to compute a (poly log n, poly log n )-decomposition of a given graph G = ( V, E ) in polylogarithmic deterministic time in the
LOCAL model.Since Lemma 3.3 shows that (poly log n, poly log n )-network decomposition is P - SLOCAL -hard, we getthat q -color multicoloring of almost uniform hypergraphs is also P - SLOCAL -hard.
Construction of the hypergraphs H , . . . , H (cid:96) . We first define (cid:96) = O (log n/ε ) almost uniformhypergraphs H , H , . . . , H (cid:96) on the node set V . For each vertex v , let B r ( v ) denote the set of allvertices within distance r of v in graph G . Let r v be the smallest radius r such that | B r + q ( v ) || B r ( v ) | ≤ ε/ r v ≤ O ( q log n/ε ). This is because, otherwise, with every q additive increase in the radius ofthe ball B r ( v ), its size would grow by a (1 + ε/
3) factor and this cannot happen more than O (log n/ε )many times. Include q + 1 hyperedges, each defined by one of the vertex sets B r v ( v ), B r v +1 ( v ), . . . , B r v + q ( v ), all in the hypergraph H i such that i = (cid:98) log ε/ | B r v ( v ) |(cid:99) . Perform this for each vertex v .Note that every node v can perform this step and define its hyperedges in the LOCAL model in O (cid:0) q log nε (cid:1) rounds. Notice that each hypergraph H i is almost uniform because each hyperedge e ∈ H i has size (1 + ε/ i ≤ | e | < (1 + ε/ · (1 + ε/ i . Furthermore, each hyperedge of each H i has radius atmost R = O ( q log n/ε ) in G and thus a round of communication on H i can be simulated in O ( q log n/ε )rounds on G . Construction of network decomposition.
We make (cid:96) = O (log n/ε ) (parallel) calls to the q -color multicoloring oracle to compute a q -color conflict-free multicoloring for each hypergraph H i ,where the coloring of H i for i ∈ [ (cid:96) ] uses colors in [1 + ( i − q, iq ]. We claim that this provides a(2 R, q(cid:96) )-decomposition.Define the network decomposition as follows. For each vertex v ∈ G , we define a cluster centerand a cluster color. The cluster centers and cluster colors are defined as follows. Consider thehyperedges corresponding to the hyperedges B r v ( v ), B r v +1 ( v ), . . . , B r v + q ( v ) in H i . Associate each ofthese hyperedges e with one color c ∈ [1 + ( i − q, iq ] such that exactly one vertex in e has color c .Note that such a color exists by the definition of a conflict-free multicoloring. Since there are q + 1hyperedges, one corresponding to each ball, and they are associated with only q colors in [1+( i − q, iq ],by the pigeonhole principle, there are two radii r , r ∈ [ r v , r v + q ], r < r , such that the hyperedgescorresponding to B r ( v ) and B r ( v ) are associated with the same color c ∈ [1 + ( i − q, iq ]. Therefore,there is a node u ∈ B r ( v ) that is colored with color c and this is the only vertex in B r ( v ), and thus alsoin B r +1 ( v ), that is colored with color c . Then, v will be in a cluster of color c and the cluster-center Center ( v ) := u . Notice that when defining t := dist ( v, Center ( v )), we have the following uniqueness property: the node Center ( v ) = u is the only node within distance t + 1 of v that has color c .To prove that we get a (2 R, q(cid:96) )-network decomposition, we argue that for each two neighboringnodes v and v which are in clusters of the same color c , we have Center ( v ) = Center ( v ). Let t = dist ( v , Center ( v )) and t = dist ( v , Center ( v )). Suppose that t ≥ t . Then, Center ( t ) iswithin distance t + 1 of v . By the uniqueness property stated above, Center ( v ) is the only nodewithin distance t + 1 of v that has color c . Hence, Center ( v ) = Center ( v ). We therefore get12hat any connected component of the same color has weak diameter at most 2 R , which concludes theproof. P - SLOCAL
Lemma 5.3.
There is an
SLOCAL algorithm with locality poly log( n ) that finds an O (log n ) -colorconflict-free multi-coloring in any almost uniform hypergraph with poly( n ) hyperedges.Proof. We describe an O (log n )-phase conflict-free multi-coloring algorithm. This can be transferredinto a single-phase algorithm using Lemma 2.2. Using Observation 2.1, we can also assume that whenprocessing a node u , u can write into the memory of nodes in its polylog-neighborhood. In each phase,we use one new color such that the number of hyperedges which do not have a unique color reducesby a constant factor. Consider the i th phase. Suppose that v , v , . . . , v n is the provided order andwe are now working on v j . Let B r ( v ) be the set of vertices within distance r of v and E [ B r ( v )] be theset of hyperedges with all their vertices in B r ( v ). We check the O (log n ) neighborhood of v j to seeif v j is processed before in the i th phase. Otherwise, we use a ball growing method to find a radius r ≤ R = O (log n ) such that | E [ B r +2 ( v j )] || E [ B r ( v j )] | ≤
2. Then, v j assigns color i to some of the vertices in B r ( v j )such that a constant fraction of the hyperedges in E [ B r ( v )] have exactly one vertex with color i . Sucha coloring exists, by a probabilistic method argument: coloring each u ∈ B r ( v j ) with color i withprobability k would provide such a coloring, with a positive probability. Then, all nodes in B r +1 ( v )are considered processed for phase i ; they will not be colored again in this phase.Since | E [ B r ( v )] | ≥ | E [ B r +2 ( v )] | /
2, this process removes a constant fraction of the edges incidenton the newly processed nodes. Hence, at the end of the phase, at least a constant fraction of thehyperedges of this phase have received unique colors, i.e., having exactly one vertex with color i .Since per phase a constant fraction of the remaining hyperedges receive unique colors, O (log n ) phasessuffice. At the end, vertices with no color are assigned a default color. In this section, we discuss the local splitting problems defined in Definitions 1.3 and 1.4 and we showthat these extremely rudimentary looking problems in some sense capture the core of the difficulty indesigning poly log n round deterministic algorithms in the LOCAL model. As outlined in Section 4, wereduce the conflict-free multicoloring problem to the local splitting problems. For completeness, werestate the definitions of λ -local splitting and weak local splitting. Definition 1.3 ( Local Splitting ) . Given is a bipartite graph B = ( U ˙ ∪ V, E B ) where E B ⊆ U × V .For any λ ∈ [0 , / λ -local splitting of B to be a 2-coloring of the nodes in V with colorsred and blue such that each node v has at least (cid:98) λ · d ( v ) (cid:99) neighbors of each color. Definition 1.4 ( Weak Local Splitting ) . Given is a bipartite graph B = ( U ˙ ∪ V, E B ) where E B ⊆ U × V . We define a weak local splitting of B to be a 2-coloring of the nodes in V with colorsred and blue such that each node v has at 1 neighbor of each color.Note that if δ is the minimum degree of any node v ∈ U and we set λ ≥ /δ , any λ -local splittingis also a weak local splitting. We will show that even for graphs where all nodes v ∈ U have degree δ/ < d ( v ) ≤ δ , there is a constant c > δ with c ln n ≤ δ = log O (1) n , the weak localsplitting problem is P - SLOCAL -complete. We prove this by first reducing the problem of computing a1 / poly log n -local splitting to the weak local splitting problem and by then reducing the conflict-freemulticoloring of the previous section to the problem of computing a 1 / poly log n -local splitting of agiven bipartite graph B . We note that the weak local splitting problem can be seen as a generalization For sufficiently large k , this algorithm can be modified to a coloring which assigns each node exactly one color.
13f the weak 2-coloring problem introduced and studied in [NS95]. A weak 2-coloring of a graph G isa 2-coloring of the nodes of G such that each node has at least one neighbor of a different color. If wedefine a hypergraph H with the same set of nodes as G and where we add a hyperedge for each of the n G , a weak local splitting of the bipartite graph corresponding to H is exactlya weak 2-coloring of G . Using techniques from [NS95, Lin92, Kuh09], the weak 2-coloring problemcan be solved in O (log ∗ n ) deterministic rounds in the LOCAL model. Hence, the weak local splittingproblem can be solved efficiently for some interesting special cases. We however show that even insparse bipartite graphs, the general case is as hard as any P - SLOCAL -problem.Before proving the hardness of the local splitting problems, we point out that both local splittingproblems are trivially solvable without communication when using randomization.
Observation 6.1.
There are positive constants c and ε < / √ c such that there is a zero-roundrandomized distributed algorithm which, w.h.p., solves the (cid:0) / − ε (cid:112) ln( n ) /δ (cid:1) -local splitting problemfor every bipartite n -graph B = ( U ˙ ∪ V, E ) in which each node in U has degree at least δ ≥ c ln n . The randomized algorithm is trivial: Each node in V is independently colored red or blue withprobability 1 /
2. Observation 6.1 then directly follows from Chernoff bounds and a union bound overall nodes in U .Specifically, the goal of this section is to prove Theorems 1.3 and 1.4, which we restate here forcompleteness. The theorems directly follow from the technical lemmas which appear in the next twosubsections. Theorem 1.3 (restated).
For n -node bipartite graphs H = ( U ˙ ∪ V, E ) where all nodes in U havedegree at least c ln n for a large enough constant c , the λ -local splitting problem for any λ = n is P - SLOCAL -complete.Proof.
The claim directly follows from Lemmas 6.4 and 6.5.
Theorem 1.4 (restated).
For n -node bipartite graphs H = ( U ˙ ∪ V, E ) where all nodes in U havedegree δ/ < d ( u ) ≤ δ , for any δ such that c ln n ≤ δ = log O (1) n for a sufficiently large constant c ,the weak local splitting problem is P - SLOCAL -complete.Proof.
The claim directly follows from Lemmas 6.3 to 6.5. P - SLOCAL -hard
As a part of the reduction for the local splitting problem, we need to show that in hypergraphs ofpolylogarithmic rank, the conflict-free multicoloring problem is in P - LOCAL . This is proven by thefollowing lemma.
Lemma 6.2.
Let H = ( V, E ) be an n -node hypergraph of rank at most κ = log O (1) n . There existsa q = log O (1) n such that a q -color conflict-free multicoloring of H can be computed in deterministic poly log n time in the LOCAL model.Proof.
The solution consists of (cid:96) phases, where in each phase, we remove some of the hyperedges from H . Let H i be the hypergraph before starting phase i , i.e., we have H = H . In each phase i , wecolor the nodes with colors from a new set C i of c = O ( κ log n ) colors and we afterwards remove allhyperedges from H i which contain exactly one node with color x for some x ∈ C i . The process endswhen all hyperedges are removed. We show that this can be done such that the number of phases (cid:96) ispolylogarithmic in n , implying the statement of the lemma.Let us now have a closer look at a specific phase i . We define a multigraph G i based on H i . G i has the same node set as H i and the following edge set: We add one edge between every two nodes14 , v ∈ G i for every hyperedge e ∈ H i that includes both u and v . Hence, if the two nodes u and v share (cid:96) hyperedges, we include (cid:96) parallel edges between u and v in G i . Let ∆ i be the maximum degreeof G i (where the degree of a node is the number of its edges).In order to color the vertices of the hypergraph H i in phase i , we apply a distributed defectivecoloring algorithm of [Kuh09] to G i . Given a graph G , a d -defective c -coloring of G is a c -coloringof the nodes of G such that every node has at most d neighbors of the same color. In [Kuh09], it isshown that in an n -node graph with maximum degree ∆, for any p ≥
1, one can compute a (∆ /p )-defective O ( p log n )-coloring in a single communication round. From the construction in [Kuh09], itis straightforward to see that the algorithm can also directly be applied to multigraphs, where in a d -defective coloring of a multigraph, each node must be in at most d monochromatic edges.Using the algorithm from [Kuh09], we compute a (∆ i / κ )-defective O ( κ log n )-coloring of themultigraph G i . Now, each node of H i has one of c = O ( κ log n ) colors. As stated, to obtain thehypergraph H i +1 for phase i + 1, we now remove every hyperedge e from H i for which there existsa color x among these O ( κ log n ) colors such that exactly one node in e has color x . Let G i +1 bethe multigraph which we obtain from the resulting hypergraph H i +1 and as before, let ∆ i +1 be themaximum degree of this multigraph. We next show that ∆ i +1 ≤ ∆ i /
2. The claim of the lemma thendirectly follows because initially, each node can be in at most (cid:0) n − k − (cid:1) ≤ n κ − hyperedges and thus thethe maximum degree ∆ of G is at most quasi-polynomial in n . Therefore, the number of phases isat most O (log ∆ ) = log O (1) n .It remains to show that ∆ i +1 ≤ ∆ i /
2. Consider a node u and its incident hyperedges in H i . Noticethat a hyperedge e ∈ H i of node u will remain for H i +1 only if at least one other node v ∈ e receivesthe same color as the color assigned to node u . In this case, the corresponding edge { u, v } in G i ismonochromatic. Since the coloring of G i has defect at most ∆ i κ , we know that in G i there are atmost ∆ i κ monochromatic edges incident to u . Hence, it follows H i +1 can have at most ∆ i κ hyperedgesthat contain node u . Given that each hyperedge of H i +1 , which is also a hyperedge of the originalhypergraph H , has at most κ nodes, we get that in G i +1 , node v has degree at most ∆ i /
2. Thus,∆ i +1 ≤ ∆ i / / poly log n -local splitting problem to theweak local splitting problem. Lemma 6.3.
Let δ , for ≤ δ = log O (1) n , be an integer parameter and let λ = 1 /δ . The λ -localsplitting problem in n -node bipartite graphs B = ( U ˙ ∪ V, E ) is polylog-reducible to the weak splittingproblems in a bipartite graph B (cid:48) = ( U (cid:48) ˙ ∪ V, E (cid:48) ) where each node v in U (cid:48) has degree δ/ < d ( v ) ≤ δ .Proof. By using an oracle for the weak splitting problem, we need to deterministically solve the λ -localsplitting problem on B in polylog time in the LOCAL model. Note that we can w.l.o.g. assume thatall nodes u ∈ U have degree d ( u ) ≤ δ as for nodes v in U of degree d ( v ) < δ , the condition on theneighboring colors is trivial (we then have (cid:98) λ · d ( v ) (cid:99) = 0) and we can thus remove such nodes from U .We transform the graph B into a bipartite graph B (cid:48) = ( U (cid:48) ˙ ∪ V, E (cid:48) ) as follows. Each node v ∈ U arbitrarily partitions its d ( v ) ≥ δ neighbors N ( v ) into parts N ( v ) , . . . , N k v ( v ) of size δ/ < N i ( v ) ≤ δ .Note that such a partition is always possible. If N ( v ) is partitioned into k v parts, node v is replaced by k v nodes v , . . . , v k v in U (cid:48) , where node v i is connected to N i ( v ). Note that when running a distributedalgorithm on B (cid:48) , node v can simulate all nodes v , . . . , v k v . Clearly in B (cid:48) , all nodes U (cid:48) have a degreein ( δ/ , δ ]. We can therefore run the weak local splitting oracle on B (cid:48) and get a coloring of V suchthat each node in U (cid:48) has at least one red neighbor and at least one blue neighbor in V . This impliesthat each node v ∈ U has at least k v ≥ d ( v ) /δ neighbors of each color in V and we have thereforesolved the λ -local splitting problem on B . The cost of the reduction is O (1).We next prove that the λ -local splitting problem is P - SLOCAL -hard for any λ = 1 / poly log n .15 emma 6.4. For any λ = 1 / log O (1) n , the problem of computing a λ -local split of an n -node bipartite B = ( U ˙ ∪ V, E ) is P - SLOCAL -hard.Proof.
We reduce the the problem of computing a conflict-free multicoloring of a given hypergraph H to the given local splitting problem. Hence, assume that we are given an n -node hypergraph H = ( V, E ) with at most polynomially many hyperedges for which we want to compute a conflict-freemulticoloring with poly log n colors by using a λ -local splitting oracle.The reduction consists of (cid:96) phases similar to the algorithm described in the proof of Lemma 6.2.In each phase, we remove some of the hyperedges and some of the nodes. Let H i = ( V i , E i ) be thehypergraph before starting phase i , i.e., we have H = H . In each phase i , we color the nodes withcolors from a new set C i of q = log O (1) n colors and we afterwards remove all hyperedges from H i which contain exactly one node with color x for some x ∈ C i . This will guarantee that all remaininghyperedges are large and we can then use the local splitting oracle to also remove some nodes. As inLemma 6.2, the process ends when all hyperedges are removed. The goal of each phase is to reducethe rank of the hypergraph by a factor at least 1 − λ/
2. Let R i be the maximum hyperedge size (i.e.,the rank) of H i . Note that we have R ≤ n . We thus need to show that for all i , R i +1 ≤ (1 − /λ ) R i .Note that this implies that the reduction requires (cid:96)O (cid:0) log nλ (cid:1) = log O (1) n phases and we thus computea conflict-free multicoloring of H with at most q(cid:96) = poly log n colors as required.Let us now consider a single phase i of the reduction. We define δ := 1 /λ and we define the set L i := { e ∈ E i : | e | ≤ δ } to be the set hyperedges of graph H i of size at most δ . Let H (cid:48) i = ( V, L i ) be thesub-hypergraph of H i which only contains the edges in L i . We then compute a q -color conflict-freemulticoloring of H (cid:48) i for some q = log O (1) n . Lemma 6.2 guarantees that we can do this deterministicallyin poly log n rounds in the LOCAL model. This makes sure that for all hyperedges e in L i , there is acolor x so that exactly one node in e has color x . Note that if R i ≤ δ , all hyperedges of H i are in L i and are therefore done. In the following, we thus assume that R i > δ . After removing all hyperedgesin L i , the resulting graph H (cid:48)(cid:48) i = ( V i , E i \ L i ) has only hyperedges of size larger than δ and it remainsto compute a conflict-free multicoloring of H (cid:48)(cid:48) i .Let B i := ( U i ˙ ∪ V i , E B i ) be the bipartite graph which is obtained from H (cid:48)(cid:48) i in the following naturalway. The left side U i contains a node for every hyperedge of H (cid:48)(cid:48) i , whereas the right side consists of thenodes V i of H (cid:48)(cid:48) i . The node u ∈ U i corresponding to some hyperedge e ∈ E i \ L i is connected to all thenodes in V i which are contained in e . In the following, let d i ( u ) be the degree of a node u ∈ U i in thebipartite graph B i . Note that for all u ∈ U i , we have d i ( u ) > δ . Using the λ -local splitting oracle, wenow compute a λ -local splitting of the bipartite graph B i . Note that because we assumed that H hasonly polynomially many hyperedges, the bipartite graph B i also has at most polynomially many nodesand we can therefore efficiently simulate graph B i on the network graph H . This assigns colors red andblue to the nodes in V i such that every node u ∈ U i has at least (cid:98) λd i ( u ) (cid:99) = (cid:98) d i ( u ) /δ (cid:99) ≥ V i,R be the set of red nodes. We define H i +1 to be the sub-hypergraph of H (cid:48)(cid:48) i whichis induced by only the red nodes V i,R . That is, for each hyperedge of e of H (cid:48)(cid:48) i , the hypergraph H i +1 contains a hyperedge consisting of the nodes e ∩ V i,R . Because each node in the bipartite graph B i hasat least one red neighbor, these hyperedges are non-empty and therefore a conflict-free multicoloringof H i +1 directly implies a conflict-free multicoloring of H (cid:48)(cid:48) i (by potentially adding one additional colorto the blue nodes to make sure that every node has at least one color). Because in B i , every node u ∈ U i has at least (cid:98) λd i ( u ) (cid:99) blue neighbors, the maximum hyperedge size of H i +1 is upper boundedby R i +1 ≤ R i − (cid:98) λR i (cid:99) = R i − (cid:22) R i δ (cid:23) ( R i >δ ) ≤ (cid:18) − δ (cid:19) · R i . This concludes the proof. 16 .2 Local Splitting is in P - SLOCAL
We next present a deterministic algorithm in the
SLOCAL model with locality poly log n that solvesthe λ -local splitting problem on bipartite graphs B = ( U ˙ ∪ V, E ), where the minimum degree of nodesin U is Ω(log n ). While the problem is shown to be P - SLOCAL -hard even for λ = 1 / poly log n inLemma 6.4, our SLOCAL algorithm achieves a much better split and even works for values of λ whichare close to 1 /
2. Our algorithm also directly shows that for the given graphs, the weak local splittingproblem is in
SLOCAL . Lemma 6.5.
Let c and d be sufficiently large positive constants. Then, for the family of n -nodebipartite graphs B = ( U ˙ ∪ V, E where every node in U has degree at least δ ≥ c ln n , the λ -localsplitting problem is in P - SLOCAL for any λ ≤ / − d · ln n √ δ .Proof. We saw in Lemma 2.2 that we can transfer any deterministic k -phase SLOCAL algorithm intoa deterministic single-phase
SLOCAL algorithm, while incurring only a k log n factor increase in thecomplexity. Leveraging this point, here we provide a 2-phase algorithm A where each phase haslocality no more than O (poly log n ).Let us assume that we are given a bipartite graph B = ( U ˙ ∪ V, E B ), where every node u in U hasdegree d ( u ) ≥ δ ≥ c ln n . Based on graph B , we define a graph G = ( V, E G ) which contains a nodefor each “right-side” node v ∈ V of B . Two nodes { v, v (cid:48) } ∈ V are connected by an edge in G if andonly if v and v (cid:48) have a common neighbor in U in graph B .In the first phase of Algorithms A , we compute a ( O (log n ) , O (log n ))-decomposition of the graph G . Such a decomposition can be computed with poly log n locality by Lemma 9.2. Recall that thispartitions the nodes V into clusters which are colored with O (log n ) colors. Because two clusters withthe same color cannot be neighbors, for every cluster color, every node u ∈ U on the “left side” of thebipartite graph B can only have neighbors from one cluster per color. For every node u ∈ U , the setof neighbors N ( u ) therefore belong to at most O (log n ) different clusters.For each cluster C ⊆ V , we now consider the induced bipartite graph B C = ( U C ˙ ∪ V C , E C ) consistingof all nodes V C = C and all nodes U C in U which have at least one neighbor in C . In an internalcomputation within each cluster, the nodes of all clusters are colored independently. Note that such acomputation within a cluster can be done with locality O (log n ) as each cluster has diameter O (log n ).To see how each cluster is colored, we consider the properties of a random coloring of a cluster C , where each node in C is independently colored red or blue with probability 1 /
2. Let u ∈ U C bea node of B C and let N C ( u ) be the neighbors of u in B C . By applying a standard Chernoff bound,with probability 1 − / (2 n ), the absolute difference between the number of red and blue nodes in N C ( u ) can be upper bounded by a term of order O ( (cid:112) | N C ( u ) | log n + log n ). A union bound over allnodes in U C implies that there exists a red/blue coloring of the nodes in C such that for all u ∈ U C ,the absolute difference in the number of red and blue nodes among the nodes in N C ( u ) is at most α ( (cid:112) | N C ( u ) | log n + log n ) for some constant α >
0. In one
SLOCAL -phase with locality O (log n ), sucha red/blue-coloring can be computed for every cluster.Recall that for each node u ∈ U , the neighborhood N ( u ) is partitioned among at most O (log n )different clusters. Assume that the set N ( u ) is partitioned among k u clusters and that it is partitionedinto sets of sizes n u, , . . . , n u,k u . By combining the red/blue-colorings of all the clusters, we thereforeobtain a red/blue-coloring of the whole set V such that for every node u ∈ U , the absolute differencebetween the number of red and blue nodes in N ( u ) is upper bounded by α · k u (cid:88) i =1 (cid:0)(cid:112) n u,i ln n + ln n (cid:1) ≤ α · (cid:118)(cid:117)(cid:117)(cid:116) k u k u (cid:88) i =1 n u,i ln n + k u ln n = α · (cid:16)(cid:112) k u | N ( u ) | ln n + k u ln n (cid:17) . k ≥ x , . . . , x k ≥
0, it holdsthat (cid:80) ki =1 √ x i ≤ √ k (cid:113)(cid:80) ki x i , which follows from the Cauchy-Schwarz inequality. The claim of thelemma now follows by using that k u = O (log n ) and by setting the constants c and d in the lemmastatement large enough. In this section, we explain
SLOCAL algorithms with complexity O (poly(log n/ε )) for computing (1 + ε )approximations of covering and packing Integer Linear Programs (ILP). In conjunction with Theo-rem 1.6, this implies that the same approximation can be achieved using randomized LOCAL algorithmswith complexity O (poly(log n/ε )). Furthermore, if one can deterministically solve one of the problemsshown to be P - SLOCAL -complete in the previous sections—for instance, local splitting, hypergraphconflict-free multi-coloring, or network decomposition—in poly log n rounds of the LOCAL model, thenwe would get O (poly(log n/ε )) round deterministic algorithms in the LOCAL model for (1 + ε ) approx-imation of covering and packing ILPs.The formulation of covering and packing ILPs, which are duals of each other, is as follows: Covering ILP: min c T x subject to A x ≥ bx ∈ N n ≥ A ≥ , c ≥ , b ≥ Packing ILP: max b T y subject to A T y ≤ cy ∈ N n ≥ A ≥ , c ≥ , b ≥ H = ( V, E ), where V = L ∪ R and E ⊆ L × R as in [PY93, BBR97, KMW06]. There is one vertex (cid:96) ∈ L , | L | = n , representing each variable andone vertex r ∈ R , | R | = n , representing each linear constraint. The edges of the bipartite graphare such that each variable vertex related to x i (or y j ) is connected to all linear constraint verticesthat have a non-zero coefficient for x i (respectively y j ). Various classic optimization problems can beeasily viewed in this framework, with no more than an O (1) factor loss in the locality. This includescovering ILPs such as minimum dominating set, set cover, and vertex cover and packing ILPs such asmaximum independent set and maximum matching. For instance, for maximum independent set in agraph G = ( V, E ), we have one variable vertex per each node of G , and one constraint vertex per eachedge e = ( v, u ) ∈ E , which can be simulated by one of its endpoints, say the one with the larger ID.In the following, we provide simple deterministic SLOCAL algorithms with locality O (poly( log nε ))for covering and packing ILPs. For simplicity, instead of presenting the algorithms in the generalframework, we explain the algorithms for two concrete sample problems, maximum independent set andminimum dominating set. It is easy to see how these algorithms can be extended to the related generalcases of packing and covering ILPs, respectively. The resulting time complexity will be polylogarithmicin n , 1 /ε , and in the ratio between the largest and smallest weight and coefficient. Theorem 7.1.
There is a deterministic algorithm with complexity O (poly(log n/ε )) in the SLOCAL model that computes a (1 + ε ) -approximation of the maximum independent set.Proof. We use a simple ball growing argument. Suppose that v , v , . . . , v n is the ordering of thevertices provided to the SLOCAL algorithm. 18et α ( H ) denote the independence number of graph H , i.e., its maximum independent set size.We begin with an empty global independent set. We start with some node v and find a radius r suchthat α ( G [ B r +1 ( v )]) ≤ (1 + (cid:15) ) · α ( G [ B r ( v )]). Notice that r ≤ R = O (log n/ε ). Compute a maximumindependent set of B r ( v ), add it to the global independent set, and remove B r +1 ( v ) from the graph.This clearly has locality O (log n/(cid:15) ). Furthermore, it provides a (1 + (cid:15) ) approximation of the maximumindependent set. The reason is as follows: we can decompose the optimal maximum independent set I ∗ into n (potentially empty) subsets I , . . . , I n , each being the vertices of I ∗ which are removedwhen processing node v i . Then, the computed independent set when processing v i has size at least | I i | / (1 + ε ). Thus, overall, the computed independent set has size at least | I ∗ | / (1 + ε ). Corollary 7.2.
There is a randomized algorithm with complexity O (poly(log n/ε )) in the LOCAL model that computes a (1 + ε ) -approximation of the maximum independent set, with high probability. We remark that, to the best of our knowledge, this is the first algorithm providing this highprobability approximation for maximum independent set. Prior to our work, it was known how torandomly compute an independent set whose size is in expectation a (1+ (cid:15) ) approximation of maximumindependent set [BHKK16]. However, we are not aware of a method for transforming that algorithmto a high probability approximation guarantee, and indeed, due to the nature of the
LOCAL model,such a transformation does not seem feasible, or at least is not straightforward.
Theorem 7.3.
There is a deterministic algorithm with complexity O (poly(log n/ε )) in the SLOCAL model that computes a (1 + ε ) -approximation of the minimum dominating set.Proof. Again, we use a simple ball growing argument. Suppose that v , v , . . . , v n is the ordering ofthe vertices provided to the SLOCAL algorithm.For a node v , let g ( v, r ) be the size of the smallest set of vertices in B r +1 ( v ) that dominates B r ( v ).We begin with an empty global dominating set. We start with some node v and find a radius r suchthat g ( v, r + 2) ≤ (1 + (cid:15) ) · g ( v, r ). Notice that r ≤ R = O (log n/ε ). Compute a smallest set in B r +3 ( v )that dominates B r +2 ( v ), add it to the global dominating set, and remove B r +2 ( v ) from the graph.Call B r ( v ) the central ball of this step. This clearly has locality O (log n/(cid:15) ). Furthermore, it providesa (1 + (cid:15) ) approximation of the minimum dominating set. The reason is as follows: construct node sets V , V , . . . , V n and add each vertex v ∈ V to the subset V i such that v was in the central ball B r ( v i )when processing vertex v i . Notice that some vertices v will be in none of the sets V i . On the otherhand, each two sets V i and V j have distance at least 3. Hence, no node can dominate vertices fromtwo or more of these sets. Consider the optimal minimum dominating set D ∗ and partition it into n disjoint (potentially empty) subsets D , . . . , D n , each being the set of vertices of D ∗ that dominate V i . Then, the computed dominating set when processing v i has size at most | D i | (1 + ε ). Thus, overall,the computed dominating set has size at most | D ∗ | (1 + ε ). As mentioned before, the
SLOCAL model is quite powerful, thanks to the fact that vertices are pro-cessed in a sequential order and that each vertex v has a local state S v to record the information itgathered. Because of this, the model is clearly stronger than the standard LOCAL model. In fact,a priori, the
SLOCAL model might look too strong to be of any interest: in particular, it can eas-ily solve all the classic problems of interest—e.g., maximal independent set, (∆ + 1)-vertex coloring,(2∆ − O (1).In this section, we show that, perhaps surprisingly, the (randomized) SLOCAL model is not muchmore powerful than the randomized
LOCAL model, when we are concerned with polylogarithmic19ocality. Furthermore, as we prove in Lemma 2.2, even if we allow the
SLOCAL algorithm to use apolylogarithmic number of phases and process the vertices sequentially for a polylogarithmic numberof iterations, the power does not change significantly.
Theorem 1.6 (restated). P - RSLOCAL ε ⊆ P - RLOCAL ε + / poly ( n ) . Proof.
Given a randomized
SLOCAL algorithm
A ∈ P - RSLOCAL ε with locality r = poly log n , weexplain a randomized LOCAL algorithm
B ∈ P - RLOCAL ε + / poly ( n ) with locality poly log n that simulates A . The first step in algorithm B is to compute an ( O (log n ) , O (log n ))-network decomposition of thegraph G r +1 , using the randomized algorithm of Linial and Saks [LS93] in O ( r log n ) time. Thisnetwork decomposition partitions the vertices of G into clusters X , X , . . . , X η such that it satisfiesthe following two properties with probability at least 1 − / poly( n ):(1) any two vertices of each cluster have distance at most O ( r log n ) in G , and(2) each cluster X i is assigned a color in a color set { , , . . . , Q } for a Q = O (log n ) such that anytwo clusters of the same color have distance at least r + 1 in G .To simulate the SLOCAL algorithm A , we use this network decomposition to generate an ordering π of vertices as in Observation 3.2 , this will be the order on which we assume A operates.The algorithm B now uses this order π to simulate A . Algorithm B works in Q = O (log n ) phases,each taking O ( r log n ) rounds. In the i th phase, each vertex v (cid:96) in a cluster X j with color i firstgathers all the information in the r -neighborhood of the cluster X j . Then, node i locally simulates thealgorithm A for all the nodes in X j , according to the order π . For each node u in X j , to determinethe output of u , the simulation will need to know the state S w of nodes w which appear before u andare within distance r of u . If w has color i (cid:48) < i , this state is written in the local memory of S w whensimulating phase i (cid:48) and thus u knows it, as it has gathered the information in the r -hop neighborhoodof X i . If w has color i , then node u simulated node w before and thus knows S w . Notice that nodesof different clusters of the same color i can perform this process in parallel as their computations donot influence each other (because of the way π is defined).The lemma easily generalizes to show that RSLOCAL ε ( t O (1) ( n )) ⊆ RLOCAL ε + / poly ( n ) ( t O (1) ( n )), forany function t ( n ) ≥ log n . We call
SLOCAL algorithms as defined in Section 2.3 single-phase
SLOCAL algorithms because theyprocess each node only once. If we allow an algorithm to run through the nodes k times, we call it a k -phase SLOCAL algorithm. We next prove that having multiple phases does not increase the powersignificantly. In particular, the set of problems which can be solved with polylogarithmic locality inthe
SLOCAL model does not change if we allow k phases as long as k is polylogarithmic.Lemma 2.2 (restated). Any k -phase SLOCAL algorithm A with locality r i in phase i = 1 , . . . , k can betransformed into a single-phase SLOCAL algorithm B with locality r + 2 (cid:80) ki =2 r i .Proof. We prove that a k -phase algorithm A with locality r i in phase i can be transferred into a singlephase algorithm B with locality R := (cid:80) ki =1 r i if we assume that node u in algorithm B can write intothe memory of nodes in B R − r ( u ). Then the claim follows with Observation 2.1.We explain how to transform a two phase SLOCAL algorithm A (cid:48) with locality r in the first phaseand r in the second phase into a single phase SLOCAL algorithm B (cid:48) with locality r + r . Then theaforementioned transformation of A into B can be deduced with an inductive argument.20o construct algorithm B (cid:48) we need to see that the output in phase two of node u in algorithm A (cid:48) only depends on the output of the first phase of all nodes in B r ( u ) and the output of the secondphase of nodes in B r ( u ) that have been processed in the second phase before u . Algorithm B (cid:48) : Assume nodes in B (cid:48) are processed according to order π . Whenever it is u ’s turn in B (cid:48) , it collects its neighborhood B r + r ( u ), u simulates the first phase of algorithm A (cid:48) for all nodes in B r ( u ) and writes the output into the memories of the nodes in B r ( u ). In this simulation u takes intoaccount that some nodes in this ball might already have computed their output because they werehandled before u or because some other node wrote their output into their memory. In particular,all nodes which are processed before u in order π have already computed their output for phase two.Note that this simulation might use different orders for the two phases of A (cid:48) .Then u has all the information to compute its output after two phases, i.e., the phase one outputand memory content of nodes in B r ( u ) and the phase two output of nodes in B r ( u ) of the nodesthat are ordered before u in π . P - SLOCAL
In this section, we review the centralized sequential (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition algorithm,which is contributed to Linial and Saks [LS93] and Awerbuch and Peleg [AP90].Recall from Definition 1.1 that a weak (cid:0) d ( n ) , c ( n ) (cid:1) -decomposition of an n -node graph G = ( V, E )is a partition of V into clusters such that each cluster has weak diameter at most d ( n ) and the clustergraph is properly colored with colors 1 , . . . , c ( n ). We refer to the vertices of the clusters of each color i as block i and denote them by V i . Thus, this decomposition partitions V into blocks V , . . . , V c ( n ) .The sequential algorithm of [LS93, AP90] constructs the decomposition one block at a time. Wedescribe one block of the construction, show that it produces non-adjacent clusters each with weakdiameter d ( n ) = O (log n ), and argue that it removes a constant fraction of the nodes. Thus, after O (log n ) blocks, all nodes are removed and thus we have a (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition. Construction of one block:
Let G i = G [ V \ (cid:0) V ∪ . . . ∪ V i − (cid:1) ] be the subgraph of G left afterremoving the vertices of blocks V to V i − . We construct the clusters of the block V i , one at a time.During this process, we will discard some vertices of G i , once they are processed, and thus G i isgradually shrinking.Repeat the following process until G i is empty: Pick an arbitrary vertex v ∈ G i and start thefollowing ball growing process on G i : Find the smallest radius r ∗ such that | B G i r ∗ +1 ( v ) || B G i r ∗ ( v ) | ≤ . (1)Note that r ∗ ≤ log n , because otherwise we would have | B G i log n +1 ( v ) | > n , which would be a contra-diction with the graph having only n vertices. Add nodes of B G i r ∗ ( v ) as one cluster of V i , and thenremove nodes B G i r ∗ +1 ( v ) from G i . Lemma 9.1.
The sequential ball growing algorithm of Linial and Saks [LS93] and Awerbuch andPeleg [AP90] described above computes an (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition.Proof. It is easy to see that due to condition Equation (1), each block removes at least a constantfraction of the unclustered nodes. Hence, O (log n ) blocks suffice.21n each block V i , each cluster has weak diameter at most 2 r ∗ ≤ n , because it was found asa ball of radius at most r ∗ around some node v . Furthermore, no two clusters of the same block areadjacent because when constructing the first cluster, its boundary nodes are removed from the graphbut not added to the cluster, that is, we remove B G i r ∗ +1 ( v ) but define only B G i r ∗ ( v ) to be a cluster. P - SLOCAL
Now, we adapt the deterministic sequential algorithm of the previous subsection to the
SLOCAL model.This allows us to compute a network decomposition, and also a low-diameter ordering, in poly log n rounds of the SLOCAL model.
Lemma 9.2.
Computing a (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition of a given n -node graph is in P - SLOCAL .Proof.
The proof of Lemma 2.2 shows how a (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition can be computed ina single phase.Alternatively to the above proof and if one assumes that nodes can write into other nodes’ memory(cf. Observation 2.1), the deterministic sequential (cid:0) O (log n ) , O (log n ) (cid:1) -decomposition algorithm fromthe previous section directly translates into an SLOCAL algorithm with O (log n ) phases, which then canbe transferred into a single-phase SLOCAL algorithm with polylogarithmic locality with Lemma 2.2.
Lemma 9.3.
The problem of computing a poly log n -diameter ordering is in P - SLOCAL .Proof.
The result follows with Lemma 9.2 and Observation 3.2.22 eferences [ABCP96] B. Awerbuch, B. Berger, L. Cowen, and D. Peleg. Fast network decompositions and covers.
J. of Parallel and Distributed Computing , 39(2):105–114, 1996.[ABI86] N. Alon, L. Babai, and A. Itai. A fast and simple randomized parallel algorithm for themaximal independent set problem.
J. of Algorithms , 7(4):567–583, 1986.[AGLP89] B. Awerbuch, A. V. Goldberg, M. Luby, and S. A. Plotkin. Network decomposition andlocality in distributed computation. In
Proc. 30th Symp. on Found. of Computer Science(FOCS) , pages 364–369, 1989.[AP90] B. Awerbuch and D. Peleg. Sparse partitions. In
Proc. 31st IEEE Symp. on Foundationsof Computer Science (FOCS) , pages 503–513, 1990.[ARVX12] N. Alon, R. Rubinfeld, S. Vardi, and N. Xie. Space-efficient local computation algorithms.In
Proc. 23rd ACM-SIAM Symp. on Discrete Algorithms (SODA) , pages 1132–1139, 2012.[Awe85] B. Awerbuch. Complexity of network synchronization.
Journal of the ACM , 32(4):804–823,1985.[Bar12] L. Barenboim. On the locality of some NP-complete problems. In
Proc. 39th Coll. onAutomata, Languages, and Programming (ICALP) , pages 403–415, 2012.[Bar15] L. Barenboim. Deterministic (∆ + 1)-coloring in sublinear (in ∆) time in static, dy-namic and faulty networks. In
Proc. 34th ACM Symposium on Principles of DistributedComputing (PODC) , pages 345–354, 2015.[BBR97] Y. Bartal, J. W. Byers, and D. Raz. Global optimization using local information withapplications to flow control. In
Proc. of the 38th IEEE Symposium on the Foundations ofComputer Science (FOCS) , pages 303–312, 1997.[BE10] L. Barenboim and M. Elkin. Deterministic distributed vertex coloring in polylogarithmictime. In
Proc. 29th Symp. on Principles of Distributed Computing (PODC) , 2010.[BE13] L. Barenboim and M. Elkin.
Distributed Graph Coloring: Fundamentals and Recent De-velopments . Morgan & Claypool Publishers, 2013.[BEG15] L. Barenboim, M. Elkin, and C. Gavoille. A fast network-decomposition algorithm and itsapplications to constant-time distributed computation. In
Proc. 22nd Coll. on StructuralInformation and Communication Complexity (SIROCCO) , pages 209–223, 2015.[BEK15] L. Barenboim, M. Elkin, and F. Kuhn. Distributed (∆ + 1)-coloring in linear (in ∆) time.
SIAM J. Computing , 43(1):72–95, 2015.[BEPS12] L. Barenboim, M. Elkin, S. Pettie, and J. Schneider. The locality of distributed symmetrybreaking. In
Proc. 53th Symp. on Foundations of Computer Science (FOCS) , 2012.[BFH +
16] S. Brand, O. Fischer, J. Hirvonen, B. Keller, T. Lempi¨ainen, J. Rybicki, J. Suomela, andJ. Uitto. A lower bound for the distributed lov´asz local lemma. In
Proc. 48th Symp. onthe Theory of Computing (STOC) , 2016.[BGK +
14] G. E. Blelloch, A. Gupta, I. Koutis, G. L. Miller, R. Peng, and K. Tangwongsan. Nearly-linear work parallel SDD solvers, low-diameter decomposition, and low-stretch subgraphs.
Theory Comput. Syst. , 55(3):521–554, 2014.23BHKK16] M. Bodlaender, M. Halld´orsson, C. Konrad, and F. Kuhn. Brief announcement: Localindependent set approximation. In
Proc. 35th ACM Symp. on Principles of DistributedComputing (PODC) , pages 93–95, 2016.[CHS04] A. Czygrinow, M. Ha´n´ckowiak, and E. Szyma´nska. Distributed algorithm for approximat-ing the maximum matching.
Discrete Applied Math. , 143:62–71, 2004.[CKP16] Y.-J. Chang, T. Kopelowitz, and S. Pettie. An exponential separation between randomizedand deterministic complexity in the LOCAL model.
CoRR , abs/1602.08166, 2016.[CV86] R. Cole and U. Vishkin. Deterministic coin tossing with applications to optimal parallellist ranking.
Information and Control , 70(1):32–53, 1986.[DMP +
05] D. Dubhashi, A. Mei, A. Panconesia, J. Radhakrishnan, and A. Srinivasan. Fast distributedalgorithms for (weakly) connected dominating sets and linear-size skeletons.
J. of Computerand System Sciences (JCSS) , 71(4):467–479, 2005.[ELRS03] G. Even, Z. Lotker, D. Ron, and S. Smorodinsky. Conflict-free colorings of simple geo-metric regions with applications to frequency assignment in cellular networks.
SIAM J.Computing , 33(1):94–136, 2003.[EN16] M. Elkin and O. Neiman. Distributed strong diameter network decomposition. In
Proc.35th ACM Symp. on Principles of Distributed Computing (PODC) , pages 211–216, 2016.[FFH16] L. Feuilloley, P. Fraigniaud, and J. Hirvonen. A hierarchy of local decision. In
Proc. 43rdColl. on Automata, Languages, and Programming (ICALP) , pages 118:1–118:15, 2016.[FGKS13] P. Fraigniaud, M. G¨o¨os, A. Korman, and J. Suomela. What can be decided locally withoutidentifiers? In
Proc. 32nd ACM Symp. on Principles of Distributed Computing (PODC) ,pages 157–165, 2013.[FHK16] P. Fraigniaud, M. Heinrich, and A. Kosowski. Local conflict coloring. In
Proc. 57th IEEESymp. on Foundations of Computer Science (FOCS) , 2016.[FHS15] P. Fraigniaud, J. Hirvonen, and J. Suomela. Node labels in local decision. In
Proc. 22ndColl. on Structural Information and Communication Complexity (SIROCCO) , pages 31–45, 2015.[FKP13] P. Fraigniaud, A. Korman, and D. Peleg. Towards a complexity theory for local distributedcomputing.
J. of the ACM , 60(5):35, 2013.[FKPP13] P. Fraigniaud, A. Korman, M. Parter, and D. Peleg. Randomized distributed decision.
Distributed Computing , 27(6):419–434, 2013.[Gha16] M. Ghaffari. An improved distributed algorithm for maximal independent set. In
Proc.27th ACM-SIAM Symp. on Discrete Algorithms (SODA) , pages 270–277, 2016.[GPS88] A.V. Goldberg, S.A. Plotkin, and G.E. Shannon. Parallel symmetry-breaking in sparsegraphs.
SIAM Journal on Discrete Mathematics , 1(4):434–446, 1988.[GS14] M. G¨o¨os and J. Suomela. No sublogarithmic-time approximation scheme for bipartitevertex cover.
Distributed Computing , 27(6):435–443, 2014.[GS17] M. Ghaffari and H.-H. Su. Distributed degree splitting, edge coloring, and orientations. In
Proc. 28th ACM-SIAM Symp. on Discrete Algorithms (SODA) , 2017.24HKP01] M. Ha´n´ckowiak, M. Karo´nski, and A. Panconesi. On the distributed complexity of com-puting maximal matchings.
SIAM J. Discrete Math. , 15(1):41–57, 2001.[HMKS16] D. Hefetz, Y. Maus, F. Kuhn, and A. Steger. A polynomial lower bound for distributedgraph coloring in a weak LOCAL model. In
Proc. 30th Symp. on Distributed Computing(DISC) , pages 99–113, 2016.[HSS16] S. G. Harris, J. Schneider, and H.-H. Su. Distributed (∆ + 1)-coloring in sublogarithmicrounds. In
Proc. 48th Symp. on the Theory of Computing (STOC) , 2016.[JRS02] L. Jia, R. Rajaraman, and R. Suel. An efficient distributed algorithm for constructingsmall dominating sets.
Distributed Computing , 15(4):193–205, 2002.[KMW06] F. Kuhn, T. Moscibroda, and R. Wattenhofer. The price of being near-sighted. In
Proc.17th Symp. on Discrete Algorithms (SODA) , pages 980–989, 2006.[KMW16] F. Kuhn, T. Moscibroda, and R. Wattenhofer. Local computation: Lower and upperbounds.
J. of the ACM , 63(2), 2016.[Kuh09] F. Kuhn. Local weak coloring algorithms and implications on deterministic symmetrybreaking. In
Proc. of 21st ACM Symp. on Parallelism in Algorithms and Architectures(SPAA) , 2009.[Lin92] N. Linial. Locality in distributed graph algorithms.
SIAM Journal on Computing ,21(1):193–201, 1992.[LS93] N. Linial and M. Saks. Low diameter graph decompositions.
Combinatorica , 13(4):441–454,1993.[Lub86] M. Luby. A simple parallel algorithm for the maximal independent set problem.
SIAMJournal on Computing , 15:1036–1053, 1986.[NS95] M. Naor and L. Stockmeyer. What can be computed locally?
SIAM J. on Comp. ,24(6):1259–1277, 1995.[Pel00] D. Peleg.
Distributed Computing: A Locality-Sensitive Approach . SIAM, 2000.[PS95] A. Panconesi and A. Srinivasan. On the complexity of distributed network decomposition.
Journal of Algorithms , 20(2):581–592, 1995.[PY93] C. Papadimitriou and M. Yannakakis. Linear programming without the matrix. In
Proc.of the 25th ACM Symposium on Theory of Computing (STOC) , pages 121–129, 1993.[RTVX11] R. Rubinfeld, G. Tamir, S. Vardi, and N. Xie. Fast local computation algorithms. In
Proc.2nd Symp. on Innovations in Computer Science (ICS) , pages 223–238, 2011.[Smo13] S. Smorodinsky. Conflict-free coloring and its applications. In
GeometryIntuitive, Discrete,and Convex , pages 331–389. Springer, 2013.[Suo13] J. Suomela. Survey of local algorithms.
ACM Computing Surveys , 45(2), 2013.[SV93] M. Szegedy and S. Vishwanathan. Locality based graph coloring. In