An Automatic Speedup Theorem for Distributed Problems

02/26/2019 ∙ by Sebastian Brandt, et al. ∙ ETH Zurich 0

Recently, Brandt et al. [STOC'16] proved a lower bound for the distributed Lovász Local Lemma, which has been conjectured to be tight for sufficiently relaxed LLL criteria by Chang and Pettie [FOCS'17]. At the heart of their result lies a speedup technique that, for graphs of girth at least 2t+2, transforms any t-round algorithm for one specific LLL problem into a (t-1)-round algorithm for the same problem. We substantially improve on this technique by showing that such a speedup exists for any locally checkable problem Π, with the difference that the problem Π_1 the inferred (t-1)-round algorithm solves is not (necessarily) the same problem as Π. Our speedup is automatic in the sense that there is a fixed procedure that transforms a description for Π into a description for Π_1 and reversible in the sense that any (t-1)-round algorithm for Π_1 can be transformed into a t-round algorithm for Π. In particular, for any locally checkable problem Π with exact deterministic time complexity T(n, Δ) ≤ t on graphs with n nodes, maximum node degree Δ, and girth at least 2t+2, there is a sequence of problems Π_1, Π_2, ... with time complexities T(n, Δ)-1, T(n, Δ)-2, ..., that can be inferred from Π. As a first application of our generalized speedup, we solve a long-standing open problem of Naor and Stockmeyer [STOC'93]: we show that weak 2-coloring in odd-degree graphs cannot be solved in o(^* Δ) rounds, thereby providing a matching lower bound to their upper bound.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In this work, we study the question of determining the time complexity of distributed graph problems from the perspective of round elimination. More concretely, we ask: Given a problem , can we find another problem which can be solved in exactly one round less? Is it perhaps even possible to infer such a problem from in an automated fashion, so that we can obtain a sequence of problems with decreasing complexities until we end up with a problem that can be solved in rounds? We will show that, given certain (reasonable) conditions, the answer to both questions is yes. As a concrete evidence of the power of this automatic speedup, we resolve the complexity of odd-degree weak -coloring, an open question asked by Naor and Stockmeyer in 1993 [24].

Model

Our distributed model of computation is a variant of the well-known model [22, 25], a synchronous message passing model where the nodes of a given input graph are processors that have the task to collaboratively solve some graph problem on . The essential difference between our model and the model is that in our case nodes are not equipped with unique identifiers, but (potentially) have some other symmetry breaking information available. The class of problems we consider are locally checkable problems, i.e., problems where the global validity of a solution can be checked locally by the nodes in constant time. More precisely, for some constant , each node has a set of acceptable output configurations for its radius- neighborhood, and a global solution is considered valid if and only if the output configuration of each node’s radius- neighborhood is acceptable. Our speedup results are about the deterministic time complexity of locally checkable problems; however, there exist known techniques to lift the obtained bounds to both the randomized and the deterministic model. We will elaborate on these techniques in Section 2.2.

1.1 Our Contributions

Our main contributions are twofold: 1) We present a speedup theorem that generalizes the speedup technique of Brandt et al. [9]: In that work, the authors obtain a lower bound for the distributed Lovász Local Lemma by developing a round elimination technique for a problem called sinkless orientation. We show that such a speedup exists for arbitrary locally checkable problems. In particular, we provide a method that takes the description of a problem as input and outputs the description of a problem that can be solved one round faster but not any faster than that. This facilitates exciting new approaches for obtaining time complexity lower (and upper) bounds. 2) We show that our speedup technique is a powerful tool by using it to prove a tight lower bound for weak -coloring in odd-degree graphs, answering the long-standing open question by Naor and Stockmeyer.

Speedup Results

We provide an automatic procedure that transforms any given locally checkable problem into a (locally checkable) problem such that, informally speaking, the following holds.

Theorem 1 (informal).

Let be a locally checkable problem and the problem obtained by applying our speedup transformation. On graphs of girth at least , the following two statements are equivalent:

  • There is an algorithm solving in time .

  • There is an algorithm solving in time .

If has an exact deterministic time complexity on graphs with nodes, maximum node degree , and girth at least , then applying this speedup iteratively yields a sequence of problems with time complexities . Now determining the time complexity of just a single in the sequence will automatically determine the time complexities of all other , and, most importantly, of our initial problem . We will give a detailed explanation how to apply this technique to infer bounds for the complexity of a problem in Section 2.1, but let us first consider a concrete application. We remark that, apart from the following application, our speedup theorem also semi-automatically reproduces previously known techniques, such as the sinkless orientation speedup [9] and color reduction on rings (leading to the upper bound for -coloring a ring [14, 18]), as we will see in Sections 4.4 and 4.5. Moreover, building on our speedup technique, Balliu et al. [2] very recently proved new lower bounds for maximal matching and maximal independent set, in both the deterministic and the randomized setting.

