Hardness of Distributed Optimization

05/24/2019
by   Nir Bachrach, et al.
0

This paper studies lower bounds for fundamental optimization problems in the CONGEST model. We show that solving problems exactly in this model can be a hard task, by providing Ω̃(n^2) lower bounds for cornerstone problems, such as minimum dominating set (MDS), Hamiltonian path, Steiner tree and max-cut. These are almost tight, since all of these problems can be solved optimally in O(n^2) rounds. Moreover, we show that even in bounded-degree graphs and even in simple graphs with maximum degree 5 and logarithmic diameter, it holds that various tasks, such as finding a maximum independent set (MaxIS) or a minimum vertex cover, are still difficult, requiring a near-tight number of Ω̃(n) rounds. Furthermore, we show that in some cases even approximations are difficult, by providing an Ω̃(n^2) lower bound for a (7/8+ϵ)-approximation for MaxIS, and a nearly-linear lower bound for an O(n)-approximation for the k-MDS problem for any constant k ≥ 2, as well as for several variants of the Steiner tree problem. Our lower bounds are based on a rich variety of constructions that leverage novel observations, and reductions among problems that are specialized for the CONGEST model. However, for several additional approximation problems, as well as for exact computation of some central problems in P, such as maximum matching and max flow, we show that such constructions cannot be designed, by which we exemplify some limitations of this framework.

READ FULL TEXT VIEW PDF

Authors

01/07/2019

Smaller Cuts, Higher Lower Bounds

This paper proves strong lower bounds for distributed computing in the C...
03/16/2020

Beyond Alice and Bob: Improved Inapproximability for Maximum Independent Set in CONGEST

By far the most fruitful technique for showing lower bounds for the CONG...
06/06/2020

Distributed Approximation on Power Graphs

We investigate graph problems in the following setting: we are given a g...
07/05/2020

New Hardness Results for Planar Graph Problems in P and an Algorithm for Sparsest Cut

The Sparsest Cut is a fundamental optimization problem that has been ext...
02/14/2020

A Breezing Proof of the KMW Bound

