Local Distributed Decision
aa r X i v : . [ c s . D C ] M a r Local Distributed Decision ∗ Pierre Fraigniaud † Amos Korman † David Peleg ‡ Abstract
A central theme in distributed network algorithms concerns understanding andcoping with the issue of locality . Despite considerable progress, research efforts in thisdirection have not yet resulted in a solid basis in the form of a fundamental compu-tational complexity theory. Inspired by sequential complexity theory, we focus on acomplexity theory for distributed decision problems . In the context of locality, solvinga decision problem requires the processors to independently inspect their local neigh-borhoods and then collectively decide whether a given global input instance belongs tosome specified language.We consider the standard
LOCAL model of computation and define LD( t ) (for local decision ) as the class of decision problems that can be solved in t number of com-munication rounds. We first study the intriguing question of whether randomizationhelps in local distributed computing, and to what extent. Specifically, we define thecorresponding randomized class BPLD( t, p, q ), containing languages for which thereexists a randomized algorithm that runs in t rounds and accepts correct instances withprobability at least p and rejects incorrect ones with probability at least q . We showthat there exists a language that does not belong to LD( t ) for any t = o ( n ) but whichbelong for BPLD(0 , p, q ) for any p, q ∈ (0 ,
1] such that p + q ≤
1. On the other hand,we show that, restricted to hereditary languages, BPLD( t, p, q ) = LD( O ( t )), for anyfunction t and any p, q ∈ (0 ,
1] such that p + q > ∗ Supported by a France-Israel cooperation grant (“Mutli-Computing” project) from the France Ministryof Science and Israel Ministry of Science. † CNRS and University Paris Diderot, France. E-mail: { pierre.fraigniaud,amos.korman } @liafa.jussieu.fr .Supported by the ANR projects ALADDIN and PROSE and by the INRIA project GANG. ‡ The Weizmann Institute of Science, Rehovot, Israel. E-mail: [email protected] . hat enables to decide all languages in constant time. Finally, we introduce the notionof local reduction, and establish some completeness results. Keywords:
Local distributed algorithms, local decision, nondeterminism, randomized algo-rithms.
Introduction
Distributed computing concerns a collection of processors which collaborate in order toachieve some global task. With time, two main disciplines have evolved in the field. Onediscipline deals with timing issues, namely, uncertainties due to asynchrony (the fact thatprocessors run at their own speed, and possibly crash), and the other concerns topology issues, namely, uncertainties due to locality constraints (the lack of knowledge about far awayprocessors). Studies carried out by the distributed computing community within these twodisciplines were to a large extent problem-driven. Indeed, several major problems consideredin the literature concern coping with one of the two uncertainties. For instance, in the asynchrony-discipline , Fischer, Lynch and Paterson [14] proved that consensus cannot beachieved in the asynchronous model, even in the presence of a single fault, and in the locality-discipline , Linial [28] proved that (∆ + 1)-coloring cannot be achieved locally (i.e.,in a constant number of communication rounds), even in the ring network.One of the significant achievements of the asynchrony-discipline was its success in es-tablishing unifying theories in the flavor of computational complexity theory. Some centralexamples of such theories are failure detectors [6, 7] and the wait-free hierarchy (includingHerlihy’s hierarchy) [18]. In contrast, despite considerable progress, the locality-disciplinestill suffers from the absence of a solid basis in the form of a fundamental computationalcomplexity theory. Obviously, defining some common cost measures (e.g., time, message,memory, etc.) enables us to compare problems in terms of their relative cost. Still, from acomputational complexity point of view, it is not clear how to relate the difficulty of prob-lems in the locality-discipline. Specifically, if two problems have different kinds of outputs,it is not clear how to reduce one to the other, even if they cost the same.Inspired by sequential complexity theory, we focus on decision problems , in which one isaiming at deciding whether a given global input instance belongs to some specified language.In the context of distributed computing, each processor must produce a boolean output,and the decision is defined by the conjunction of the processors’ outputs, i.e., if the instancebelongs to the language, then all processors must output “yes”, and otherwise, at least oneprocessor must output “no”. Observe that decision problems provide a natural frameworkfor tackling fault-tolerance: the processors have to collectively check whether the networkis fault-free, and a node detecting a fault raises an alarm. In fact, many natural problemscan be phrased as decision problems, like “is there a unique leader in the network?” or “isthe network planar?”. Moreover, decision problems occur naturally when one is aiming at1hecking the validity of the output of a computational task, such as “is the produced coloringlegal?”, or “is the constructed subgraph an MST?”. Construction tasks such as exact orapproximated solutions to problems like coloring, MST, spanner, MIS, maximum matching,etc., received enormous attention in the literature (see, e.g., [5, 25, 26, 28, 30, 31, 32, 38]),yet the corresponding decision problems have hardly been considered.The purpose of this paper is to investigate the nature of local decision problems. Decisionproblems seem to provide a promising approach to building up a distributed computationaltheory for the locality-discipline. Indeed, as we will show, one can define local reductionsin the framework of decision problems, thus enabling the introduction of complexity classesand notions of completeness.We consider the
LOCAL model [36], which is a standard distributed computing modelcapturing the essence of locality. In this model, processors are woken up simultaneously,and computation proceeds in fault-free synchronous rounds during which every processorexchanges messages of unlimited size with its neighbors, and performs arbitrary computationson its data. Informally, let us define LD( t ) (for local decision) as the class of decision problemsthat can be solved in t number of communication rounds in the LOCAL model. (We findspecial interest in the case where t represents a constant, but in general we view t as afunction of the input graph. We note that in the LOCAL model, every decidable decisionproblem can be solved in n communication rounds, where n denotes the number of nodes inthe input graph.)Some decision problems are trivially in LD( O (1)) (e.g., “is the given coloring a (∆ + 1)-coloring?”, “do the selected nodes form an MIS?”, etc.), while some others can easily beshown to be outside LD( t ), for any t = o ( n ) (e.g., “is the network planar?”, “is there a uniqueleader?”, etc.). In contrast to the above examples, there are some languages for which it isnot clear whether they belong to LD( t ), even for t = O (1). To elaborate on this, consider theparticular case where it is required to decide whether the network belongs to some specifiedfamily F of graphs. If this question can be decided in a constant number of communicationrounds, then this means, informally, that the family F can somehow be characterized byrelatively simple conditions. For example, a family F of graphs that can be characterized asconsisting of all graphs having no subgraph from C , for some specified finite set C of finitesubgraphs, is obviously in LD( O (1)). However, the question of whether a family of graphscan be characterized as above is often non-trivial. For example, characterizing cographs asprecisely the graphs with no induced P , attributed to Seinsche [40], is not easy, and requiresnontrivial usage of modular decomposition.The first question we address is whether and to what extent randomization helps. For2 , q ∈ (0 , t, p, q ) as the class of all distributed languages that can be decidedby a randomized distributed algorithm that runs in t number of communication rounds andproduces correct answers on legal (respectively, illegal) instances with probability at least p (resp., q ). An interesting observation is that for p and q such that p + q ≤
1, we haveLD( t ) ( BPLD( t, p, q ). In fact, for such p and q , there exists a language L ∈
BPLD(0 , p, q ),such that L / ∈ LD( t ), for any t = o ( n ). To see why, consider the following Unique-Leader language. The input is a graph where each node has a bit indicating whether it is a leaderor not. An input is in the language
Unique-Leader if and only if there is at most one leaderin the graph. Obviously, this language is not in LD( t ), for any t < n . We claim it is inBPLD(0 , p, q ), for p and q such that p + q ≤
1. Indeed, for such p and q , we can design thefollowing simple randomized algorithm that runs in 0 time: every node which is not a leadersays “yes” with probability 1, and every node which is a leader says “yes” with probability p . Clearly, if the graph has at most one leader then all nodes say “yes” with probability atleast p . On the other hand, if there are at least k ≥ − p k ≥ − p ≥ q .It turns out that the aforementioned choice of p and q is not coincidental, and that p + q =1 is really the correct threshold. Indeed, we show that Unique-Leader / ∈ BPLD( t, p, q ), forany t < n , and any p and q such that p + q >
1. In fact, we show a much more general result,that is, we prove that if p + q >
1, then restricted to hereditary languages, BPLD( t, p, q )actually collapses into LD( O ( t )), for any t .In the second part of the paper, we investigate the impact of non-determinism on localdecision, and establish some structural results inspired by classical computational complexitytheory. Specifically, we show that non-determinism does help, but that this help is limited,as there exist languages that cannot be decided non-deterministically. Perhaps surprisingly,it turns out that it is the combination of randomization with non-determinism that enablesto decide all languages in constant time. Finally, we introduce the notion of local reduction,and establish some completeness results. We study the impact of randomization on local decision. We prove that if p + q > t, p, q ) = LD( O ( t )), for any function t . This,together with the observation that LD( t ) ( BPLD( t, p, q ), for any t = o ( n ), may indicatethat p + q = 1 serves as a sharp threshold for distinguishing the deterministic case from the3andomized one. We first show that non-determinism helps local decision, i.e., we show that the class NLD( t )(cf. Section 2.3) strictly contains LD( t ). More precisely, we show that there exists a languagein NLD( O (1)) which is not in LD( t ) for every t = o ( n ), where n is the size of the input graph.Nevertheless, NLD( t ) does not capture all (decidable) languages, for t = o ( n ). Indeed weshow that there exists a language not in NLD( t ) for every t = o ( n ). Specifically, this languageis = { ( G, n ) | | V ( G ) | = n } . Perhaps surprisingly, it turns out that it is the combination of randomization with non-determinism that enables to decide all languages in constant time. Let BPNLD( O (1)) =BPNLD( O (1) , p, q ), for some constants p and q such that p + q ≤
1. We prove thatBPNLD( O (1)) contains all languages. To sum up, LD( o ( n )) ( NLD( O (1)) ⊂ NLD( o ( n )) ( BPNLD( O (1)) = All.Finally, we introduce the notion of many-one local reduction, and establish some com-pleteness results. We show that there exits a problem, called cover , which is, in a sense,the most difficult decision problem. That is we show that cover is BPNLD( O (1))-complete.(Interestingly, a small relaxation of cover , called containment , turns out to be NLD( O (1))-complete). Locality issues have been thoroughly studied in the literature, via the analysis of variousconstruction problems, including (∆ + 1)-coloring and Maximal Independent Set (MIS) [1,5, 23, 26, 28, 30, 35], Minimum Spanning Tree (MST) [12, 25, 37], Maximal Matching [19],Maximum Weighted Matching [31, 32, 41], Minimum Dominating Set [24, 27], Spanners [9,13, 38], etc. For some problems (e.g., coloring [5, 23, 35]), there are still large gaps betweenthe best known results on specific families of graphs (e.g., bounded degree graphs) and onarbitrary graphs.The question of what can be computed in a constant number of communication roundswas investigated in the seminal work of Naor and Stockmeyer [34]. In particular, that pa-per considers a subclass of LD( O (1)), called LCL, which is essentially LD( O (1)) restrictedto languages involving graphs of constant maximum degree, and involving processor inputstaken from a set of constant size, and studies the question of how to compute in O (1) rounds4he constructive versions of decision problems in LCL. The paper provides some beautifulgeneral results. In particular, the authors show that if there exists a randomized algorithmthat constructs a solution for a problem in LCL in O (1) rounds, then there is also a deter-ministic algorithm constructing a solution for this problem in O (1) rounds. Unfortunately,the proof of this result relies heavily on the definition of LCL. Indeed, the constant boundconstraints on the degrees and input sizes allow the authors to cleverly use Ramsey theory.It is thus not clear whether it is possible to extend this result to all languages in LD( O (1)).The question of whether randomization helps in decreasing the locality parameter ofconstruction problems has been the focus of numerous studies. To date, there exists evidencethat, for some problems at least, randomization does not help. For instance, [33] proves thisfor 3-coloring the ring. In fact, for low degree graphs, the gaps between the efficiencies of thebest known randomized and deterministic algorithms for problems like MIS, (∆+1)-coloring,and Maximal Matching are very small. On the other hand, for graphs of arbitrarily largedegrees, there seem to be indications that randomization does help, at least in some cases. Forinstance, (∆ + 1)-coloring can be randomly computed in expected O (log n ) communicationrounds on n -node graphs [1, 30], whereas the best known deterministic algorithm for thisproblem performs in 2 O ( √ log n ) rounds [35]. (∆ + 1)-coloring results whose performancesare measured also with respect to the maximum degree ∆ illustrate this phenomena aswell. Specifically, [39] shows that (∆ + 1)-coloring can be randomly computed in expected O (log ∆ + √ log n ) communication rounds whereas the best known deterministic algorithmperforms in O (∆ + log ∗ n ) rounds [5, 23].Recently, several results were established conserving decision problems in distributedcomputing. For example, [8] and [20] study specific decision problems in the CON GE ST model. (In contrast to the
LOCAL model, this model assumes that the message size isbounded by O (log n ) bits, hence dealing with congestion is the main issue.) Specifically,tight bounds are established in [20] for the time and message complexities of the problem ofdeciding whether a subgraph is an MST, and time lower bounds for many other subgraph-decision problems (e.g., spanning tree, connectivity) are established in [8]. It is interestingto note that some of these lower bounds imply strong unconditional time lower bounds onthe hardness of distributed approximation for many classical construction problems in the CON GE ST model. Decision problems have received recent attention from the asynchrony-discipline too, in the framework of wait-free computing [17]. In this framework, the focus ison task checkability. Wait-free checkable tasks have been characterized in term of coveringspaces, a fundamental tool in algebraic topology.The theory of proof-labeling schemes [21, 22] was designed to tackle the issue of locally5erifying (with the aid of a proof , i.e., a certificate, at each node) solutions to problemsthat cannot be decided locally (e.g.,“is the given subgraph a spanning tree of the network?”,or, “is it an MST?”). In fact, the model of proof-labeling schemes has some resemblanceto our definition of the class NLD( O (1)). Investigations in the framework of proof-labelingschemes mostly focus on the minimum size of the certificate necessary so that verification canbe performed in a single round. The notion of proof-labeling schemes also has interestingsimilarities with the notions of local detection [2], local checking [3], or silent stabilization [11], which were introduced in the context of self-stabilization [10].The use of oracles that provide information to nodes was studied intensively in the contextof distributed construction tasks. For instance, this framework, called local computation withadvice , was studied in [15] for MST construction and in [15] for 3-coloring a cycle.Finally, we note that our notion of NLD seems to be related to the theory of lifts , e.g.,[29]. Let us first recall some basic notions in distributed computing. We consider the
LOCAL model [36], which is a standard model capturing the essence of locality. In this model, pro-cessors are assumed to be nodes of a network G , provided with arbitrary distinct identities,and computation proceeds in fault-free synchronous rounds. At each round, every processor v ∈ V ( G ) exchanges messages of unrestricted size with its neighbors in G , and performscomputations on its data. We assume that the number of steps (sequential time) used forthe local computation made by the node v in some round r is bounded by some function f A ( H ( r, v )), where H ( r, v ) denotes the size of the “history” seen by node v up to the begin-ning of round r . That is, the total number of bits encoded in the input and the identity ofthe node, as well as in the incoming messages from previous rounds. Here, we do not imposeany restriction on the growth rate of f A . We would like to point out, however, that imposingsuch restrictions, or alternatively, imposing restrictions on the memory used by a node forlocal computation, may lead to interesting connections between the theory of locality andclassical computational complexity theory. To sum up, during the execution of a distributedalgorithm A , all processors are woken up simultaneously, and, initially, a processor is solelyaware of it own identity, and possibly to some local input too. Then, in each round r , everyprocessor v
61) sends messages to its neighbors,(2) receives messages from its neighbors, and(3) performs at most f A ( H ( r, v )) computations.After a number of rounds (that may depend on the network G and may vary among theprocessors, simply because nodes have different identities, potentially different inputs, andare typically located at non-isomorphic positions in the network), every processor v termi-nates and outputs some value out( v ). Consider an algorithm running in a network G withinput x and identity assignment Id. The running time of a node v , denoted T v ( G, x , Id), isthe maximum of the number of rounds until v outputs. The running time of the algorithm,denoted T ( G, x , Id), is the maximum of the number of rounds until all processors terminate,i.e., T ( G, x , Id) = max { T v ( G, x , Id) | v ∈ V ( G ) } . Let t be a non-decreasing function of inputconfigurations ( G, x , Id). (By non-decreasing, we mean that if G ′ is an induced subgraphof G and x ′ and Id ′ are the restrictions of x and Id, respectively, to the nodes in G ′ , then t ( G ′ , x ′ , Id ′ ) ≤ t ( G, x , Id).) We say that an algorithm A has running time at most t , if T ( G, x , Id) ≤ t ( G, x , Id), for every ( G, x , Id). We shall give special attention to the case that t represents a constant function. Note that in general, given ( G, x , Id), the nodes may not beaware of t ( G, x , Id). On the other hand, note that, if t = t ( G, x , Id) is known, then w.l.o.g.one can always assume that a local algorithm running in time at most t operates at eachnode v in two stages: (A) collect all information available in B G ( v, t ), the t -neighborhood , or ball of radius t of v in G , including inputs, identities and adjacencies, and (B) compute theoutput based on this information. LD ) We now refine some of the above concepts, in order to formally define our objects of in-terest. Obviously, a distributed algorithm that runs on a graph G operates separately oneach connected component of G , and nodes of a component G ′ of G cannot distinguish theunderlying graph G from G ′ . For this reason, we consider connected graphs only. Definition 2.1 A configuration is a pair ( G, x ) where G is a connected graph, and everynode v ∈ V ( G ) is assigned as its local input a binary string x ( v ) ∈ { , } ∗ . In some problems, the local input of every node is empty, i.e., x ( v ) = ǫ for every v ∈ V ( G ),where ǫ denotes the empty binary string. Since an undecidable collection of configurationsremains undecidable in the distributed setting too, we consider only decidable collections ofconfigurations. Formally, we define the following.7 efinition 2.2 A distributed language is a decidable collection L of configurations. In general, there are several possible ways of representing a configuration of a distributedlanguage corresponding to standard distributed computing problems. Some examples con-sidered in this paper are the following.
Unique-Leader = { ( G, x ) |k x k ≤ } consists of all configurations such that there existsat most one node with local input 1, with all the others having local input 0. Consensus = { ( G, ( x , x )) | ∃ u ∈ V ( G ) , ∀ v ∈ V ( G ) , x ( v ) = x ( u ) } consists of all config-urations such that all nodes agree on the value proposed by some node. Coloring = { ( G, x ) | ∀ v ∈ V ( G ) , ∀ w ∈ N ( v ) , x ( v ) = x ( w ) } where N ( v ) denotes the (open)neighborhood of v , that is, all nodes at distance 1 from v . MIS = { ( G, x ) | S = { v ∈ V ( G ) | x ( v ) = 1 } forms a MIS } . SpanningTree = { ( G, (name , head)) | T = { e v = ( v, v + ) , v ∈ V ( G ) , head( v ) = name( v + ) } is a spanning tree of G } consists of all configurations such that the set T of edges e v between every node v and its neighbor v + satisfying name( v + ) = head( v ) forms aspanning tree of G .(The language MST , for minimum spanning tree, can be defined similarly).An identity assignment Id for a graph G is an assignment of distinct integers to thenodes of G . A node v ∈ V ( G ) executing a distributed algorithm in a configuration ( G, x )initially knows only its own identity Id( v ) and its own input x ( v ), and is unaware of thegraph G . After t rounds, v acquires knowledge only of its t -neighborhood B G ( v, t ). In eachround r of the algorithm A , a node may communicate with its neighbors by sending andreceiving messages, and may perform at most f A ( H ( r, v )) computations. Eventually, eachnode v ∈ V ( G ) must output a local output out( v ) ∈ { , } ∗ .Let L be a distributed language. We say that a distributed algorithm A decides L if andonly if for every configuration ( G, x ), and for every identity assignment Id for the nodes of G , every node of G eventually terminates and outputs “yes” or “no”, satisfying the followingdecision rules: • If ( G, x ) ∈ L , then out( v ) =“yes” for every node v ∈ V ( G ); • If ( G, x ) / ∈ L , then there exists at least one node v ∈ V ( G ) such that out( v ) =“no”.We are now ready to define one of our main subjects of interest, the class LD( t ), for localdecision . 8 efinition 2.3 Let t be a non-decreasing function of triplets ( G, x , Id) . Define
LD( t ) as theclass of all distributed languages that can be decided by a local distributed algorithm that runsin number of rounds at most t . For instance,
Coloring ∈ LD(1) and
MIS ∈ LD(1). On the other hand, it is not hard tosee that languages such as
Unique-Leader , Consensus , and
SpanningTree are not in LD( t ),for any t = o ( n ). In what follows, we define LD( O ( t )) = ∪ c> LD( c · t ). NLD ) A distributed verification algorithm is a distributed algorithm A that gets as input, in ad-dition to a configuration ( G, x ), a global certificate vector y , i.e., every node v of a graph G gets as input a binary string x ( v ) ∈ { , } ∗ , and a certificate y ( v ) ∈ { , } ∗ . A verificationalgorithm A verifies L if and only if for every configuration ( G, x ), the following hold: • If ( G, x ) ∈ L , then there exists a certificate y such that for every id-assignmentId, algorithm A applied on ( G, x ) with certificate y and id-assignment Id outputsout( v ) =“yes” for all v ∈ V ( G ); • If ( G, x ) / ∈ L , then for every certificate y and for every id-assignment Id, algorithm A applied on ( G, x ) with certificate y and id-assignment Id outputs out( v ) =“no” for atleast one node v ∈ V ( G ).One motivation for studying the nondeterministic verification framework comes from settingsin which one must perform local verifications repeatedly. In such cases, one can afford tohave a relatively “wasteful” preliminary step in which a certificate is computed for each node.Using these certificates, local verifications can then be performed very fast. See [21, 22] formore details regarding such applications. Indeed, the definition of a verification algorithmfinds similarities with the notion of proof-labeling schemes discussed in [21, 22]. Informally,in a proof-labeling scheme, the construction of a “good” certificate y for a configuration( G, x ) ∈ L may depend also on the given id-assignment. Since the question of whether a con-figuration ( G, x ) belongs to a language L is independent from the particular id-assignment,we prefer to let the “good” certificate y depend only on the configuration. In other words,as defined above, a verification algorithm operating on a configuration ( G, x ) ∈ L and a“good” certificate y must say “yes” at every node regardless of the id-assignment.We now define the class NLD( t ), for nondeterministic local decision . (our terminology isby direct analogy to the class NP in sequential computational complexity).9 efinition 2.4 Let t be a non-decreasing function of triplets ( G, x , Id) . Define
NLD( t ) asthe class of all distributed languages that can be verified in at most t communication rounds. BPLD ) A randomized distributed algorithm is a distributed algorithm A that enables every node v ,at any round r during the execution, to toss a number of random bits obtaining a string r ( v ) ∈ { , } ∗ . Clearly, this number cannot exceed f A ( H ( r, v )), the bound on the number ofcomputational steps used by node v at round r . Note however, that H ( r, v ) may now alsodepend on the random bits produced by other nodes in previous rounds. For p, q ∈ (0 , A is a ( p, q ) -decider for L , or, that it decides L with “yes” success probability p and “no” success probability q , if and only if for everyconfiguration ( G, x ), and for every identity assignment Id for the nodes of G , every node of G eventually terminates and outputs “yes” or “no”, and the following properties are satisfied: • If ( G, x ) ∈ L , then Pr[out( v ) = “yes” for every node v ∈ V ( G )] ≥ p , • If ( G, x ) / ∈ L , then Pr[out( v ) = “no” for at least one node v ∈ V ( G )] ≥ q ,where the probabilities in the above definition are taken over all possible coin tosses per-formed by nodes. We define the class BPLD( t, p, q ), for “Bounded-error Probabilistic LocalDecision”, as follows. Definition 2.5
For p, q ∈ (0 , and a function t , BPLD( t, p, q ) is the class of all distributedlanguages that have a local randomized distributed ( p, q ) -decider running in time t . (i.e., canbe decided in time t by a local randomized distributed algorithm with “yes” success probability p and “no” success probability q ). Consider some graph G , and a subset U of the nodes of G , i.e., U ⊆ V ( G ). Let G [ U ] denotethe vertex-induced subgraph of G defined by the nodes in U . Given a configuration ( G, x ),let x [ U ] denote the input x restricted to the nodes in U . For simplicity of presentation, if H is a subgraph of G , we denote x [ V ( H )] by x [ H ]. A prefix of a configuration ( G, x ) is aconfiguration ( G [ U ] , x [ U ]), where U ⊆ V ( G ) (note that in particular, G [ U ] is connected).We say that a language L is hereditary if every prefix of every configuration ( G, x ) ∈ L is alsoin L . Coloring and
Unique-Leader are clearly hereditary languages. As another example10f an hereditary language, consider a family G of hereditary graphs, i.e., that is closed undervertex deletion; then the language { ( G, ǫ ) | G ∈ G} is hereditary. Examples of hereditarygraph families are planar graphs, interval graphs, forests, chordal graphs, cographs, perfectgraphs, etc.Theorem 3.1 below asserts that, for hereditary languages, randomization does not helpif one imposes that p + q >
1, i.e, the ”no” success probability distribution is at least aslarge as one minus the square of the ”yes” success probability. Somewhat more formally,we prove that for hereditary languages, we have S p + q> BPLD( t, p, q ) = LD( O ( t )). Thiscomplements the fact that for p + q ≤
1, we have LD( t ) ( BPLD( t, p, q ), for any t = o ( n ).Recall that [34] investigates the question of whether randomization helps for constructingin constant time a solution for a problem in LCL ( LD ( O (1)). We stress that the techniqueused in [34] for tackling this question relies heavily on the definition of LCL, specifically,that only graphs of constant degree and of constant input size are considered. Hence it isnot clear whether the technique of [34] can be useful for our purposes, as we impose no suchassumptions on the degrees or input sizes. Also, although it seems at first glance, that Lovszlocal lemma might have been helpful here, we could not effectively apply it in our proof.Instead, we use a completely different approach. Theorem 3.1
Let L be an hereditary language and let t be a function. If L ∈
BPLD( t, p, q ) for constants p, q ∈ (0 , such that p + q > , then L ∈
LD( O ( t )) . Proof.
Let us start with some definitions. Let L be a language in BPLD( t, p, q ) where p, q ∈ (0 ,
1] and p + q >
1, and t is some function. Let A be a randomized algorithmdeciding L , with ”yes” success probability p , and ”no” success probability q , whose runningtime is at most t ( G, x , Id), for every configuration ( G, x ) with identity assignment Id. Fix aconfiguration ( G, x ), and an id-assignment Id for the nodes of V ( G ). The distance dist G ( u, v )between two nodes of G is the minimum number of edges in a path connecting u and v in G . The distance between two subsets U , U ⊆ V is defined asdist G ( U , U ) = min { dist G ( u, v ) | u ∈ U , v ∈ U } . For a set U ⊆ V , let E ( G, x , Id , U ) denote the event that when running A on ( G, x ) withid-assignment Id, all nodes in U output “yes”. Let v ∈ V ( G ). The running time of A at v may depend on the coin tosses made by the nodes. Let t v = t v ( G, x , Id) denote the maximalrunning time of v over all possible coin tosses. Note that t v ≤ t ( G, x , Id) (we do not assumethat neither t or t v are known to v ).The radius of a node v , denoted r v , is the maximum value t u such that there exists anode u , where v ∈ B G ( u, t u ). (Observe that the radius of a node is at most t .) The radius11f a set of nodes S is r S := max { r v | v ∈ S } . In what follows, fix a constant δ such that0 < δ < p + q −
1, and define λ = 11 ⌈ log p/ log(1 − δ ) ⌉ .A splitter of ( G, x , Id) is a triplet (
S, U , U ) of pairwise disjoint subsets of nodes suchthat S ∪ U ∪ U = V , dist G ( U , U ) ≥ λr S . (Observe that r S may depend on the identityassignment and the input, and therefore, being a splitter is not just a topological propertydepending only on G ). Given a splitter ( S, U , U ) of ( G, x , Id), let G k = G [ U k ∪ S ], and let x k be the input x restricted to nodes in G k , for k = 1 , L is hereditary. Lemma 3.2
For every configuration ( G, x ) with identity assignment Id , and every splitter ( S, U , U ) of ( G, x , Id) , we have (cid:16) ( G , x ) ∈ L and ( G , x ) ∈ L (cid:17) ⇒ ( G, x ) ∈ L . Let ( G, x ) be a configuration with identity assignment Id. Assume, towards contradic-tion, that there exists a splitter ( S, U , U ) of triplet ( G, x , Id), such that ( G , x ) ∈ L and( G , x ) ∈ L , yet ( G, x ) / ∈ L . (The fact that ( G , x ) ∈ L and ( G , x ) ∈ L implies that both G and G are connected, however, we note, that for the claim to be true, it is not requiredthat G [ U ], G [ U ] or G [ S ] are connected.) Let d = λr S .Given a vertex u ∈ S , we define the level of u by ℓ ( u ) = dist G ( U , { u } ). For an integer i ∈ [1 , d ], let L i denote the set of nodes in S of level i . For an integer i ∈ ( r S , d − r S ), let S i = S i + r S j = i − r S L j , and finally, for a set J ⊆ ( r S , d − r S ) of integers, let S J = S i ∈ J S i .Define I = { i ∈ (2 r S , d − r S ) | Pr[ E ( G, x , Id , S i )] < − δ } . Claim 3.3
There exists i ∈ (2 r S , d − r S ) such that i / ∈ I . Proof.
For proving Claim 3.3, we upper bound the size of I by d − r S −
2. This is doneby covering the integers in (2 r S , d − r S ) by at most 4 r S + 1 sets, such that each one is(4 r S + 1)-independent, that is, for every two integers in the same set, they are at least4 r S + 1 apart. Specifically, for s ∈ [1 , r S + 1] and m ( S ) = ⌈ ( d − r S ) / (4 r S + 1) ⌉ , we define J s = { s + 2 r S + j (4 r S + 1) | j ∈ [0 , m ( S )] } . Observe that, as desired, (2 r S , d − r S ) ⊂ S s ∈ [1 , r S +1] J s , and for each s ∈ [1 , r S + 1], J s is (4 r S + 1)-independent. In what follows, fix s ∈ [1 , r S + 1] and let J = J s . Since ( G , x ) ∈ L , we know that,Pr[ E ( G , x , Id , S J ∩ I )] ≥ p . Observe that for i ∈ (2 r S , d − r S ), t v ≤ r v ≤ r S , and hence, the t v -neighborhood in G of12very node v ∈ S i is contained in S ⊆ G , i.e., B G ( v, t v ) ⊆ G . It therefore follows that:Pr[ E ( G, x , Id , S J ∩ I )] = Pr[ E ( G , x , Id , S J ∩ I )] ≥ p . (1)Consider two integers a and b in J . We know that | a − b | ≥ r S + 1. Hence, the distance in G between any two nodes u ∈ S a and v ∈ S b is at least 2 r S + 1. Thus, the events E ( G, x , Id , S a )and E ( G, x , Id , S b ) are independent. It follows by the definition of I , thatPr[ E ( G, x , Id , S J ∩ I )] < (1 − δ ) | J ∩ I | (2)By (1) and (2), we have that p < (1 − δ ) | J ∩ I | and thus | J ∩ I | < log p/ log(1 − δ ). Since(2 r S , d − r S ) can be covered by the sets J s , s = 1 , . . . , r S + 1, each of which is (4 r S + 1)-independent, we get that | I | = r S +1 X s =1 | J s ∩ I | < (4 r S + 1)(log p/ log(1 − r )) . Combining this bound with the fact that d = λr S , we get that d − r S − > | I | . It follows bythe pigeonhole principle that there exists some i ∈ (2 r S , d − r S ) such that i / ∈ I , as desired.This completes the proof of Claim 3.3. (cid:3) Fix i ∈ (2 r S , d − r S ) such that i / ∈ I , and let F = E ( G, x , Id , S i ). By definition,Pr[ F ] ≤ δ < p + q − . (3)Let H denote the subgraph of G induced by the nodes in ( S i − r S − j =1 L j ) ∪ U . We similarlydefine H as the subgraph of G induced by the nodes in ( S j>i + r S L j ) ∪ U . Note that S i ∪ V ( H ) ∪ V ( H ) = V , and for any two nodes u ∈ V ( H ) and v ∈ V ( H ), we have d G ( u, v ) > r S . It follows that, for k = 1 ,
2, the t u -neighborhood in G of each node u ∈ V ( H k )equals the t u -neighborhood in G k of u , that is, B G ( u, t u ) ⊆ G k . (To see why, consider, forexample, the case k = 2. Given u ∈ V ( H ), it is sufficient to show that ∄ v ∈ V ( H ), suchthat v ∈ B G ( u, t u ). Indeed, if such a vertex v exists then d G ( u, v ) > r S , and hence t u > r S .Since there must exists a vertex w ∈ S i such that w ∈ B ( u, t u ), we get that r w > r S ,in contradiction to the fact that w ∈ S .) Thus, for k = 1 ,
2, since ( G i , x i ) ∈ L , we getPr[ E ( G, x , Id , V ( H i ))] = Pr[ E ( G i , x i , Id , V ( H i ))] ≥ p .Let F ′ = E ( G, x , Id , V ( H ) ∪ V ( H )). As the events E ( G, x , Id , V ( H )) and E ( G, x , Id , V ( H ))are independent, it follows that Pr[ F ′ ] > p , that isPr[ F ′ ] ≤ − p (4)13y Eqs. (3) and (4), and using union bound, it follows that Pr[ F ∨ F ′ ] < q . ThusPr[ E ( G, x , Id , V ( G ))] = Pr[ E ( G, x , Id , S i ∪ V ( H ) ∪ V ( H ))] = Pr[ F ∧ F ′ ] > − q . This is in contradiction to the assumption that ( G, x ) / ∈ L . This concludes the proof ofLemma 3.2. (cid:3) Our goal now is to show that
L ∈
LD( O ( t )) by proving the existence of a deterministiclocal algorithm D that runs in time O ( t ) and recognizes L . (No attempt is made here tominimize the constant factor hidden in the O ( t ) notation.) Recall that both t = t ( G, x , Id)and t v = t v ( G, x , Id) may not be known to v . Nevertheless, by inspecting the balls B G ( v, i )for increasing i = 1 , , · · · , each node v can compute an upper bound on t v as given by thefollowing claim. Claim 3.4
Fix a a configuration ( G, x ) , an id-assignment Id , and a constant c . In O ( t ) time, each node v can compute a value t ∗ v = t ∗ v ( c ) such that (1) c · t v ≤ t ∗ v = O ( t ) and (2) forevery u ∈ B G ( v, c · t ∗ v ) , we have t u ≤ t ∗ v . To establish the claim, observe first that in O ( t ) time, each node v can compute a value t ′ v satisfying t v ≤ t ′ v ≤ t . Indeed, given the ball B G ( v, i ), for some integer i , and usingthe upper bound on number of (sequential) local computations, node v can simulate all itspossible executions up to round r = 2 i . The desired value t ′ v is the smallest r = 2 i for whichall executions of v up to round r conclude with an output at v . Once t ′ v is computed, node v aims at computing t ∗ v . For this purpose, it starts again to inspect the balls B G ( v, i ) forincreasing i = 1 , , · · · , to obtain t ′ u from each u ∈ B G ( v, i ). (For this purpose, it may needto wait until u computes t ′ u , but this delays the whole computation by at most O ( t ) time.)Now, node v outputs t ∗ v = 2 i for the smallest i satisfying (1) c · t ′ v ≤ i and (2) for every u ∈ B G ( v, c · i ), we have t ′ u ≤ t ∗ v . It is easy to see that for this i , we have 2 i = O ( t ), hence t ∗ v = O ( t ).Given a configuration ( G, x ), and an id-assignment Id, Algorithm D , applied at a node u first calculates t ∗ u = t ∗ u (6 λ ), and then outputs “yes” if and only if the 2 λt ∗ u -neighborhoodof u in ( G, x ) belongs to L . That is,out( u ) = “yes” ⇐⇒ ( B G ( u, λt ∗ u ) , x [ B G ( u, λt ∗ u )]) ∈ L . Obviously, Algorithm D is a deterministic algorithm that runs in time O ( t ). We claimthat Algorithm D decides L . Indeed, since L is hereditary, if ( G, x ) ∈ L , then every prefixof ( G, x ) is also in L , and thus, every node u outputs out( u ) =“yes”. Now consider thecase where ( G, x ) / ∈ L , and assume by contradiction that by applying D on ( G, x ) with14d-assignment Id, every node u outputs out( u ) =“yes”. Let U ⊆ V ( G ) be maximal byinclusion, such that G [ U ] is connected and ( G [ U ] , x [ U ]) ∈ L . Obviously, U is not empty, as( B G ( u, λt ∗ v ) , x [ B G ( u, λt ∗ v )]) ∈ L for every node u . On the other hand, we have | U | < | V ( G ) | ,because ( G, x ) / ∈ L .Let u ∈ U be a node with maximal t u such that B G ( u, t u ) contains a node outside U . Define G ′ as the subgraph of G induced by U ∪ V ( B G ( u, t u )). Observe that G ′ isconnected and that G ′ strictly contains U . Towards contradiction, our goal is to show that( G ′ , x [ G ′ ]) ∈ L .Let H denote the graph which is maximal by inclusion such that H is connected and B G ( u, t u ) ⊂ H ⊆ B G ( u, t u ) ∪ ( U ∩ B G ( u, λt ∗ u )) . Let W , W , · · · , W ℓ be the ℓ connected components of G [ U ] \ B G ( u, t u ), ordered arbitrarily.Let W be the empty graph, and for k = 0 , , , · · · , ℓ , define the graph Z k = H ∪ W ∪ W ∪ W ∪ · · · ∪ W k . Observe that Z k is connected for each k = 0 , , , · · · , ℓ .We prove by induction on k that ( Z k , x [ Z k ]) ∈ L for every k = 0 , , , · · · , ℓ . This willestablish the contradiction since Z ℓ = G ′ . For the basis of the induction, the case k = 0,we need to show that ( H, x [ H ]) ∈ L . However, this is immediate by the facts that H is aconnected subgraph of B G ( u, λt ∗ u ), the configuration ( B G ( u, λt ∗ u ) , x [ B G ( u, λt ∗ u )]) ∈ L , and L is hereditary. Assume now that we have ( Z k , x [ Z k ]) ∈ L for 0 ≤ k < ℓ , and consider thegraph Z k +1 = Z k ∪ W k +1 . Define the sets of nodes S = V ( Z k ) ∩ V ( W k +1 ) , U = V ( Z k ) \ S, and U = V ( W k +1 ) \ S .
A crucial observation is that (
S, U , U ) is a splitter of Z k +1 . This follows from the followingarguments. Let us first show that r S ≤ t ∗ u . By definition, we have t v ≤ t ∗ u , for every v ∈ B G ( u, λt ∗ u ). Hence, in order to bound the radius of S (in Z k +1 ) by t ∗ u it is sufficientto prove that there is no node w ∈ U \ B G ( u, λt ∗ u ) such that B G ( w, t w ) ∩ S = ∅ . Indeed,if such a node w exists then t w > λt ∗ u and hence B G ( w, t w ) contains a node outside U , incontradiction to the choice of u . It follows that r S ≤ t ∗ u .We now claim that dist Z k +1 ( U , U ) ≥ λt ∗ u . Consider a simple directed path P in Z k +1 going from a node x ∈ U to a node y ∈ U . Since x / ∈ V ( W k +1 ) and y ∈ V ( W k +1 ), we getthat P must pass through a vertex in B G ( u, t u ). Let z be the last vertex in P such that z ∈ B G ( u, t u ), and consider the directed subpath P [ z,y ] of P going from z to y . Now, let P ′ = P [ z,y ] \ { z } . The first d ′ = min { (2 λ − t ∗ u , | P ′ |} vertices in the directed subpath P ′ mustbelong to V ( H ) ⊆ V ( Z k ). In addition, observe that all nodes in P ′ must be in V ( W k +1 ). Itfollows that the first d ′ nodes of P ′ are in S . Since y / ∈ S , we get that | P ′ | ≥ d ′ = (2 λ − t ∗ u ,15nd thus | P | > λt ∗ u . Consequently, dist Z k +1 ( U , U ) ≥ λt ∗ u , as desired. This completes theproof that ( S, U , U ) is a splitter of Z k +1 .Now, by the induction hypothesis, we have ( G , x [ G ]) ∈ L , because G = G [ U ∪ S ] = Z k .In addition, we have ( G , x [ G ]) ∈ L , because G = G [ U ∪ S ] = W k +1 , and W k +1 is a prefixof G [ U ]. We can now apply Lemma 3.2 and conclude that ( Z k +1 , x [ Z k +1 ]) ∈ L . Thisconcludes the induction proof. The theorem follows. (cid:3) Let
Planar = { ( G, ǫ ) : G is planar } , Interval = { ( G, ǫ ) : G is an interval graph } and CycleFree = { ( G, ǫ ) : G has no cycle } . One can easily check that neither of these threelanguages is in LD( t ), for any t = o ( n ). Hence, Theorem 3.1 yields the following. Corollary 3.5
Let p, q ∈ (0 , such that p + q > , then Unique-Leader , Planar , Interval and
CycleFree are not in
BPLD( t, p, q ) , for any t = o ( n ) . Our first separation result indicates that non-determinism helps for local decision. Indeed,we show that there exists a language, specifically, tree = { ( G, ǫ ) | G is a tree } , whichbelongs to NLD(1) but not to LD( t ), for any t = o ( n ). The proof follows by rather standardarguments. Theorem 4.1
LD( t ) ( NLD( t ) , for any t = o ( n ) . Proof.
To establish the theorem it is sufficient to show that there exists a language L such that L / ∈ LD( o ( n )) and L ∈
NLD(1). Let tree = { ( G, ǫ ) | G is a tree } . Wehave tree / ∈ LD ( o ( n )). To see why, consider a cycle C with nodes labeled consecutivelyfrom 1 to 4 n , and the path P (resp., P ) with nodes labeled consecutively 1 , . . . , n (resp.,2 n + 1 , . . . , n, , . . . , n ), from one extremity to the other. For any algorithm A deciding tree , all nodes n + 1 , . . . , n output “yes” in configuration ( P , ǫ ) for any identity assignmentfor the nodes in P , while all nodes 3 n + 1 , . . . , n, , . . . , n output “yes” in configuration( P , ǫ ) for any identity assignment or the nodes in P . Thus if A is local, then all nodesoutput “yes” in configuration ( C, ǫ ), a contradiction. In contrast, we next show that tree ∈ NLD. The (nondeterministic) local algorithm A verifying tree operates as follows. Givena configuration ( G, ǫ ), the certificate given at node v is y ( v ) = dist G ( v, r ) where r ∈ V ( G )is an arbitrary fixed node. The verification procedure is then as follows. At each node v , A • y ( v ) is a non-negative integer, • if y ( v ) = 0, then y ( w ) = 1 for every neighbor w of v , and • if y ( v ) >
0, then there exists a neighbor w of v such that y ( w ) = y ( v ) −
1, and, for allother neighbors w ′ of v , we have y ( w ′ ) = y ( v ) + 1.If G is a tree, then applying Algorithm A on G with the certificate yields the answer “yes”at all nodes regardless of the given id-assignment. On the other hand, if G is not a tree,then we claim that for every certificate, and every id-assignment Id, Algorithm A outputs“no” at some node. Indeed, consider some certificate y given to the nodes of G , and let C be a simple cycle in G . Assume, for the sake of contradiction, that all nodes in C output“yes”. In this case, each node in C has at least one neighbor in C with a larger certificate.This creates an infinite sequence of strictly increasing certificates, in contradiction with thefiniteness of C . (cid:3) Theorem 4.2
There exists a language L such that L / ∈ NLD( t ) , for any t = o ( n ) . Proof.
Let
InpEqSize = { ( G, x ) | ∀ v ∈ V ( G ) , x ( v ) = | V ( G ) |} . We show that InpEqSize / ∈ NLD( t ), for any t = o ( n ). Assume, for the sake of contradiction, that thereexists a local nondeterministic algorithm A deciding InpEqSize . Let t < n/ A . Consider the cycle C with 2 t + 1 nodes u , u , · · · , u t +1 , enumerated clockwise.Assume that the input at each node u i of C satisfies x ( u i ) = 2 t + 1. Then, there exists acertificate y such that, for any identity assignment Id, algorithm A outputs “yes” at eachnode of C . Now, consider the configuration ( C ′ , x ′ ) where the cycle C ′ has 4 t + 2 nodes, andfor each node v i of C ′ , x ′ ( v i ) = 2 t + 1. We have ( C ′ , x ′ ) / ∈ InpEqSize . To fool Algorithm A , we enumerate the nodes in C ′ clockwise, i.e., C = ( v , v , · · · , v t +2 ). We then define thecertificate y ′ as follows: y ′ ( v i ) = y ′ ( v i +2 t +1 ) = y ( u i ) for i = 1 , , · · · t + 1 . Fix an id-assignment Id ′ for the nodes in V ( C ′ ), and fix i ∈ { , , · · · t + 1 } . Thereexists an id-assignment Id for the nodes in V ( C ), such that the output of A at node v i in( C ′ , x ′ ) with certificate y ′ and id-assignment Id ′ is identical to the output of A at node u i in( C, x ) with certificate y and id-assignment Id . Similarly, there exists an id-assignment Id for the nodes in V ( C ) such that the output of A at node v i +2 t +1 in ( C ′ , x ′ ) with certificate y ′ and id-assignment Id ′ is identical to the output of A at node u i in ( C, x ) with with17ertificate y and id-assignment Id . Thus, Algorithm A at both v i and v i +2 t +1 outputs “yes”in ( C ′ , x ′ ) with certificate y ′ and id-assignment Id ′ . Hence, since i was arbitrary, all nodesoutput “yes” for this configuration, certificate and id-assignment, contradicting the fact that( C ′ , x ′ ) / ∈ InpEqSize . (cid:3) For p, q ∈ (0 ,
1] and a function t , let us define BPNLD( t, p, q ) as the class of all distributedlanguages that have a local randomized non-deterministic distributed ( p, q )-decider runningin time t . Theorem 4.3
Let p, q ∈ (0 , such that p + q ≤ . For every language L , we have L ∈
BPNLD(1 , p, q ) . Proof.
Let L be a language. The certificate of a configuration ( G, x ) ∈ L is a map of G ,with nodes labeled with distinct integers in { , ..., n } , where n = | V ( G ) | , together with theinputs of all nodes in G . In addition, every node v receives the label λ ( v ) of the correspondingvertex in the map. Precisely, the certificate at node v is y ( v ) = ( G ′ , x ′ , i ) where G ′ is anisomorphic copy of G with nodes labeled from 1 to n , x ′ is an n -dimensional vector suchthat x ′ [ λ ( u )] = x ( u ) for every node u , and i = λ ( v ). The verification algorithm involveschecking that the configuration ( G ′ , x ′ ) is identical to ( G, x ). This is sufficient becausedistributed languages are sequentially decidable, hence every node can individually decidewhether ( G ′ , x ′ ) belongs to L or not, once it has secured the fact that ( G ′ , x ′ ) is the actualconfiguration. It remains to show that there exists a local randomized non-deterministicdistributed ( p, q )-decider for verifying that the configuration ( G ′ , x ′ ) is identical to ( G, x ),and running in time 1.The non-deterministic ( p, q )-decider operates as follows. First, every node v checks thatit has received the input as specified by x ′ , i.e., v checks wether x ′ [ λ ( v )] = x ( v ), and outputs“no” if this does not hold. Second, each node v communicates with its neighbors to checkthat (1) they all got the same map G ′ and the same input vector x ′ , and (2) they are labeledthe way they should be according to the map G ′ . If some inconsistency is detected by a node,then this node outputs “no”. Finally, consider a node v that passed the aforementioned twophases without outputting “no” . If λ ( v ) = 1 then v outputs “yes” (with probability 1), andif λ ( v ) = 1 then v outputs “yes” with probability p .We claim that the above implements a non-deterministic distributed ( p, q )-decider forverifying that the configuration ( G ′ , x ′ ) is identical to ( G, x ). Indeed, if all nodes pass thetwo phases without outputting “no”, then they all agree on the map G ′ and on the inputvector x ′ , and they know that their respective neighborhood fits with what is indicated onthe map. Hence, ( G ′ , x ′ ) is a lift of ( G, x ). If follows that ( G ′ , x ′ ) = ( G, x ) if and only18f there exists at most one node v ∈ G , whose label satisfies λ ( v ) = 1. Consequently, if( G ′ , x ′ ) = ( G, x ) then all nodes say “yes” with probability at least p . On the other hand, if( G ′ , x ′ ) = ( G, x ) then there are at least two nodes in G whose label is “1”. These two nodessay “yes” with probability p , hence, the probability that at least one of them says “no” isat least 1 − p ≥ q . This completes the proof of Theorem 4.3. (cid:3) The above theorem guarantees that the following definition is well defined. Let BPNLD =BPNLD(1 , p, q ), for some p, q ∈ (0 ,
1] such that p + q ≤
1. The following follows fromTheorems 4.1, 4.2 and 4.3.
Corollary 4.4
LD( o ( n )) ( NLD( O (1)) ⊂ NLD( o ( n )) ( BPNLD =
All.
Let us first define a notion of reduction that fits the class LD. For two languages L , L , wesay that L is locally reducible to L , denoted by L (cid:22) L , if there exists a constant timelocal algorithm A such that, for every configuration ( G, x ) and every id-assignment Id, A produces out( v ) ∈ { , } ∗ as output at every node v ∈ V ( G ) so that( G, x ) ∈ L ⇐⇒ ( G, out) ∈ L . By definition, LD( O ( t )) is closed under local reductions, that is, for every two languages L , L satisfying L (cid:22) L , if L ∈ LD( O ( t )) then L ∈ LD( O ( t )).We now show that there exists a natural problem, called cover , which is in some sensethe “most difficult” decision problem; that is, we show that cover is BPNLD-complete.Language cover is defined as follows. Every node v is given as input an element E ( v ), and afinite collection of sets S ( v ). The union of these inputs is in the language if there exists a node v such that one set in S ( v ) equals the union of all the elements given to the nodes. Formally,we define cover = { ( G, ( E , S )) | ∃ v ∈ V ( G ) , ∃ S ∈ S ( v ) s.t. S = {E ( v ) | v ∈ V ( G ) } . Theorem 4.5 cover is BPNLD -complete.
Proof.
The fact that cover ∈ BPNLD follows from Theorem 4.3. To prove that cover isBPNLD-hard, we consider some
L ∈
BPNLD and show that
L (cid:22) cover . For this purpose, wedescribe a local distributed algorithm A transforming any configuration for L to a configura-tion for cover preserving the memberships to these languages. Let ( G, x ) be a configurationfor L and let Id be an identity assignment. Algorithm A operating at a node v outputs apair ( E ( v ) , S ( v )), where E ( v ) is the “local view” at v in ( G, x ), i.e., the star subgraph of G consisting of v and its neighbors, together with the inputs of these nodes and their identities,19nd S ( v ) is the collection of sets S defined as follows. For a binary string x , let | x | denotethe length of x , i.e., the number of bits in x . For every vertex v , let ψ ( v ) = 2 | Id ( v ) | + | x ( v ) | .Node v first generates all configurations ( G ′ , x ′ ) where G ′ is a graph with k ≤ ψ ( v ) vertices,and x ′ is a collection of k input strings of length at most ψ ( v ), such that ( G ′ , x ′ ) ∈ L . Foreach such configuration ( G ′ , x ′ ), node v generates all possible Id ′ assignments to V ( G ′ ) suchthat for every node u ∈ V ( G ′ ), | Id( u ) | ≤ ψ ( v ). Now, for each such pair of a graph ( G ′ , x ′ )and an Id ′ assignment, algorithm A associates a set S ∈ S ( v ) consisting of the k = | V ( G ′ ) | local views of the nodes of G ′ in ( G ′ , x ′ ). We show that ( G, x ) ∈ L ⇐⇒ A ( G, x ) ∈ cover .If ( G, x ) ∈ L , then by the construction of Algorithm A , there exists a set S ∈ S ( v ) suchthat S covers the collection of local views for ( G, x ), i.e., S = {E ( u ) | u ∈ G } . Indeed,the node v maximizing ψ ( v ) satisfies ψ ( v ) ≥ max { Id( u ) | u ∈ V ( G ) } ≥ n and ψ ( v ) ≥ max { x ( u ) | u ∈ V ( G ) } . Therefore, that specific node has constructed a set S which containsall local views of the given configuration ( G, x ) and Id assignemnt. Thus A ( G, x ) ∈ cover .Now consider the case that A ( G, x ) ∈ cover . In this case, there exists a node v and aset S ∈ S ( v ) such that S = {E ( u ) | u ∈ G } . Such a set S is the collection of local viewsof nodes of some configuration ( G ′ , x ′ ) ∈ L and some Id ′ assignment. On the other hand, S is also the collection of local views of nodes of the given configuration ( G, x ) ∈ L and Idassignment. It follows that ( G, x ) = ( G ′ , x ′ ) ∈ L . (cid:3) We now define a natural problem, called containment , which is NLD( O (1))-complete.Somewhat surprisingly, the definition of containment is quite similar to the definition of cover . Specifically, as in cover , every node v is given as input an element E ( v ), and a finitecollection of sets S ( v ). However, in contrast to cover , the union of these inputs is in the containment language if there exists a node v such that one set in S ( v ) contains the unionof all the elements given to the nodes. Formally, we define containment = { ( G, ( E , S )) |∃ v ∈ V ( G ) , ∃ S ∈ S ( v ) s.t. S ⊇ {E ( v ) | v ∈ V ( G ) } . Theorem 4.6 containment is NLD( O (1)) -complete. Proof.
We first prove that containment is NLD( O (1))-hard. Consider some L ∈
NLD( O (1));we show that L (cid:22) containment . For this purpose, we describe a local distributed algorithm D transforming any configuration for L to a configuration for containment preserving thememberships to these languages.Let t = t L ≥ A L deciding L in time at most t . Let ( G, x ) be a configuration for L and let Id bean identity assignment. Algorithm D operating at a node v outputs a pair ( E ( v ) , S ( v )), where E ( v ) is the “ t -local view” at v in ( G, x ), i.e., the ball of radius t around v , B G ( v, t ), together20ith the inputs of these nodes and their identities, and S ( v ) is the collection of sets S definedas follows. For a binary string x , let | x | denote the length of x , i.e., the number of bits in x .For every vertex v , let ψ ( v ) = 2 | Id ( v ) | + | x ( v ) | . Node v first generates all configurations ( G ′ , x ′ )where G ′ is a graph with m ≤ ψ ( v ) vertices, and x ′ is a collection of m input strings of lengthat most ψ ( v ), such that ( G ′ , x ′ ) ∈ L . For each such configuration ( G ′ , x ′ ), node v generatesall possible Id ′ assignments to V ( G ′ ) such that for every node u ∈ V ( G ′ ), | Id( u ) | ≤ ψ ( v ).Now, for each such pair of a graph ( G ′ , x ′ ) and an Id ′ assignment, algorithm D associates aset S ∈ S ( v ) consisting of the m = | V ( G ′ ) | t -local views of the nodes of G ′ in ( G ′ , x ′ ). Weshow that ( G, x ) ∈ L ⇐⇒ D ( G, x ) ∈ containment .If ( G, x ) ∈ L , then by the construction of Algorithm D , there exists a set S ∈ S ( v ) suchthat S covers the collection of t -local views for ( G, x ), i.e., S = {E ( u ) | u ∈ G } . Indeed,the node v maximizing ψ ( v ) satisfies ψ ( v ) ≥ max { Id( u ) | u ∈ V ( G ) } ≥ n and ψ ( v ) ≥ max { x ( u ) | u ∈ V ( G ) } . Therefore, that specific node has constructed a set S that preciselycorresponds to ( G, x ) and its given Id assignment; hence, S contains all corresponding t -localviews. Thus, D ( G, x ) ∈ containment .Now consider the case that D ( G, x ) ∈ containment . In this case, there exists a node v and a set S ∈ S ( v ) such that S ⊇ {E ( u ) | u ∈ G } . Such a set S is the collection of t -local views of nodes of some configuration ( G ′ , x ′ ) ∈ L and some Id ′ assignment. Since( G ′ , x ′ ) ∈ L , there exists a certificate y ′ for the nodes of G ′ , such that when algorithm A L operates on ( G ′ , x ′ , y ′ ), all nodes say “yes”. Now, since S contains the t -local views of nodes( G, x ), with the corresponding identities, there exists a mapping φ : ( G, x , Id) → ( G ′ , x ′ , Id ′ )that preserves inputs and identities. Moreover, when restricted to a ball of radius t arounda vertex v ∈ G , φ is actually an isomorphism between this ball and its image. We assign acertificate y to the nodes of G : for each v ∈ V ( G ), y ( v ) = y ′ ( φ ( v )). Now, Algorithm A L when operating on ( G, x , y ) outputs “yes” at each node of G . By the correctness of A L , weobtain ( G, x ) ∈ L .We now show that containment ∈ NLD( O (1)). For this purpose, we design a nondeter-ministic local algorithm A that decides whether a configuration ( G, x ) is in containment .Such an algorithm A is designed to operate on ( G, x , y ), where y is a certificate. The con-figuration ( G, x ) satisfies that x ( v ) = ( E ( v ) , S ( v )). Algorithm A aims at verifying whetherthere exists a node v ∗ with a set S ∗ ∈ S ( v ∗ ) such that S ∗ ⊇ {E ( v ) | v ∈ V ( G ) } .Given a correct instance, i.e., a configuration ( G, x ), we define the certificate y asfollows. For each node v , the certificate y ( v ) at v consists of several fields, specifically, y ( v ) = ( y c ( v ) , y s ( v ) , y id ( v ) , y l ( v )). The candidate configuration field y c ( v ) is a triplet y c ( v ) = ( G ′ , x ′ , Id ′ ), where ( G ′ , x ′ ) is an isomorphic copy ( G ′ , x ′ ) of ( G, x ) and Id ′ is an21dentity assignment for the nodes of G ′ . The candidate set field y s ( v ) is a copy of S ∗ , i.e., y s ( v ) = S ∗ . In addition, let u and u ∗ be the nodes in ( G ′ , x ′ ) corresponding to v and v ∗ ,respectively. The candidate identity field y id ( v ) is y id ( v ) = Id ′ ( u ), and the candidate leader field y l ( v ) is y l ( v ) = Id ′ ( u ∗ ).We describe the operation of Algorithm A on some triplet ( G, x , y ). First, each node v verifies that it agrees with its neighbors on the candidate configuration and candidate setfields in their certificates. That way, if all nodes say “yes” then we know that all nodes holdthe same candidate configuration which is some triplet ( G ′ , x ′ , Id ′ ), and the same candidateset S ′ . Second, each node verifies that E ( v ) ∈ S ′ . Also, each node checks that it agrees withits neighbors on the candidate leader field in their certificates. I.e, that there exists someinteger k such that for all nodes v we have y l ( v ) = k . Each node v checks that there existsa node u ∗ ∈ V ( G ′ ) such that Id ′ ( u ∗ ) = k , and that there exists a node v ′ ∈ V ( G ′ ) suchthat y id ( v ) = Id ′ ( v ′ ). Moreover, node v verifies that the input x ′ at v ′ contains a collectionof sets S ′ ( v ′ ) that contains S ′ , that is, S ′ ∈ S ′ ( v ′ ). Finally, each node v verifies that itsimmediate neighborhood B G ( v,
1) agrees with the corresponding neighborhood of v ′ in G ′ ,and that the candidate identities y id ( w ) of its neighbors w ∈ B G ( v,
1) are compatible withthe corresponding identities Id ′ ( w ′ ) in G ′ . We term this verification the neighborhood check of v .It is easy to see that when applying Algorithm A on a correct instance, together withthe certificate described above, each node outputs “yes”. We now show the other direction.Assume that Algorithm A applied on some triplet ( G, x , y ) outputs “yes” at each node,our goal is to show that ( G, x ) ∈ L . Since all nodes say “yes” on ( G, x , y ), it follows thatthe certificate y ( v ) at every node v ∈ V ( G ) contains the same candidate configuration field( G ′ , x ′ , Id ′ ), the same candidate set S ′ and the same pointer Id ′ ( v ′ ) to a vertex v ′ ∈ G ′ ,such that S ′ ∈ S ( v ′ ). Since each node v ∈ V ( G ) verifies that E ( v ) ∈ S ′ , it follows that S ′ ⊇ {E ( v ) | v ∈ V ( G ) } . It remains to show that there exists a node v ∗ ∈ V ( G ) such that S ′ ∈ S ( v ∗ ). Indeed, this follows by the neighborhood checks of all nodes. (cid:3) This paper aims to make a first step in the direction of establishing a complexity theory forthe locality discipline. Many interesting questions are left open. For example, it would beinteresting to investigate the connections between BPLD( t, p, q ) for different p and q suchthat p + q ≤
1. (A simple observation shows that BPLD( t, p, q ) ⊆ BPLD( t, p k , − (1 − q ) k ),for every integer k . Indeed, given an algorithm with a “yes” and “no” success probabilities22 and q , one can modify the success probabilities by performing k runs and requiring eachnode to individually output “no” if it decided “no” on at least one of the runs. In thiscase, the “no” success probability increases from q to at least 1 − (1 − q ) k , and the “yes”success probability then decreases from p to p k .) Another interesting question is whetherthe phenomena we observed regarding randomization occurs also in the non-deterministicsetting, that is, whether BPNLD( t, p, q ) collapses into NLD( O ( t )), for p + q > LOCAL model, focuses on difficulties arisingfrom purely locality issues, and abstracts away other complexity measures. Naturally, itwould be very interesting to come up with a rigorous complexity framework taking intoaccount also other complexity measures. For example, it would be interesting to investigatethe connections between classical computational complexity theory and the local complexityone. The bound on the (centralized) running time in each round (given by the function f , see Section 2) may serve a bridge for connecting the two theories, by putting constrainson this bound (i.e., f must be polynomial, exponential, etc). Also, one could restrict thememory used by a node, in addition to, or instead of, bounding the sequential time. Finally,it would be interesting to come up with a complexity framework taking also congestion intoaccount. 23 eferences [1] N. Alon, L. Babai, and A. Itai. A fast and simple randomized parallel algorithm for themaximal independent set problem. J. Algorithms , 7(4):567–583, 1986.[2] Y. Afek, S. Kutten, and M. Yung. The local detection paradigm and its applications to selfstabilization.
Theoretical Computer Science , 186(1-2):199–230, 1997.[3] B. Awerbuch, B. Patt-Shamir, and G. Varghese. Self-Stabilization By Local Checkingand Correction.
Proc. IEEE Symp. on the Foundations of Computer Science (FOCS) , 1991,268-277.[4] B. Awerbuch, B. Patt-Shamir, G. Varghese, and S. Dolev. Self-Stabilization by LocalChecking and Global Reset.
Proc. Workshop on Distributed Algorithms , LNCS 857, Springer,1994, 326-339.[5] L. Barenboim and M. Elkin. Distributed (∆ + 1)-coloring in linear (in delta) time.
Proc. 41stACM Symp. on Theory of computing (STOC) , 111–120, 2009.[6] T. D. Chandra and S. Toueg. Unreliable Failure Detectors for Reliable Distributed Systems.
J. ACM , 43(2):225-267, 1996.[7] T. D. Chandra, V. Hadzilacos and S. Toueg. The Weakest Failure Detector for Solving Con-sensus.
J. ACM , 43(4):685-722, 1996.[8] A. Das Sarma, S. Holzer, L. Kor, A. Korman, D. Nanongkai, G. Pandurangan, D. Peleg and R.Wattenhofer. Distributed Verification and Hardness of Distributed Approximation. Submitted.[9] B. Derbel, C. Gavoille, D. Peleg and L. Viennot. Local computation of nearly additive spanners.
Proc. 23rd Symp. on Distributed Computing (DISC) , 176–190, (2009).[10] E.W. Dijkstra. Self-stabilization in spite of distributed control.
Comm. ACM , 17(11), 643–644,1974.[11] S. Dolev, M. Gouda, and M. Schneider. Requirements for silent stabilization.
Acta Infor-matica , 36(6), 447-462, 1999.[12] M. Elkin. A faster distributed protocol for constructing a minimum spanning tree.
J. Comput.Syst. Sci. ǫ, β )-spanners in the dis-tributed and streaming models.
Distrib.Comput. , 18(5), 375–385 (2006).[14] M. J. Fischer, N. A. Lynch and M. Paterson. Impossibility of Distributed Consensus with OneFaulty Process.
J. ACM , 32(2): 374–382, 1985.15] P. Fraigniaud, C. Gavoille, D. Ilcinkas and A. Pelc. Distributed Computing with Advice:Information Sensitivity of Graph Coloring.
Proc. 34th Colloq. on Automata, Languages andProgramming (ICALP) , 231-242, 2007.[16] P. Fraigniaud, A Korman, and E. Lebhar. Local MST computation with short advice.
Proc.19th ACM Symp. on Parallelism in Algorithms and Architectures (SPAA) , 154–160, 2007.[17] P. Fraigniaud, S. Rajsbaum, and C. Travers. Wait-free checkable tasks. Submitted.[18] M. Herlihy. Wait-Free Synchronization.
ACM Trans. Programming Languages and Systems ,13(1):124–149, 1991.[19] M. Hanckowiak, M. Karonski, and A. Panconesi. On the Distributed Complexity of ComputingMaximal Matchings.
SIAM J. Discrete Math.
DistributedComputing , 20:253–266, 2007.[22] A. Korman, S. Kutten, and D Peleg. Proof labeling schemes.
Distributed Computing , 22:215–233, 2010.[23] F. Kuhn. Weak graph colorings: distributed algorithms and applications. proc. 21st ACMSymp. on Parallel Algorithms and Architectures (SPAA) , 138–144, 2009.[24] F. Kuhn, T. Moscibroda, R. Wattenhofer. What cannot be computed locally!
Proc. ACMSymp. on Principles of Distributed Computing (PODC) , 2004, 300-309.[25] S. Kutten and D. Peleg. Fast distributed construction of small k-dominating sets and appli-cations.
J. Algorithms , 28(1):40–66, 1998.[26] F. Kuhn, and R. Wattenhofer. On the complexity of distributed graph coloring.
Proc. 25thACM Symp. on Principles of Distributed Computing (PODC) , 7–15, 2006.[27] C. Lenzen, Y. A. Oswald and R. Wattenhofer. What can be approximated locally?: case study:dominating sets in planar graphs. In
Proc. 20th Ann. ACM Symp. on Parallelism in Alg. andArchitectures (SPAA) , 46-54, 2008.[28] N. Linial. Locality in distributed graph algorithms.
SIAM J. Comput. , 21(1):193–201, 1992.[29] A. Amit, N. Linial, J. Matousek, and E. Rozenman. Random lifts of graphs. In
Proc. 12thACM-SIAM Symp. on Discrete Algorithms (SODA) , 883–894, 2001.[30] M. Luby. A simple parallel algorithm for the maximal independent set problem.
SIAM J.Comput. , 15:1036–1053, 1986.31] Z. Lotker, B. Patt-Shamir and A. Rosen. Distributed Approximate Matching.
SIAM J.Comput.
Proc.20th Ann. ACM Symp. on Parallelism in Alg. and Architectures (SPAA) , pages 129–136, 2008.[33] M. Naor. A Lower Bound on Probabilistic Algorithms for Distributive Ring Coloring.
SIAMJ. Discrete Math , 4(3): 409-412 (1991).[34] M. Naor and L. Stockmeyer. What can be computed locally?
SIAM J. Comput.
J. Algorithms
Distributed Computing: A Locality-Sensitive Approach . SIAM, 2000.[37] D. Peleg and V. Rubinovich. A near-tight lower bound on the time complexity of distributedminimum-weight spanning tree construction.
SIAM J. Comput. , 30(5):1427–1442, 2000.[38] S. Pettie. Distributed algorithms for ultrasparse spanners and linear size skeletons.
DistributedComputing , 22(3): 147-166 (2010).[39] J. Schneider and R. Wattenhofer. A new technique for distributed symmetry breaking. In
Proc. 29th ACM Symp. on Principles of Distributed Computing (PODC) , 257-266, 2010.[40] D. Seinsche. On a property of the class of n -colorable graphs. J. Combinatorial Theory , Ser.B, 16, pages 191–193, 1974.[41] M. Wattenhofer and R. Wattenhofer. Distributed Weighted Matching.