Odd-Degree Weak -Coloring

Weak -coloring is the problem of coloring the nodes of a given input graph with colors such that each node (of degree at least ) has at least one neighbor with a different color. In their seminal work [24], Naor and Stockmeyer proved that in graphs where each node has odd degree, a weak -coloring can be found in time . As one of their three open questions they asked whether this bound can be improved. While the question seemed simple enough, surprisingly no progress has been made over the past 25 years, indicating that the available lower bound techniques might not be sufficient for showing that the upper bound is tight. Using our speedup results, we close this gap by showing the following theorem.

Theorem 4.

There is no -time algorithm solving weak -coloring in odd-degree graphs.

Given the speedup framework, the main technical ingredient in our proof is a generalization of weak -coloring to a problem we call superweak -coloring that has the following two nice properties:

  1. If we set to be superweak -coloring, then the problem obtained by applying our speedup is at least as hard as superweak -coloring, for some .

  2. Relaxing to superweak -coloring (and then continuing to apply the speedup technique) is sufficiently tight, in the sense that we essentially still need speedup steps until we obtain a -round solvable problem.

More concretely, a rough proof outline goes as follows. Relax weak -coloring to superweak -coloring, apply our speedup, relax the obtained problem to superweak -coloring for some , apply our speedup, relax to superweak -coloring for some , etc. Then, show that any problem obtained after steps of speedup and relaxation is still not solvable in rounds. Our speedup results then immediately imply that there is no -algorithm for weak -coloring.

1.2 Related Work

Follow-up Work

In a recent breakthrough, Balliu et al. [2] used our speedup technique to show that, both for maximal matching and maximal independent set, there is no randomized algorithm with runtime and no deterministic algorithm with runtime . As documented in [2, Section 3.7], apart from the speedup provided by Theorem 1, the authors also apply both of our simplification techniques (see Section 2.1) to achieve their lower bounds.

Further Related Work

The first occurrence of the round elimination speedup technique we extend to any locally checkable problem was seen in [9], where the authors show that such a speedup works for the problem of (-regular) sinkless orientation, resulting in a randomized lower bound of that also applies to the (constructive symmetric) distributed Lovász Local Lemma (LLL) and -coloring. In [12], Chang et al. proved that this result can be extended to a deterministic lower bound of , which is tight (for sinkless orientation) due to a matching upper bound by Ghaffari and Su [17], who also gave a matching upper bound for the deterministic case. Chang and Pettie [13] conjectured that the (randomized) lower bound for the distributed LLL is tight for sufficiently relaxed LLL criteria; despite a recent improvement of the upper bound by Ghaffari et al. [16], this conjecture is still open. In [11], Chang et al. simplified the randomized speedup technique of [9] and showed that the sinkless orientation lower bounds also imply an deterministic and an randomized lower bound for -edge coloring.

Weak -coloring on odd-degree graphs was introduced by Naor and Stockmeyer [24] as an example of a non-trivial problem that can be solved in constant time on graphs of bounded degree. As they show, the odd-degree condition is a necessary requirement; there are graph classes where nodes are allowed to have even degrees for which no constant-time weak coloring algorithm exists. Very recently, Balliu et al. [5] refined our knowledge in this regard by proving a tight lower bound of for weak -coloring on regular trees. While, from a theory perspective, weak coloring is interesting as “a problem with minimal symmetry breaking requirements” [20, p.139], a more concrete application exists in the form of certain resource allocation problems [24]. Naor and Stockmeyer provided an -algorithm for odd-degree weak -coloring, which was subsequently simplified and adapted to the dynamic setting by Mayer et al. [23]. While progress has been made for other relaxations of the standard node coloring problem, such as defective [20, 6] or arbdefective [7] coloring, the question by Naor and Stockmeyer whether their bound can be improved has remained open until now.

Naor and Stockmeyer’s work also initiated, together with [22], the line of research on local algorithms, and introduced the concept of locally checkable labeling (LCL) problems. This class of problems has been subject to many investigations, resulting in an almost complete understanding of the respective complexity landscape very recently [3, 4, 9, 10, 12, 13, 15, 16]. We remark that, while our speedup applies to LCL problems, it is not restricted to them: in particular, we do not require the considered graphs to be of constant degree.

2 Technical Overview

In this section, we will outline how to apply the speedup technique to obtain new bounds, including further helpful techniques for the application of the speedup. Moreover, we will give an overview of the available techniques to extend bounds achieved from our speedup (in our model) to the LOCAL model and to randomized complexities.

2.1 How to Apply the Speedup Results