In their seminal paper from 2004, Kuhn, Moscibroda, and Wattenhofer (KMW...
08/08/2019

Small Cuts and Connectivity Certificates: A Fault Tolerant Approach

We revisit classical connectivity problems in the CONGEST model of distr...
06/16/2018

Advice Complexity of Priority Algorithms

The priority model of "greedy-like" algorithms was introduced by Borodin...
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

Optimization problems are cornerstone problems in computer science, for which finding exact and approximate solutions is extensively studied in various computational settings. Since optimization problems are fundamental for a variety of computational tasks, mapping their trade-offs between time complexity and approximation ratio is a holy-grail, especially for those that are NP-hard.

Distributed settings share this necessity of resolving the complexity of exact and approximate solutions for optimization problems, and a rich landscape of complexities is constantly being explored. However, distributed settings exhibit very different behavior, compared with their sequential counterpart, in terms of what is efficient and what is hard. Here, we focus on the congest model in which vertices communicate synchronously over the underlying network graph, using an -bit bandwidth [43]. Since the local computation of vertices is not polynomially bounded, hardness results in the sequential setting do not translate to hardness results in the distributed one. In particular, any natural graph problem can be solved in the congest model in rounds, being the number of edges, by letting the vertices learn the whole graph. For some problems, such as MaxIS and finding the chromatic number [10], this naïve solution is known to be nearly-optimal, whereas for other problems more efficient solutions exist. On the other hand, there do exist problems with a polynomial sequential complexity, which require rounds in the congest model, such as deciding whether the graph contains a cycle of a certain length and weight [10].

In the sequential setting, finding an exact solution for some problems, such as minimum dominating set (MDS) or a maximum independent set (MaxIS), is known to be NP-hard [27]. In such cases, it is sometimes possible to obtain efficient approximations, such as an -approximation for MDS, where is the maximum degree in the graph [49]. However, in some cases, even obtaining an approximation is hard. For MDS, any approximation better than logarithmic is hard to obtain [38]. MaxIS does not admit even an approximation [23]. In the congest model, there are polylogarithmic -approximations for MDS [26, 34, 33], and it is also known that obtaining such an approximation requires at least a polylogarithmic time. More specifically, there are lower bounds of and [33]. However, currently nothing else is known with respect to better approximations or exact solutions. For the MaxIS problem, there are efficent and approximations for the unweighted and weighted cases, respectively [7]. However, the complexity of achieving any better approximations is not known. Solving it exactly requires rounds [10]. In the closely related local model, where the size of messages is not bounded, -approximations for both problems can be obtained in polylogarithmic time [20].

The curious aspect of the huge gaps that are present in our current understanding of various optimization and approximation complexities in the congest model is that we do not have any hardness conjectures to blame these gaps on. This raises the natural question: can we obtain better approximations efficiently in the congest model?

For problems in P, in many cornerstone cases, such as min cut, max flow and maximum matching, we have efficient -approximations [37, 19, 39], but the complexity of exact computation is still open. Many additional questions are open with respect to various optimization problems.

The contributions of this paper are three-fold, providing (i) novel techniques for nearly-tight lower bounds for exact optimizations, (ii) advanced approaches for nearly-tight lower bounds for approximations, and (iii) new methods for showing limitations of the main lower-bound framework.

1.1 Our contributions, the challenges, and our techniques

Lower bounds for exact computation.

We show that in many cases, solving problems exactly in the congest model is hard, by providing many new lower bounds for fundamental optimization problems, such as MDS, max-cut, Hamiltonian path, Steiner tree and minimum 2-edge-connected spanning subgraph (2-ECSS). Such results were previously known only for the minimum vertex cover (MVC), MaxIS and minimum chromatic number problems [10]. Our results are inspired by [10], but combine many new technical ingredients. In particular, one of the key components in our lower bounds are reductions between problems. After having a lower bound for MDS, a cleverly designed reduction allows us to build a new lower bound construction for Hamiltonian path. These constructions serve as a basis for our constructions for the Steiner tree and minimum 2-ECSS. We emphasize that we cannot use directly known reductions from the sequential setting, but rather we must create reductions that can be applied efficiently on lower bound constructions.

To demonstrate the challenge, we now give more details about the general framework. We use the well-known framework of reductions from 2-party communication complexity, as originated in [44] and used in many additional works, e.g., [47, 18, 17, 9, 1, 14]. In communication complexity, two players, Alice and Bob, receive private input strings and their goal is to solve some problem related to their inputs, for example, decide whether their inputs are disjoint, by communicating the minimum number of bits possible. To show a lower bound for the congest model, the high-level idea is to create a graph that satisfies some required property, for example have an MDS of a certain size, iff the input strings satisfy some property. If a fast algorithm in the congest exists, Alice and Bob can simulate it and solve the communication problem. Then, lower bounds from communication complexity translate to lower bounds in the congest model. The exact lower bound we can show depends on certain parameters such as the size of the graph, the size of the inputs and the size of the cut between the parts of the graph that the players simulate. An attempt to use the known reduction from MVC to MDS together with the lower bound for MVC from [10] faces a complication: This reduction requires adding a new vertex for each edge in the original graph, which blows up the size of the graph with respect to the inputs, and allows showing only a nearly-linear lower bound. For similar reasons, known reductions from MVC to Hamiltonian cycle and Steiner tree cannot show any super-linear lower bound. Nevertheless, we show that in some cases reductions can be a powerful tool in providing new bounds, but they need to be designed carefully in order to preserve certain parameters of the graph, such as the number of vertices and the size of the cut between the two players.

A succinct summary of our results in this section is the following.

  • We show an lower bound for solving MDS, weighted max-cut, Hamiltonian path and cycle, minimum Steiner tree, and unweighted 2-ECSS on general graphs. For unweighted max-cut, we show an algorithm for computing a -approximation for max-cut in general graphs, for all .

Lower bounds in bounded-degree graphs.

In many cases, the graph over which one needs to solve a certain problem is not a worst-case instance, but rather is drawn from a specific graph family that does allow efficient solutions. For example, while we show that finding a Hamiltonian path requires rounds in the worst case, in random graphs

, there exist fast algorithms, with the exact complexity depending on the probability

 [48, 13, 21]. When we focus on bounded-degree graphs, there exist efficient constant approximations for many optimization problems, such as MaxIS and MDS, whereas in general graphs such results are currently not known in the congest model. We show that when it comes to exact computation, even in bounded-degree graphs many problems are still difficult. Specifically, to solve MaxIS or MVC in bounded-degree graphs one would need rounds, and this holds even in graphs with logarithmic diameter and maximum degree 5. A similar result is shown for MDS. This is nearly-optimal, since all these problems can be solved in rounds in these graphs. Our lower bound here is again based on reductions, but this time not necessarily between graph problems. To show a lower bound for MaxIS we use a sequence of reductions between MaxIS and max 2SAT instances. Replacing a graph by a CNF formula is useful since it allows us to use the power of expander graphs and replace by a new equivalent CNF formula where each variable appears only a constant number of times. This reduction is inspired by [41, 15] and is the main ingredient that allows us eventually to convert our graph to a bounded-degree graph. Once we have a lower bound for MaxIS, a lower bound for MVC and MDS is obtained using standard reductions between the problems.

A succinct summary of our results in this section is the following.

  • We show an lower bound for solving MVC, MDS, MaxIS, and weighted 2-spanner on bounded degree graphs.

Hardness of approximation.

While solving problems exactly seems to be a difficult task, one can hope to find fast and efficient approximation algorithms. In the congest model, currently the best efficient approximation algorithms known for many problems achieve the same approximation factors as the best approximations known for polynomial sequential algorithms. An intriguing question is whether better approximations can be obtained efficiently. As a first step towards answering this question, we show that in some cases even just approximating the optimal solution is hard.

The challenge in showing such a lower bound is that we need to create a gap. It is no longer enough that the graph satisfies some predicate iff the inputs are, for example, disjoint, but rather we want that the size of the optimal solution would change dramatically according to the inputs. Creating gaps is also crucial in showing inapproxiambility results in the sequential setting, a prime example for this is the PCP theorem which is a key tool for creating such gaps. In the distributed setting, we may need a more direct approach. Several approaches to create such gaps are shown in previous work. In weighted problems, sometimes we can use the weights to create a gap, as done in the constructions of Das Sarma et al. [47]. In some cases, the construction itself allows showing a gap. For example, if the chromatic number of a graph is either at most or at least depending on the inputs, it shows a lower bound for a -approximation [10]. Similar ideas are used in lower bounds for approximating the diameter [1, 24, 18, 25]. Another option is to reduce from a problem in communication complexity that already embeds a gap in it, such as the gap disjointness problem [9], or to design a specific construction that produces a gap, as in the lower bound for directed -spanners [9].

We contribute two new techniques for this toolbox. Namely, we show that error-correcting codes and probabilistic methods are useful for creating gaps also in the congest model. Based on these, we show that obtaining a -approximation for MaxIS requires rounds. As we explain in Section 5, although MaxIS may be very difficult to approximate, we cannot use the Alice-Bob framework to show any lower bound for approximation better than . For other problems, however, we are able to show a lower bound for a stronger approximation. Specifically, we show a near-linear lower bound for obtaining an -approximation for the -MDS problem for , and for several variants of the Steiner tree problem. Here, -MDS is the problem of finding in a given vertex weighted graph , a minimum weight set such that for all , either , or . We also show such a result for MDS, but with some restrictions on the algorithm. For general algorithms, we show in Section 5 that we cannot use the Alice-Bob framework to show any hardness result for approximation above 2. This simply follows from the fact that if each one of Alice and Bob solves the problem optimally on its part, the union of the solutions gives a 2-approximation.

Our results demonstrate a clear separation between the congest and local models, since in the latter there are efficient -approximations for MaxIS and -MDS [20].111The algorithm for -MDS follows from algorithm for MDS, since in the local model we can simulate an MDS algorithm in the graph . Such a separation for a local approximation problem, a problem whose approximate solution does not require diameter many rounds when the message size is unbounded, was previously known only for approximating spanners [9].

A succinct summary of our results in this section is the following.

  • We show an and an lower bounds for computing a -approximation for MaxIS and a -approximation for MaxIS, respectively, for any constant . We also show a nearly-linear lower bound for computing an -approximation for weighted -MDS for all . We show similar results also for several variants of the Steiner tree problem. In addition, we show such results for weighted MDS, assuming some restrictions on the algorithm.

Limitations.

Finally, we study the limitations of this general lower bound framework. While it is capable of providing many near-quadratic lower bounds for exact and approximate computations, we show that sometimes it is limited in showing hardness of approximation. In addition, we prove impossibility of using this framework for providing lower bounds for exact computation for several central problems in P, such as maximum matching, max flow, min - cut and weighted - distance. Interestingly, we also show it cannot provide strong lower bounds for several verification problems, which stands in sharp contrast to known lower bounds for these problems [47]. This implies that using a fixed cut as in our paper, is provably weaker than allowing a changing cut as in [47].

One tool for showing such results is providing a protocol that allows Alice and Bob solve the problem by communicating only a small number of bits. Such ideas are used in showing the limitation of this framework for obtaining any lower bound for triangle detection [16], any super-linear lower bound for weighted APSP [10] (recently proven to have a linear solution [6]), and any lower bound larger than for detecting 4-cliques [14].

We push this idea further, showing that a non-deterministic protocol for Alice and Bob, which may be much easier to establish, can imply the limitations of the technique. We also show how to obtain such protocols using a connection to proof labeling schemes (PLS).

1.2 Preliminaries

We denote by the set . To prove lower bounds on the number of rounds necessary in order to solve a distributed problem in the congest model, we use reductions from two-party communication complexity problems. In what follows, we give the required definitions and the main reduction mechanism.

1.3 Communication Complexity

In the two-party communication complexity setting [35], there is a function , and two players, Alice and Bob, who are given two input strings, , respectively, and need to compute by exchanging bits according to some protocol . The communication complexity of is the maximal number of bits Alice and Bob exchange in , taken over all possible pairs of -bit strings .

For our lower bounds, we consider deterministic and randomized protocols. To show limitations of obtaining lower bounds we also consider nondeterministic protocols, whose discussion we defer to Section 5. In a randomized protocol, Alice and Bob can generate truly random bits of their own, and the final output of Alice and Bob needs to be correct (according to ) with probability at least over the random bits generated by both players.

The deterministic communication complexity of is the minimum , taken over all deterministic protocols for computing . The randomized communication complexity is defined analogously.

The main communication complexity problem that we use for our lower bounds is set disjointness, , which is defined as if and only if there is an index such that . It is known that and  [35, Example 3.22]. The latter holds even if Alice and Bob are allowed to generate shared truly random bits.

1.4 Family of Lower Bound Graphs

To formalize the reductions, we use the following definition which is taken from [10].

Definition 1.1.

Family of Lower Bound Graphs
Given integers and , a Boolean function and some Boolean graph property or predicate denoted , a set of graphs is called a family of lower bound graphs with respect to and if the following hold:

  1. The set of vertices is the same for all the graphs in the family, and we denote by a fixed partition of the vertices.

  2. Given , the only part of the graph which is allowed to be dependent on (by adding edges or weights, no adding vertices) is .

  3. Given , the only part of the graph which is allowed to be dependent on (by adding edges or weights, no adding vertices) is .

  4. satisfies if and only if .

The set of edges is denoted by , and is the same for all graphs in the family.

We use the following theorem whose proof can be found in [10].

Theorem 1.1.

Fix a function and a predicate . If there exists a family of lower bound graphs w.r.t and then any deterministic algorithm for deciding in the congest model takes rounds, and every randomized algorithm for deciding in the congest model takes rounds.

2 Near Quadratic Exact Lower Bounds

Here we show near-quadratic lower bounds for Minimum Dominating Set, max-cut, Minimum Steiner Tree, Directed and Undirected Hamiltonian Path or Cycle, and Minimum 2-edge-connected spanning subgraph.

2.1 Minimum Dominating Set

In the minimum dominating set (MDS) problem we are given a graph , and our goal is to find a minimum cardinality set of vertices such that each vertex is dominated by a vertex in : it is either in (thus dominates itself), or has a neighbor in . The MDS problem is a central problem, with many efficient -approximation algorithms in the congest model [26, 34, 33], where is the maximum degree in the graph. In this section, we show that solving the problem exactly requires nearly quadratic number of rounds, proving the following.

Theorem 2.1.

Any distributed algorithm in the congest model for computing a minimum dominating set or for deciding whether there is a dominating set of a given size requires rounds.

Note that our bound immediately applies to the vertex-weighted version of the problem. Also, note that a super-linear lower bound for deciding whether there is a dominating set of a given size also implies the same lower bound for computing a minimum dominating set, since computing the size of a given set of vertices takes rounds in the congest model. Thus, it suffices to prove the second part of the theorem, which we do by presenting a family of lower bound graphs.

Our construction is inspired by the lower bound graph construction for vertex cover from [10]. A first attempt to obtain this lower bound could be by using the standard NP-hardness reduction from vertex cover to MDS [41] (see also Section 3.3 for more details). However, this would require adding a vertex on each edge in the original graph, blowing up the size of the graph, and consequently showing only a near-linear lower bound. Instead, we show how to extend the construction from [10] to obtain a family of lower bound graphs for the MDS problem. Since MDS is a very basic problem, showing a lower bound for it allows us to later show lower bounds for additional problems such as Steiner Tree and Hamiltonian cycle. While there are standard reductions to both problems also from MVC, using them together with the lower bound from [10] can only show a near-linear lower bound. Roughly speaking, this follows since for each edge in the lower bound graph for MVC we must add at least one vertex, which blows up the number of vertices with respect to the inputs. In MDS, we cover vertices and not edges which allows showing an lower bound. We next describe our graph construction for MDS.

The family of lower bound graphs: Let be a power of , and build a family of graphs with respect to and the following predicate : the graph contains a dominating set of size .

The fixed graph construction: Start with a fixed graph (see Figure 1) consisting of four sets of vertices each, denoted , , , ; we refer to each set as a row, and to their vertices as row vertices. For each set add three additional sets of vertices and ; we refer to these vertices as bit-gadget vertices. For each and each , connect the -cycle . The cycles are connected to the sets by binary representation in the following way. Given a row vertex , i.e., , let denote the -th bit in the binary representation of . Connect to the set , defined as . Similarly, define .

Figure 1: The family of lower bound graphs for MDS
Constructing from given :

We index the strings by pairs of the form such that . Now we augment in the following way: For all pairs , we add the edge if and only if , and we add the edge if and only if .

Lemma 2.1.

Given , the graph has a dominating set of size if and only if .

Proof.

Assume first that , and let be the index s.t. , i.e., the edges are both in the graph . Construct a dominating set containing , and all the vertices in . This set is of size . By taking all of and , we made sure all the bit-gadget vertices of are dominated, and similarly, all the other bit-gadget vertices are dominated as well.

For the row vertices, first observe that are dominated by using the edges and . For the other row vertices, consider w.l.o.g. some vertex where , so there exists s.t. . If , then , and is dominated; similarly, if then is dominated as well. Thus, is a dominating set of size .

For the other direction, assume has a dominating set of size . For each and , the only way to dominate two vertices and is by two different bit-gadget vertices, so must contain at least bit-gadget vertices. We show that this is the exact number of bit-gadget vertices in by eliminating all other options.

If has bit-gadget vertices and no row vertices, then there is a set such that contains at most vertices of . In this set, contains at most one vertex out of any consecutive triple : If it contains more than one vertex in such a triplet, it contains no vertices of some other triple , and as cannot be dominated by row vertices, it is not dominated at all. So, for some , there is a set of the form in , which does not intersect . As does not contain any row vertices, it does not contain or any of its neighbors, so this vertices is not dominated.

If has bit-gadget vertices, and exactly one row-vertex, assume w.l.o.g. that this row vertex is in . For each other set , must contain at least one vertex from each triplet in order to dominate , and thus contains at least vertices of . Hence, for at least one of the set , contains exactly vertices of . The argument now follows the same lines as the previous: There is a set of the form that does not intersect , and as does not contain vertices from and , is not dominated.

We are left with the case where has exactly bit-gadget vertices and row vertices. This requires a sequence of claims, as follows.

The two row vertices are in different sets. If the two row vertices are in the same set, w.l.o.g. , then must contain at least one vertex from each triplet , in order to dominate . Since contains exactly vetrices of every -cycle, it can contain most one vertex of each triplet . Hence, there is a vertex such that does not intersect . Since no vertex of or is in , the vertex is not dominated, a contradiction.

contains exactly one of every pair of neighbors . Assume w.l.o.g. that are both in , so in the same -cycle, must both be dominated by vertices of . But no single vertex in has both in , and cannot contain two vertices of .

For each pair , and for each pair , either both vertices are in or both are not in . If is in then by the previous claim is not, so must be in in order to dominate ; similarly, if is in then must be in as well. If is in then is not, then must be in in order to dominate ; similarly, if is in then must be in .

As exactly of every -cycle vertices are in , from each pair at most one vertex is in . Choose a vertex not in from each pair , and let be the vertex such that is the set of these vertices. Hence, does not intersect , and is not dominated by bit-gadget vertices. For each vertex that is not in , the corresponding vertex is also not in , and similarly for vertices of the form . Thus, also does not intersect , and is not dominated by bit-gadget vertices. Similarly, let be a vertex such that does not intersect , and conclude also does not intersect . Thus, we have four vertices, that are not dominated by bit-gadget vertices, and instead, must be dominated by row vertices. It is impossible that both and have vertices from , as then there are no vertices from in and and and are not dominated; similarly, it is impossible that both and have vertices from . So, one of and must be in , and dominate the other, and either way the edge must exist in ; similarly, the edge must exist in . We thus conclude that , as claimed. ∎

Now all that is left in order to prove Theorem 2.1 is to use Theorem 1.1.

Proof.

We use Theorem 1.1. For that purpose we divide the graph into and in the following way. Define , and define . Since we get by using Theorem 1.1 a lower bound of rounds for the problem of deciding whether there is a dominating set of size . As , the proof is completed. ∎

2.2 Hamiltonian Path and Cycle Lower Bounds and applications

In this Section, we show near-quadratic lower bounds for Hamiltonian path and cycle in directed and undirected graphs, and for the minimum 2-edge-connected spanning subgraph problem (2-ECSS).

While the Hamiltonian path problem is not an optimization problem, it is known to be NP-hard, e.g., through a reduction from minimum vertex cover [27]. A lower bound of is known for the verification version of the problem [47], and Hamiltonian paths can be found efficiently in random graphs [21, 13, 48]. However, in general graphs we show an lower bound.

We also show that this directly shows hardness of unweighted 2-ECSS. While approximation algorithms to the problem include an -round -approximation [32], an -round 2-approximation [8] and an -round -approximation [42], we show that solving the 2-ECSS problem exactly requires near-quadratic number of rounds.

2.2.1 Directed Hamiltonian Path

Intuition for the construction:

Imagine traversing our lower bound graph for MDS in search for a Hamiltonian path, to which we add and vertices, where the path begins and ends, respectively. We need the existence of such a path to determine if the input strings are disjoint, so our approach is to traverse the bit-gadget vertices and the row vertices such that after a certain prefix, it remains to use a single edge from to followed by a single edge from to in order to each . The crux is to guarantee that these two edges have corresponding indexes. Since row vertices in different sides are not connected, we add a special vertex that is reachable from all vertices, leading to another special vertex that is connected to all vertices, which adds a single edge to .

The key challenge is guaranteeing that we can use such two edges iff they have the same indexes, implying that we need the prefix of the path to exclude exactly such 4 vertices. The second challenge is that there are more row vertices than bit-gadget vertices, so we cannot simply walk back and forth between these two types of vertices without reaching the bit-gadget vertices multiple times.

Our high-level approach for addressing these two issues is as follows (see Figure 2). For each row vertex in and each of its corresponding bit-gadget vertices, we plug in a gadget of constant size that replaces the bit-gadget vertices altogether. Further, we traverse the gadgets in an order that corresponds to some choice of and for each index of row vertices. The latter is what promises that we reach iff we use a single edge from to and a single edge from to with corresponding indexes. However, since the number of gadget-vertices is proportional to times the number of row vertices , we now face an opposite problem: there are more gadget vertices than row vertices, and the latter play a role in multiple gadgets. Moreover, if we chose to traverse the gadgets that correspond to, say, a choice for some index, we still need to visit the gadget vertices of the choice and we need to do so without visiting its respective row vertex. The power of the gadget is that it is designed to allow us to choose whether the path visits the row vertex of that gadget, or skips it and continues to the next gadget. This has two main strengths: First, it nullifies the issue that is caused by having row vertices appear in multiple gadgets. Second, it allows us to traverse all the gadget vertices that do not correspond to the choices that we make. This eventually allows us to obtain our desired claim, that a directed Hamiltonian path exists if and only if for an appropriate that allows a near-quadratic lower bound.

The family of lower bound graphs:

Given (we assume for simplicity that is a power of 2) we build our family of graphs with respect to and being the predicate that says that there exists in a directed Hamiltonian Path.

The fixed graph construction:

See Figure 2 for an illustration.

Figure 2: Hamiltonian path graph construction for .

We define 2 vertices, and , and 4 vertices . Further, there are vertices for every (row vertices).

The vertex has outgoing edges to all vertices for . The vertex has incoming edges from all vertices for , and has an outgoing edge to . The vertex has outgoing edges to all vertices for . The vertex has incoming edges from all vertices for , and has an outgoing edge to .

For every we define a box . The box contains vertices and , and for every and every it contains 4 vertices: (launch vertices), (wheel vertices), (skip vertices), and (burn vertices).

A crucial detail here is that the wheel vertices are not additional vertices, but they are simply reoccurrences of the row vertices, as follows. For every , it holds that

  • , for all such that is the -th index whose -th bit is , and , for all such that is the -th index whose -th bit is .

  • , for all such that is the -th index whose -th bit is , and , for all such that is the -th index whose -th bit is .

  • , for all such that is the -th index whose -th bit is , and , for all such that is the -th index whose -th bit is .

  • , for all such that is the -th index whose -th bit is , and , for all such that is the -th index whose -th bit is .

Within each box , the vertices has outgoing edges to for both possible values of . For each , the vertex has outgoing edges to and to . The vertex has an outgoing edge to . The vertices and have outgoing edges between each other in both directions. In addition, and have outgoing edges to a vertex , such that if , if and , and if and . Finally, the vertex has an outgoing edge to a vertex , such that if , and if .

Finally, the vertex a single outgoing edge into , and the vertex has two incoming edges, from for .

Constructing from given :

We index the strings by pairs of the form such that . Now we augment in the following way: For all pairs , we add the edge if and only if , and we add the edge if and only if .

Proving that is a family of lower bound graphs:

For every , , and , we define the following. We first define three types of -forward-steps: A -wheel-forward-step is a subpath , such that if then , if and then , and otherwise, . A -sigma-forward-step is a subpath , such that if then , if and then , and otherwise, (we will show that a Hamiltonian path cannot contain sigma-forward-steps). A -beta-forward-step is a subpath , such that if then , if and then , and otherwise, .

Finally, we define: A -backward-step is a subpath , such that if then , if then , and otherwise, .

Claim 2.1.

If then has a Hamiltonian path.

Proof.

If then there are row vertices such that the edges are in . Denote by the set of indexes in which the bit in the binary representation of is .

The Hamiltonian path is as follows. From it goes into which is in the first box . From , if then we go into the launch vertex and otherwise we go into the launch vertex . In general, when the path enters , if then it goes to the launch vertex and otherwise to the launch vertex ). When the path enters , if then it goes to the launch vertex and otherwise to the launch vertex ). We refer to these choices of edges as .