The most natural application of our speedup technique is to prove a lower bound for some given problem . The roadmap is as follows. Starting with , we apply our speedup theorem iteratively, resulting in a problem sequence , where each problem can be solved exactly one round faster than the previous one. Given the mentioned conditions, our speedup works until we reach a problem that can be solved in rounds; hence, in theory, the only thing we have to do is to look at our sequence and to determine which is the first problem in this sequence that is solvable in rounds (usually depending on our parameters and/or ). If is the first problem solvable in rounds, the problem we are interested in has time complexity . However, since Theorem 1 requires girth at least , only the lower bound of holds for general graphs.

While -round solvable problems have a simple characterization, there is a catch: in general, the description of an inferred problem is much more complex than the description of the original problem. In fact, dealing with this explosion in complexity is one of the main challenges in applying our speedup. To this end, we provide two simplification techniques.

Relaxation

After inferring a new problem from via the speedup, we can try to find a relaxed version of (i.e., a problem that is provably not harder than ) that has a much simpler description, and use this problem as the starting point for the next speedup step. Alternating between relaxation and speedup, we continue this process until we reach a problem that is solvable in rounds. Then is a lower bound for the time complexity of our initial problem . Of course, we can also stop before we reach a -round solvable problem, and the respective index of the problem is also a lower bound.

If, informally speaking, we relax the problems obtained after each speedup step too much, the lower bound we obtain in the end might be asymptotically worse than the correct (tight) bound, or no improvement on existing bounds at all, so finding the right relaxation is a challenging problem. Moreover, in order to avoid having to find “good” relaxations for many very different problems, it is desirable to find relaxed problems that are similar (perhaps with different parameters of some kind) to previous problems in the problem sequence. The above outline captures exactly what we do in our lower bound for weak -coloring.

We remark that a dual version of the relaxation technique exists, where we obtain upper bounds on high-girth graphs by making problems harder instead of relaxing them. We will see a concrete example for this dual technique when we consider color reduction on rings as a special case of our speedup in Section 4.5.

Description Simplification

As the second tool in our toolbox for managing the increasing description complexity, we provide a “maximality constraint” that can be applied twice per speedup step in order to decrease the set of allowed outputs and thereby simplify the problem. Despite its simplicity, this technique can significantly reduce the description complexity of a problem, as we will see in Section 4.6. As we show in Theorem 2, this simplification comes at no cost, keeping the complexity of the problem under consideration as it is.

2.2 How to Lift Bounds to the Model.

A requirement for our speedup result is that the class of input graphs satisfies a property that we call -independence. Informally, a graph class is -independent if the following holds: If any node111If we want to be a bit more precise, the same also has to hold for any edge, where for simplicity, we also consider edges as computational entities. that has gathered all information in its radius- neighborhood extends its view by one hop along some edge, then the new information obtains does not affect what information might see if it extends its view by one hop along any other edge. In particular, if the nodes are equipped with globally unique identifiers, then -independence does not hold: if a node sees some ID in the extended view along some edge, it knows that this ID cannot be in any of the extended views along the other edges, due to our girth condition. While almost every other kind of symmetry breaking information commonly used, such as node colorings, edge colorings, edge orientations, or combinations thereof, satisfy -independence, extending bounds obtained by our speedup technique to the setting with unique IDs, i.e., the model, requires additional techniques. Note that upper bounds obtained by our technique immediately apply to the model (as basically every other symmetry breaking information can be inferred from unique IDs), hence we will focus on lower bounds in the following.

Method I: Randomization

As demonstrated in [2, 9]

, by explicitly incorporating error probabilities into the speedup steps, lower bounds in our setting can be lifted to the randomized

model (which essentially guarantees -independence since no unique IDs are required). The obtained bounds are weaker than the original bounds from our setting, which is to be expected considering that allowing randomization can only lower the complexity of a problem. In a second step, the randomized bounds can then be lifted to the (deterministic) model, by exploiting gaps in the complexity landscape of so-called LCL problems [12], or by explicitly showing that the existence of a deterministic algorithm of some complexity would imply the existence of a randomized algorithm that violates the randomized lower bound [2]. The available evidence [2, 12] suggests that this detour via the randomized complexity does not weaken the deterministic bound: in both cases, the bound in our setting is identical to the bound in the model. This is not too surprising since the uniqueness of IDs might simply not be enough to change the complexity of a problem (as compared to, say, a setting with non-unique IDs); however, a proof for this is not known and would be a valuable step forward.

Method II: Order-Invariant Algorithms