For every , from the launch vertex that was reached by , the path proceeds by -forward-steps until it reaches if , or otherwise. These forward steps are either -wheel-forward-steps or -beta-forward-steps, such that for every , the step is a -wheel-forward-step if and only if is not yet visited.

At the end of the above, the path reaches . For every , from the path goes into such that is the edge and . For every , the path then takes -backward-steps until it reaches if , or otherwise.

The above traversal has the property that it visits all row vertices through one of their wheel copies, except for exactly 4 row vertices: , and . This is because of our choice of according to the binary representations of and .

Now, from the path continues to , from which it continues to through the edge that exists given the input . From there the path continues to and to , from which it goes into . From there it continues to through the edge that exists given the input . Finally, the path goes into and ends in . ∎

We now claim that the opposite also holds.

Claim 2.2.

If then does not have a Hamiltonian path.

To prove Clai 2.2, we show that the following hold for any Hamiltonian path in .

Claim 2.3.

For any Hamiltonian path in , for every , , and , if goes from a launch vertex to , then it contains the -wheel-forward-step.

Proof.

Fix , , and . Assume that goes into and continues to . Assume towards a contradiction that the next vertex that goes into is not . Then is not Hamiltonian because it never reaches either of . This is because the only incoming edges to these two vertices are from each other, or from and , which have already been visited by . This means that from , the path goes to . The same argument gives that must then continue to , as otherwise it never reaches it, because it already visited all the vertices at its incoming edges. From the path must then continue to if , or to otherwise, unless in which case the path must continue to . ∎

Claim 2.4.

For any Hamiltonian path in , for every , , the following hold:

  1. If goes from to , then it must continue by a sequence of -forward-steps until it reaches if , or , otherwise.

  2. If goes from to , then it must continue by a sequence of -backward-steps until it reaches if , or , otherwise.

Proof.

The proof is by induction on . Let , and assume that goes from to . If does not continue with a -forward-step, it means that it goes to , either through or through , and from there to . Since other vertices, e.g.,