A second technique to lift bounds to the model comes into play when we are interested in time complexities as a function of the maximum node degree of the input graph. By a result of Naor and Stockmeyer [24], if there is a constant-time algorithm solving a locally checkable problem in the model, then there is also an order-invariant algorithm with the same runtime, where order-invariant indicates that any node only uses the relative IDs, i.e., the order of the IDs it sees, but not the actual ID values, in order to determine its output. Hence, if there is an algorithm solving a locally checkable problem with runtime independent of , then we can essentially restrict attention to order-invariant algorithms. We provide an extension of our speedup result (Theorem 3) that shows that for order-invariant algorithms our speedup holds also in the case of unique IDs, i.e., in the model. We will make use of this extension when we prove our lower bound for weak -coloring (in the model).

3 Preliminaries

Graphs

All graphs we consider throughout the paper will be simple, undirected and connected. We denote the set of nodes of a graph by and the set of edges by , and we set . Furthermore, we write for the degree of a node and denote the maximum node degree of a graph by . A (-)regular graph is a graph where for all . The girth of a graph is the length of the smallest cycle. A matching is a set such that no two distinct edges from share an endpoint.

An important component in designing and proving our speedup is the idea to split the output of a node into parts that belong to incident edges. As the basis for a convenient representation of such a split output, define as the set of all pairs where and is an endpoint of . Finally, for a graph class , we denote the subclass of consisting of the contained graphs with nodes and maximum degree by , for all non-negative integers . Similarly, the subclass of graphs with maximum degree is denoted by .

Input-Labeled Graphs

Commonly, locally checkable problems are defined by allowed configurations of output labels and a specification of the given inputs and the considered graph class. Definitionwise, we will strictly separate between the outputs on one side (which will define what we call a problem) and the inputs222Note that in this work, we focus on the common case of problems where the correctness of the output does not depend on the given inputs. Adapting the speedup results to the case where output correctness depends on the inputs is not hard, but carries a significant technical overhead which would needlessly impair readability. and the graph class on the other side (which will be given by input-labeled graphs). This enables us to give a very general definition of the setting in which our results are applicable; more importantly though, this separation caters to the fact that the sequence of problems we obtain by repeatedly speeding up a given problem is independent of the considered inputs and the considered graph class.

For the definition of input-labeled graphs, we will also use the set defined above, which allows for a convenient way to encode, e.g., edge orientations. Furthermore, we will not restrict attention to graphs with bounded degree or to bounded input label sets; instead we will use the following more complicated, but also more general definition, which allows, e.g., to define graph classes of unbounded degree with an input edge coloring (which requires labels), or unique IDs (which come from a set that is a function of ).

Let be a (possibly infinite) set of input labels and a function such that is a finite subset333Note that, throughout the paper, we use the expression for the power set of set , as opposed to the set of functions from to . of , for all . A -input-labeled graph is a pair , where is a graph and is a function , where and are the number of nodes and the maximum degree of , respectively. For simplicity, we will usually omit the function and simply denote the -input-labeled graph by . We extend the notion of being -input-labeled to graph classes and say that a graph class is -input-labeled if each graph in is -input-labeled. Throughout the paper, all considered graph classes are assumed to be input-labeled, if not stated otherwise. Furthermore, if we want to avoid that nodes have to be able to compute uncomputable functions during the distributed computation, we can require additionally that the function that maps each pair to the graph class (as well as any other function involved in specifying parts of a distributed problem) is computable.

Problems

The speedup results we present apply to all locally checkable problems; however, formally, we will only consider problems where the validity of a global output essentially444Due to our particular way of splitting the output of a node into partial outputs for each incident edge, our formal definition of a problem will contain acceptable configurations for both edges and nodes; a more precise term for edge-checkability would thus be node-and-edge-checkability. can be checked on edges, i.e., there is a set of acceptable output configurations for the two endpoints of an edge, and the global output is correct if and only if the configuration for each edge is acceptable. Restriction to these problems does not lose generality for our purposes: by requiring that each node outputs the computed output labels (and the topology555Note that in general graphs where nodes do not have unique identifiers, the information a node obtains in rounds may not be enough to determine the exact topology of the subgraph induced by all nodes in distance at most ; however, since we will only consider radius- neighborhoods in graphs that have girth at least , the subgraph topology in each radius- neighborhood is a tree which implies that each node can determine the exact topology of its radius- neighborhood.) of its whole radius- neighborhood for some suitably large constant , any locally checkable problem can be transformed into an edge-checkable4 problem with the same asymptotic time complexity. For the definition of (our restricted version of) a problem, we will need the notion of a multiset, which is simply a set in which elements can have multiplicity larger than , but where, as usual, the order of elements does not matter.

Formally, for the scope of this paper, a problem is defined by

  1. a (possibly infinite) set of output labels,

  2. a function such that is a finite subset of , for all ,

  3. a function that maps each to a set of -element multisets where both elements are taken from , and

  4. a function that maps each to a set of multisets with at most elements, all taken from .

The specification of ensures that problems that require the set of output labels to depend666Similarly to the case of unique IDs as input labels, one could also allow for problems where the set of output labels depends on . However, we are not aware of commonly studied problems of this kind, which is why we chose the simpler definition that only allows a dependence on . on , such as -coloring, are included in our problem definition. The sets and formalize which output configurations are allowed on an edge (i.e., at and ), resp. at a node (i.e., at , where are the edges incident to ). For instance, the problem of -coloring can be described by setting , , , .

Combining problems and input-labeled graphs, we define a realized problem as a pair , where is a problem and a -input-labeled graph class. For convenience, we may simply use the term “problem” for . We say that an algorithm solves a realized problem (or, equivalently, that solves on ) if, for any and any graph , assigns an output to each pair such that, for each edge , the multiset is contained in , and for each node , the multiset is contained in .

Model

Since we defined inputs to be part of the considered graph class (and hence assigned the duty of providing sufficient symmetry-breaking information to the choice of the graph class), we can use a very weak model of computation. This has the advantage that essentially all problems that are defined in a stronger model, such as the model, can also be formulated in our model. The only requirement that we need is that nodes are able to distinguish between their neighbors (or incident edges), which is why we formally choose the port numbering model [1] as our model of computation.

In the port numbering model, each node of the input graph has many ports which correspond to the edges incident to ; the two endpoints of an edge may have different ports corresponding to the connecting edge. Each node can communicate with its neighbors by sending messages along the connecting edges. Computation proceeds in synchronous rounds where in each round each node first sends arbitrarily large messages to its neighbors and then, upon receiving the messages sent by its neighbors, performs some arbitrarily complex local computation. Each node executes the same algorithm and has to terminate at some point, upon which it outputs its local part of the global solution (e.g., if the task is to find a proper node coloring, each node outputs its own color). The runtime of such a distributed algorithm is the number of rounds until the last node terminates. In the beginning of the computation, each node is aware of the parameters and and sees the input label assigned to for all incident edges , i.e., one input label per port. When terminating, a node assigns an output label from to each . We are interested in the worst-case runtime of a distributed algorithm, i.e., for worst-case input-labeled graphs with worst-case assignments of port numbers to edges.

A distributed algorithm is correct if the output labels assigned to the elements in satisfy the constraints encoded in and at each edge, resp. node. More precisely, we say that a distributed algorithm solves a realized problem if the above is true for each graph (where are defined by ). In this work, we formally only consider deterministic algorithms; the implications for randomized algorithms have been discussed in Section 2.2.

It is well-known that the best a node can do in rounds of communication is to gather the whole input information contained in its radius- neighborhood (as well as the topology5), and then decide on its output using only the collected information. Hence, a -round algorithm can be equivalently described as a function that maps each possible radius- neighborhood of a node to a tuple of output labels (one for each port of , i.e., each ). Note that in this description the degree of is only fixed when a radius- neighborhood has been chosen.

Neighborhoods

Let be a -input-labeled graph. For any node and any non-negative integer , we define the radius- neighborhood of (in ) as the collection of information that can obtain in rounds, i.e., the topology of the subgraph of induced by the set of all nodes in distance at most from , together with the input information each of these nodes possesses at the very beginning.5 Similarly, for any edge , we define the radius- neighborhood of (in ) as the collection of information that both and can obtain in rounds, i.e., the topology of the subgraph of induced by the set of all nodes in distance at most from both and , together with the respective input information. For convenience, we may occasionally forget about assigned labels or edges and consider or as unlabeled graphs or sets of nodes. We write and if we want to specify the underlying graph . We say that the radius- neighborhood of a node in graph and the radius- neighborhood of a node in graph are isomorphic and write if the collection of information can obtain in rounds in is the same as the collection of information can obtain in rounds in . We define isomorphisms for radius- edge neighborhoods analogously.

For simplicity, we will abuse notation, and use set operations to describe further collections of information, in the canonical way. For instance, we write . In particular, we are interested in “extensions” of such information collections, e.g., the information a node can obtain in rounds that a neighbor cannot obtain in rounds, or the information two neighboring nodes and can both obtain in rounds that cannot obtain in rounds. Hence, for any node , any edge , and any positive integer , we define and . Again, we write and to specify the underlying graph.

Consider some radius- neighborhood of an edge , and let be a graph class containing . We say that has an extension in (along ) if there is a graph such that , where is some node of . For convenience, we will identify and (and other nodes and edges in isomorphic neighborhoods), allowing us, e.g., to specify the output label of in graph . Analogously, we say that has an extension in (along ) if there is a graph such that , where is some edge of , and we will identify nodes (and edges) similarly as above.

-Independence

As mentioned in Section 2.2, our speedup results require a property called -independence. This property essentially only exists in graph classes with sufficiently high girth which is the reason (together with the difficulty of determining neighborhood topologies if the girth is too small) why we restrict attention to these classes of graphs. Roughly speaking, -independence is satisfied if for any fixed radius- neighborhood of a node , the set of extensions along one incident edge is independent of the sets of extensions along the other incident edges (i.e., fixing an extension along one edge does not influence which extensions are possible along the other edges), and if a similar statment holds for edge neighborhoods. See Figure 1 for an illustration.

Figure 1: One of the two requirements for -independence is that, for any node , the sets of extensions of along the different incident edges are independent of each other. In other words, for the depicted node of degree , if we fix one of the possibilities for the topology and the input labels in the blue area, then this does not change which topologies and input label combinations are possible in the orange and the black area, and vice versa.

Formally, we define -independence as follows.

Let be a -input-labeled graph class consisting of graphs with nodes and maximum degree and let be a positive integer. We say that is -independent if for any graph , any node , and any edge , the following two properties are satisfied:

  1. Set , and define analogously. Then, for each element and each element , there is a graph and an edge such that , , and , where, under the given isomorphism, corresponds to , and to .

  2. For each edge incident to , set . Then, for each indexed family with , there is a graph and a node such that and, for all incident to v, , where, under the given isomorphism, corresponds to .

While this exact definition of -independence is cumbersome, the intuition behind it makes it straightforward to check that -independence is satisfied for the usual symmetry breaking inputs that do not include unique IDs, such as node colorings, edge colorings777We assume all symmetry breaking inputs to be given in the natural way, i.e., input for a node to be encoded at all , and input for an edge to be encoded at all . In particular, in a -round algorithm each node is aware of the colors and orientations of all incident edges (otherwise -independence might not be satisfied)., edge orientations, or combinations thereof (in common graph classes with graphs of girth at least ).

If is -independent for each , then we say that is -independent. If is a graph class such that, for each non-negative , is -independent (resp. -independent), then we say that is -independent (resp. -independent). Note that if is empty, it is trivially -independent for any positive .

4 The Speedup Theorem

In this section, we will present our speedup results and apply them to several problems. We start by defining our automatic speedup that produces a sequence of problems with decreasing runtimes, and subsequently prove our main theorem (Section 4.1). In Section 4.2, we introduce an important simplification technique that reduces the complexity of the descriptions of the problems in our sequence (by transforming the problems) and show that this technique is compatible with the main theorem. Then we prove that the main theorem can be extended to settings with unique IDs if we restrict attention to order-invariant algorithms (Section 4.3). In Sections 4.4 and 4.5, we will see how to obtain two known results by applying our speedup, confirming the viability and generality of the speedup technique. Finally, in Section 4.6, we will examine the effect of our speedup on weak -coloring, giving some intuition for the generalization of weak -coloring that is essential for our lower bound proof in Section 5.

4.1 The Theorem

In the following, we describe how to transform a given problem into a problem that can be solved one round faster. Our speedup consists of two steps: First we transform into a problem that, in some sense, can be solved half a round faster, then we transform into . Recall that a -round distributed algorithm (for ) is nothing else than a function that maps each possible radius- neighborhood to a tuple of outputs for . By saying that can be solved half a round faster, we mean that there is a distributed algorithm for where each node looks only at a neighborhood that is smaller than its radius- neighborhood , but larger than its radius- neighborhood . More precisely for deciding on the output at , node looks only at the radius- neighborhood of . An alternative way to look at this is to consider the edges of the input graph as the computing entities in an algorithm for ; each edge then decides on the outputs at and . This highlights the inherent duality of the two steps in our speedup: both steps are essentially the same with the difference that the role of nodes and edges is swapped.

Deriving Problems

Let be a problem, and let be the set of output labels and the functions used to define . We define the problem by specifying the set of output labels and the three required functions , , and as follows.

We set and , and we define as the set of all multisets , where , with the following property:

  1. For any , , the multiset is contained in .

We define as the set of all multisets , where and , with the following property:

  1. [resume]

  2. There exist elements such that the multiset is contained in .

Since is finite for all , also is finite. Hence, indeed satisfies the definition of a problem. Similarly to how we derived from , we will now derive from . More precisely, is defined as follows.

We set and , and we define as the set of all multisets , where , with the following property:

  1. [resume]

  2. There exist elements such that the multiset is contained in .

We define as the set of all multisets , where and , with the following property:

  1. [resume]

  2. For any , the multiset is contained in .

With the same reasoning as for , we see that satisfies the definition of a problem. For an illustration of the definitions, we refer to the concrete examples in Sections 4.44.6. In the same way as we derived and from , we can derive problems and from . In general, set , and for any positive integer , define recursively and .

The intuition behind the definition of (and the proof of Theorem 1) is that the restrictions for and given in Properties 1 and 1 are just weak enough that an algorithm that looks only at radius- edge neighborhoods can infer correct outputs by simulating an algorithm for on the radius- neighborhoods obtained by extending the radius- edge neighborhoods (with all possible extensions). The tightness of the two properties makes it possible that, conversely, we can also infer a (half-round slower) algorithm for from an algorithm for . A dual version of the above arguments holds for the relation between and . In the following, we show how to derive the algorithms for and mentioned above from an algorithm for in a black box manner (the converse direction will be part of the proof of Theorem 1).

Algorithm Speedup

Let be an arbitrary algorithm that solves some problem on some graph class . Let be the worst-case runtime of on the graph class . We define an algorithm for as follows.

Consider an arbitrary graph , and let denote the number of nodes of , and the maximum degree. In the following, we describe how an arbitrary node executing decides on the output label it will assign to , where is some arbitrary edge incident to . Node starts executing Algorithm by collecting the radius- neighborhood of edge . Note that has access to and and therefore can determine . Then, for each output label , node determines whether has an extension in such that would assign output to according to . Let be the set of all for which such an extension exists. In other words, simulates on each radius- node neighborhood occurring in that can be obtained by extending in direction of (seen from ), and collects in all output labels that outputs in each such neighborhood at the node-edge pair corresponding to . Finally, node outputs at . This concludes the description of . We will argue about the correctness and the runtime of (and ) in the proof of Theorem 1.

Analogously, we define an algorithm as follows, by deriving it from . Again, we focus on the output assigns to according to , where . Similarly to before, starts executing Algorithm by collecting the radius- neighborhood of . Then, for each output label , node determines whether has an extension in such that would assign output to according to . Finally, collects all for which such an extension exists in a set , and outputs at . Now we are set to prove our main speedup result.

Theorem 1.

Consider some arbitrary problem and the derived problem . Let be a -input-labeled graph class consisting of -node graphs with maximum degree . Assume that is -independent for some positive integer and contains only graphs of girth at least . Then, the following two statements are equivalent:

  • There is an algorithm solving in time .

  • There is an algorithm solving in time .

Proof.

We first show that (1) implies (2). Let be an algorithm solving in time . Consider the algorithms and derived from in the manner described above. We argue that solves and that for deciding on the output assigned to some node-edge pair in the execution of , node only looks at . Furthermore, we argue that solves in time . The statement that only looks at directly follows from the definition of ; analogously, the runtime of follows from the description of . Hence, what is left to show is that the two derived algorithms actually solve the two derived realized problems. We start with and .

Let be an arbitrary graph in , and let be an arbitrary node, the edges incident to , and the other endpoint of . Furthermore, let denote the output assigns to , and let the output for other node-edge pairs be denoted analogously. We have to show that A) the multiset is contained in , and B) the multiset is contained in .

For A), observe that, by the definition of , for any two output labels and , has both an extension in such that would output at and an extension in such that would output at . Due to the -independence of , there is a graph such that the radius- neighborhood of some node is isomorphic to , which implies that, in , would output at and at . Since solves , it follows that the multiset is contained in . We conclude that for any , the multiset is contained in , which shows that the multiset is contained in , by Property 1 in the definition of .

For B), consider , and let be the outputs would assign to , respectively, when executing . Observe that, for any , has an extension in such that would output at , namely . Hence, by the definition of , we have . Since the multiset is contained in (due to solving ), it follows that the multiset is contained in , by Property 1 in the definition of . This concludes the proof showing that solves .

The proof for showing that solves is analogous. Note that this proof does not rely in any way on the fact that and are derived from another problem, resp. algorithm. The proof works just as well if we replace by any other problem and by any other algorithm that solves the problem on and has the property that each node decides on the output for by only looking at .

Now, we show that (2) implies (1). Let be an algorithm solving in time . We derive an algorithm as follows. For each graph and each edge , let and be the outputs assigns to and , respectively, when executed (by ) on . Since solves , there exist elements such that the multiset is contained in , by Property 1 in the definition of . We define algorithm to output at and at , when executed on ; thereby trivially satisfies one of the two conditions for solving (the one concerning ). By Property 1 in the definition of (and the fact that solves on ), algorithm also satisfies the other condition, concerning . Hence solves . Observe that due to the design of , each node can determine the output at according to by looking only at .

Now, using an analogous argumentation, we can define an algorithm that solves , where each node can determine the output at by looking only at . Hence, there is an algorithm solving in time . ∎

Theorem 1 provides an explicit version of our speedup guarantees for graph classes . We formulate the implications for general graph classes in the following corollary of Theorem 1.

Corollary 1.

Consider some arbitrary problem , and let be a -input-labeled graph class and some function. If, for all , it holds that is -independent and contains only graphs of girth at least , then the following two statements are equivalent:

  • There is an algorithm solving in time .

  • There is an algorithm solving in time .

Note that Theorem 1 and Corollary 1 do not contradict the existence of known gaps [12, 13, 24] in the time complexity landscape of LCL problems since the problem obtained after applying our speedup a non-constant number of times is not necessarily an LCL problem anymore (but is still locally checkable).

4.2 Simplification via Maximality

In this section, we will present a technique that simplifies the derived problems and without affecting the correctness of Theorem 1. Consider the (common) case that the input labeling of a considered graph class contains some symmetry breaking information for the two endpoints of each edge, i.e., any two nodes , connected by an edge can select the same of the two endpoints. We will consider the simplest case that the desired symmetry breaking can be achieved by both nodes by just looking at their -round input information, i.e., the respective input graph contains edge orientations (where the orientation of an edge is encoded in both input labels assigned to and ). Note that if, instead, the nodes have to look up to a distance of (or, more generally, some constant ), as, e.g., in the case of an input node coloring or input IDs, then the simplification technique we present still works for all cases except for the speedup of a -round (resp. any -round) algorithm to a -round (resp. one-round-faster) algorithm.

The idea behind the simplification technique is that we can reduce the number of output labels the derived algorithm for can use, by making the set smaller; as we will show this can be done in a way that ensures that the algorithm (or, more precisely, its adapted version) can still solve (the new version of) in the same runtime as before. More specifically, observing that the definition of contains an existential and a universal statement, we can replace each multiset in by some with if still satisfies the universal Property 1 in the description of ; the correctness of the existential Property 1 is not affected by this and shrinks. The symmetry breaking on edges mentioned above is a necessary ingredient for performing this process in a consistent manner (in the dual case for , we need analogously a symmetry breaking for nodes; however, this is already provided by the port numbers). As we will see in Sections 4.44.6, this approach can lead to a significant decrease in usable outputs. For a simplified problem, we may compress the problem description by assuming that the respective and contain only those outputs that can actually occur in a correct solution (i.e., that occur in both some multiset contained in and some multiset contained in ).

Simplified Problems

We obtain the simplified version of by replacing Property 1 in the description of by the following extension:

  1. [resume]

  2. For any , , the multiset is contained in and the sets and are maximal with this property, i.e., for any , the multiset does not satisfy Property 1, and for any , the multiset does not satisfy Property 1.

Analogously, we obtain the simplified version of by replacing Property 1 by the following extension:

  1. [resume]

  2. For any , the multiset is contained in and the sets are maximal with this property, i.e., for any , it holds that, for any , the multiset does not satisfy Property 1.

However, just performing the latter replacement as it is will result in a (simplified) problem that is derived from , not from . Hence, we define by not only performing the above replacement, but also replacing by in Property 1, where is the analogue to in (and actually the only part in which the definitions of and differ). Now, similarly to above we can define simplified problems recursively for any positive by setting and . Note that for simplicity, we write, e.g., instead of when talking about the simplified problem if it is clear which problem is considered.

In the following theorem, we show that Theorem 1 still holds if we replace a derived problem by its simplified version. Naturally, this implies that also an analogous version of Corollary 1 holds for our simplified problems. Moreover, from the proof of Theorem 2, it follows that we can arbitrarily decide after which performed problem derivation we apply the simplification technique and after which we do not, without affecting the runtime of the derived problem.

Theorem 2.

If we augment the conditions of Theorem 1 by the requirement that the inputs for the graphs from contain an orientation for each edge, then the following two statements are equivalent:

  • There is an algorithm solving in time .

  • There is an algorithm solving in time .

Proof.

Recall that, as observed in the proof of Theorem 1, the speedup of one round is actually obtained by two independent speedups, going from to and from to . In particular, the fact that is a derived problem is not relevant for the second speedup. Therefore (and due to the two speedups being analogous), it is enough to argue that if there is an algorithm solving by looking only at radius- edge neighborhoods, then there is also an algorithm solving by looking only at radius- edge neighborhoods, and vice versa. Going from to is easy: since is a more restrictive version of , any algorithm solving also solves , hence setting is sufficient.

For the other direction, given an algorithm as described above, we transform it into an algorithm as described above, as follows. Consider an arbitrary edge in some graph . From the orientation of , nodes and infer an ordering of the set in some fixed way (so, both and infer the same ordering, in rounds). Then, and compute the outputs and of at and