Slightly Superexponential Parameterized Problems
Daniel Lokshtanov, Daniel Marx, Saket Saurabh

TL;DR
This paper investigates parameterized problems with superexponential running times and proves that for some, the dependence on the parameter cannot be improved to single exponential, highlighting inherent computational complexity limits.
Contribution
The paper demonstrates that for certain parameterized problems with $f(k)=k^{O(k)}$, the superexponential dependence on $k$ is optimal and cannot be reduced to single exponential.
Findings
Proves superexponential dependence is optimal for some problems.
Shows that $f(k)=k^{O(k)}$ cannot be improved to $c^k$ for these problems.
Highlights inherent complexity barriers in parameterized algorithms.
Abstract
A central problem in parameterized algorithms is to obtain algorithms with running time such that is as slow growing function of the parameter as possible. In particular, a large number of basic parameterized problems admit parameterized algorithms where is single-exponential, that is, for some constant , which makes aiming for such a running time a natural goal for other problems as well. However there are still plenty of problems where the appearing in the best known running time is worse than single-exponential and it remained ``slightly superexponential'' even after serious attempts to bring it down. A natural question to ask is whether the appearing in the running time of the best-known algorithms is optimal for any of these problems. In this paper, we examine parameterized problems where is $k^{O(k)}=2^{O(k\log…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Slightly Superexponential Parameterized Problems111A preliminary version of the paper appeared in the proceedings of SODA 2011.
Daniel Lokshtanov Department of Informatics, University of Bergen, Bergen, Norway. [email protected]. Supported by ERC Starting Grant PaPaAlg (No. 715744).
Dániel Marx Institute for Computer Science and Control, Hungarian Academy of Sciences (MTA SZTAKI), Budapest, Hungary. [email protected]. Supported by ERC Starting Grant PARAMTIGHT (No. 280152) and Consolidator Grant SYSTEMATICGRAPH (No. 755978).
Saket Saurabh The Institute of Mathematical Sciences, Chennai, India. [email protected]. Supported by the ERC Starting Grant PARAPPROX (No. 306992).
Abstract
A central problem in parameterized algorithms is to obtain algorithms with running time such that is as slow growing function of the parameter as possible. In particular, a large number of basic parameterized problems admit parameterized algorithms where is single-exponential, that is, for some constant , which makes aiming for such a running time a natural goal for other problems as well. However there are still plenty of problems where the appearing in the best known running time is worse than single-exponential and it remained “slightly superexponential” even after serious attempts to bring it down. A natural question to ask is whether the appearing in the running time of the best-known algorithms is optimal for any of these problems.
In this paper, we examine parameterized problems where is in the best known running time and for a number of such problems, we show that the dependence on in the running time cannot be improved to single exponential. More precisely we prove following tight lower bounds, for four natural problems, arising from three different domains:
- •
In the Closest String problem, given strings , , over an alphabet of length each, and an integer , the question is whether there exists a string over of length , such that its hamming distance from each of the strings , , is at most . The pattern matching problem Closest String is known to be solvable in time and . We show that there are no or time algorithms, unless the Exponential Time Hypothesis (ETH) fails.
- •
The graph embedding problem Distortion, that is, deciding whether a graph has a metric embedding into the integers with distortion at most can be solved in time . We show that there is no time algorithm, unless the ETH fails.
- •
The Disjoint Paths problem can be solved in time in time on graphs of treewidth at most . We show that there is no time algorithm, unless the ETH fails.
- •
The Chromatic Number problem can be solved in time in time on graphs of treewidth at most . We show that there is no time algorithm, unless the ETH fails.
To obtain our results, we first prove the lower bound for variants of basic problems: finding cliques, independent sets, and hitting sets. These artificially constrained variants form a good starting point for proving lower bounds on natural problems without any technical restrictions and could be of independent interest. Several follow up works have already obtained tight lower bounds by using our framework, and we believe it will prove useful in obtaining even more lower bounds in the future.
1 Introduction
The goal of parameterized complexity is to find ways of solving NP-hard problems more efficiently than brute force: our aim is to restrict the combinatorial explosion to a parameter that is hopefully much smaller than the input size. Formally, a parameterization of a problem is assigning an integer to each input instance and we say that a parameterized problem is fixed-parameter tractable (FPT) if there is an algorithm that solves the problem in time , where is the size of the input and is an arbitrary computable function depending on the parameter only. There is a long list of NP-hard problems that are FPT under various parameterizations: finding a vertex cover of size , finding a cycle of length , finding a maximum independent set in a graph of treewidth at most , etc. For more background, the reader is referred to the monographs [18, 29, 34, 60].
The practical applicability of fixed-parameter tractability results depends very much on the form of the function in the running time. In some cases, for example in results obtained from Graph Minors theory, the function is truly horrendous (towers of exponentials), making the result purely of theoretical interest. On the other hand, in many cases is a moderately growing exponential function: for example, is in the current fastest algorithm for finding a vertex cover of size [14], which can be further improved to in the special case of graphs with maximum degree 3 [67]. For some problems, can be even subexponential (e.g., ) [24, 23, 22, 1].
The implicit assumption in the research on fixed-parameter tractability is that whenever a reasonably natural problem turns out to be FPT, then we can improve to with some small (hopefully ) if we work on the problem hard enough. Indeed, for some basic problems, the current best running time was obtained after a long sequence of incremental improvements. However, it is very well possible that for some problems there is no algorithm with single-exponential in the running time.
In this paper, we examine parameterized problems where is “slightly superexponential” in the best known running time: is of the form . Algorithms with this running time naturally occur when a search tree of height at most and branching factor at most is explored, or when all possible permutations, partitions, or matchings of a element set are enumerated. For a number of such problems, we show that the dependence on in the running time cannot be improved to single exponential. More precisely, we show that a time algorithm for these problems would violate the Exponential Time Hypothesis (ETH), which is a complexity-theoretic assumption that can be informally stated as saying that there is no -time algorithm for -variable 3SAT [44].
In the first part of the paper, we prove the lower bound for variants of basic problems: finding cliques, independent sets, and hitting sets. These variants are artificially constrained such that the search space is of size and we prove that a time algorithm would violate the ETH. The results in this section demonstrate that for some problems the natural upper bound on the search space is actually a tight lower bound on the running time. More importantly, the results on these basic problems form a good starting point for proving lower bounds on natural problems without any technical restrictions.
In the second part of the paper, we use our results on the basic problems to prove tight lower bounds for four natural problems from three different domains:
- •
In the Closest String problem, given strings , , over an alphabet of length each, and an integer , the question is whether there exists a string over of length , such that its hamming distance from each of the strings , , is at most . The pattern matching problem Closest String is known to be solvable in time [40] and [55]. We show that there are no or time algorithms, unless the ETH fails.
- •
The graph embedding problem Distortion, that is, deciding whether a vertex graph has a metric embedding into the integers with distortion at most can be done in time [33]. We show that there is no time algorithm, unless the ETH fails.
- •
The Disjoint Paths problem can be solved in time on vertex graphs of treewidth at most [64]. We show that there is no time algorithm, unless the ETH fails.
- •
The Chromatic Number problem can be solved in time on vertex graphs of treewidth at most [46]. We show that there is no time algorithm, unless the ETH fails.
We remark that the algorithm given in [64] does not mention the running time for Disjoint Paths as on graphs of bounded treewidth but a closer look reveals that it is indeed the case. We expect that many further results of this form can be obtained by using the framework of the current paper. Thus parameterized problems requiring “slightly superexponential” time is not a shortcoming of algorithm design or pathological situations, but an unavoidable feature of the landscape of parameterized complexity.
It is important to point out that it is a real possibility that some time algorithm can be improved to single-exponential dependence with some work. In fact, there are examples of well-studied problems where the running time was “stuck” at for several years before some new algorithmic idea arrived that made it possible to reduce the dependence to :
- •
In 1985, Monien [57] gave a time algorithm for finding a cycle of length in a graph on vertices. Alon, Yuster, and Zwick [2] introduced the color coding technique in 1995 and used it to show that a cycle of length can be found in time .
- •
In 1995, Eppstein [31] gave a time algorithm for deciding if a -vertex planar graph is a subgraph of an -vertex planar graph . Dorn [26] gave an improved algorithm with running time . One of the main technical tools in this result is the use of sphere cut decompositions of planar graphs, which was used earlier to speed up algorithms on planar graphs in a similar way [27].
- •
In 1995, Downey and Fellows [28] gave a time algorithm for Feedback Vertex Set (given an undirected graph on vertices, delete vertices to make it acyclic). A randomized time algorithm was given in 2000 [6]. The first deterministic time algorithms appeared only in 2005 [42, 21], using the technique of iterative compression introduced by Reed et al. [62].
- •
In 2003, Cook and Seymour [17] used standard dynamic programming techniques to give a -time algorithm for Feedback Vertex Set on graphs of treewidth , and it was considered plausible that this is the best possible form of running time. Hence it was a remarkable surprise in 2011 when Cygan et al. [19] presented a time randomized algorithm by using the so-called Cut & Count technique. Later, Bodlaender et al. [9] and Fomin et al. [36] obtained deterministic single-exponential parameterized algorithms using a different approach.
As we can see in the examples above, achieving single-exponential running time often requires the invention of significant new techniques. Therefore, trying to improve the running time for a problem whose best known parameterized algorithm is slightly superexponential can lead to important new discoveries and developments. However, in this paper we identify problems for which such an improvement is very unlikely. The dependence on seems to be inherent to these problems, or one should realize that in achieving single-exponential dependence one is essentially trying to disprove the ETH.
There are some lower bound results on FPT problems in the parameterized complexity literature, but not of the form that we are proving here. Cai and Juedes [12] proved that if the parameterized version of a MAXSNP-complete problems (such as Vertex Cover on graphs of maximum degree 3) can be solved in time , then ETH fails. Using parameterized reductions, this result can be transfered to other problems: for example, assuming the ETH, there is a no time algorithm for planar versions of Vertex Cover, Independent Set, and Dominating Set (and this bound is tight). However, no lower bound above was obtained this way for any problem so far.
Flum, Grohe, and Weyer [35] tried to rebuild parameterized complexity by redefining fixed-parameter tractability as time and introducing appropriate notions of reductions, completeness, and complexity classes. This theory could be potentially used to show that the problems treated in the current paper are hard for certain classes, and therefore they are unlikely to have single-exponential parameterized algorithms. However, we see no reason why these problems would be complete for any of those classes (for example, the only complete problem identified in [35] that is actually FPT is a model checking on problem on words for which it was already known that cannot even be elementary). Moreover, we are not only giving evidence against single-exponential time algorithms in this paper, but show that the dependence is actually tight.
2 Basic problems
In this section, we modify basic problems in such a way that they can be solved in time by brute force, and this is best possible assuming the ETH. In all the problems of this section, the task is to select exactly one element from each row of a table such that the selected elements satisfy certain constraints. This means that the search space is of size . We denote by the set of elements in a table, where is the element in row and column . Thus selecting exactly one element from each row gives a set , , for some mapping . In some of the variants, we not only require that exactly one element is selected from each row, but we also require that exactly one element is selected from each column, that is, has to be a permutation. The lower bounds for such permutation problems will be essential for proving hardness results on Closest String (Section 3) and Distortion (Section 4). The key step in obtaining the lower bounds for permutation problems is the randomized reordering argument of Theorem 2.11. The analysis and derandomization of this step is reminiscent of the color coding [2] and chromatic coding [1] techniques.
To prove that a too fast algorithm for a certain problem contradicts the Exponential Time Hypothesis, we have to reduce -variable 3SAT to problem and argue that the algorithm would solve 3SAT in time . It will be somewhat more convenient to do the reduction from 3-Coloring. We use the well-known fact that there is a polynomial-time reduction from 3SAT to 3-Coloring where the number of vertices of the graph is linear in the size formula.
Proposition 2.1**.**
Given a 3SAT formula with -variables and -clauses, it is possible to construct a graph with vertices in polynomial time such that is 3-colorable if and only if is satisfiable.
Proposition 2.1 implies that an algorithm for 3-Coloring with running time subexponential in the number of vertices gives an algorithm for 3SAT that is subexponential in the number of clauses. This is sufficient for our purposes, as the Sparsification Lemma of Impagliazzo, Paturi and Zane [44] shows that such an algorithm already violates the ETH.
Lemma 2.2** ([44]).**
Assuming the ETH, there is no time algorithm for -clause 3SAT.
Combining Proposition 2.1 and Lemma 2.2 gives the following proposition:
Proposition 2.3**.**
Assuming the ETH, there is no time algorithm for deciding whether an -vertex graph is -colorable.
2.1 ** Clique**
The first problem we investigate is the variant of the standard clique problem where the vertices are the elements of a table, and the clique we are looking for has to contain exactly one element from each row.
Clique
Input:
A graph over the vertex set
Parameter:
Question:
Is there a -clique in with exactly one element from each row?
Note that the graph in the Clique instance has vertices at most edges, thus the size of the instance is .
Theorem 2.4**.**
Assuming the ETH, there is no time algorithm for Clique.
Proof.
Suppose that there is an algorithm that solves Clique in time. We show that this implies that 3-Coloring on a graph with vertices can be solved in time , which contradicts the ETH by Proposition 2.3.
Let be a graph with vertices. Let be the smallest integer such that , or equivalently, . Note that such a finite exists for every and it is easy to see that for the smallest such . Intuitively, it will be useful to think of as a value somewhat larger than (and hence is somewhat less than ).
Let us partition the vertices of into groups , , , each of size at most . For every , let us fix an enumeration of all the proper 3-colorings of . Note that there are most such 3-colorings for every . We say that a proper 3-coloring of and a proper 3-coloring of are compatible if together they form a proper coloring of : for every edge with and , we have . Let us construct a graph over the vertex set where vertices and with are adjacent if and only if the -th proper coloring of and the -th proper coloring of are compatible (this means that if, say, has less than proper colorings, then is an isolated vertex).
We claim that has a -clique having exactly one vertex from each row if and only if is 3-colorable. Indeed, a proper 3-coloring of induces a proper 3-coloring for each of , , . Let us select vertex if and only if the proper coloring of induced by is the -th proper coloring of . It is clear that we select exactly one vertex from each row and they form a clique: the proper colorings of and induced by are clearly compatible. For the other direction, suppose that , , form a -clique for some mapping . Let be the -th proper 3-coloring of . The colorings , , together define a coloring of . This coloring is a proper 3-coloring: for every edge with and , the fact that and are adjacent means that and are compatible, and hence .
Running the assumed algorithm on decides the 3-colorability of . Let us estimate the running time of constructing and running algorithm on . The graph has vertices and the time required to construct is polynomial in : for each , we need to enumerate at most proper 3-colorings of . Therefore, the total running time is (using that ). It follows that we have a time algorithm for 3-Coloring on an -vertex graph, contradicting the ETH. ∎
Permutation Clique is a more restricted version of Clique: in addition to requiring that the clique contains exactly one vertex from each row, we also require that it contains exactly one vertex from each column. In other words, the vertices selected in the solution are , , for some permutation of . Given an instance of Clique having a solution , if we randomly reorder the vertices in each row, then with some probability the reordered version of solution contains exactly one vertex from each row and each column of the reordered instance. In Theorem 2.5, we use this argument to show that a time algorithm for Permutation Clique gives a randomized time algorithm for Clique. Section 2.1.1 shows how the proof of Theorem 2.5 can be derandomized.
Theorem 2.5**.**
If there is a time algorithm for Permutation Clique, then there is a randomized time algorithm for -clause 3SAT.
Proof.
We show how to transform an instance of Clique into an instance of Permutation Clique with the following properties: if is a no-instance, then is a no-instance, and if is a yes-instance, then is a yes-instance with probability at least . This means that if we perform this transformation times and accept as a yes-instance if and only at least one of the constructed instances is a yes-instance, then the probability of incorrectly rejecting a yes-instance can be reduced to an arbitrary small constant. Therefore, a time algorithm for Permutation Clique implies a randomized time algorithm for Clique.
Let be a mapping chosen uniform at random; we can imagine as a coloring of the vertices. Let if there is a such that and let otherwise (i.e., if , then no other vertex has color in row ). The instance of Permutation Clique is constructed the following way: if there is an edge between and in instance and , then we add an edge between and in instance . That is, we use mapping to rearrange the vertices in each row. If vertex clashes with some other vertex in the same row (that is, ), then all the edges incident to are thrown away.
Suppose that has a -clique , , for some permutation of . For every , there is a unique such that : otherwise is an isolated vertex in . It is easy to see that , , is a clique in : vertices and have to be adjacent, otherwise there would be no edge between and in . Therefore, if is a no-instance, then is a no-instance as well.
Suppose now that is a yes-instance: there is a clique , , in . Let us estimate the probability that the following two events occur:
- (1)
For every , .
- (2)
For every and with , .
Event (1) means that , , is a permutation of . Therefore, the probability of (1) is (using Stirling’s Formula). For a particular , event (2) holds if randomly chosen values are all different from . Thus the probability that (2) holds for a particular is and the probability that (2) holds for every is at least . Furthermore, events (1) and (2) are independent: we can imagine the random choice of the mapping as first choosing the values , , and then choosing the remaining values. Event (1) depends only on the first choices, and for any fixed result of the first choices, the probability of event (2) is the same. Therefore, the probability that (1) and (2) both hold is .
Suppose that (1) and (2) both hold. Event (2) implies that for every . Event (1) implies that if we set , then is a permutation of . Therefore, the clique , , is a solution of , as required. ∎
In the next section, we show that instead of random colorings, we can use a certain deterministic family of colorings. This will imply:
Corollary 2.6**.**
Assuming the ETH, there is no time algorithm for Permutation Clique.
2.1.1 Derandomization
In this section, we give a coloring family that can be used instead of the random coloring in the proof of Theorem 2.5. We call a graph to be a cactus-grid graph if the vertices are elements of a table and the graph precisely consists of a clique containing exactly one vertex from each row and each vertex in the clique is adjacent to every other vertex in its row. There are no other edges in the graph, thus the graph has exactly edges. We are interested in a coloring family with the property that for any cactus-grid graph with vertices from table, there exists a function such that properly colors the vertices of . We call such a as a coloring family for cactus-grid graphs.
Before we proceed to construct a coloring family of size , we explain how this can be used to obtain the derandomized version of Theorem 2.5, the Corollary 2.6. Suppose that the instance of Clique is a yes-instance. Then there is a clique , , in . Consider the cactus-grid graph consisting of clique , , and for each , the edges between and for every . Let be a proper coloring of . Now since , , is a clique in they get distinct colors by and since all the vertices in the row , , , are adjacent to we have that . So if we use this in place of , the random coloring used in the proof of Theorem 2.5, then events (1) and (2) hold and we know that the instance obtained using is a yes-instance of Permutation Clique. Thus we know that an instance of Clique has a clique of size containing exactly one element from each row if and only if there exists an such that the corresponding instance of Permutation Clique has a clique of size such that it contains exactly one element from each row and column. This together with the fact that the size of is bounded by imply the Corollary 2.6.
To construct our deterministic coloring family we also need a few known results on perfect hash families. Let be a set of functions such that for all subsets of size there is a such that it is one-to-one on . The set is called -family of perfect hash functions. There are some known constructions for set . We summarize them below.
Proposition 2.7** ([2, 59]).**
There exists explicit construction of -family of perfect hash functions of size . There is also another explicit construction of -family of perfect hash functions of size .
Now we are ready to state the main lemma of this section.
Lemma 2.8**.**
There exists explicit construction of coloring family for cactus-grid graphs of size .
Proof.
Our idea for deterministic coloring family for cactus-grid graphs is to keep functions where each is an element of a -family of perfect hash functions for some and use it to map the elements of (the column ). We guess the number of vertices of that appear in each column, and we reserve that many private colors for the column so that these colors are not used on the vertices of any other columns. This will ensure that we get the desired coloring family. We make our intuitive idea more precise below. A description of a function consists of a tuple having
- •
a set ;
- •
a tuple where , and ;
- •
functions where and is a -family of perfect hash functions.
The set tells us which columns the clique intersects. Let the elements of be sorted in increasing order, say . Then the tuple tells us that the column , , contains vertices from the clique. Hence with this interpretation, given a tuple we define the coloring function as follows. Every element in is mapped to . Now for vertices in (vertices in column ), we define . We do this for every between and . This concludes the description. Now we show that it is indeed a coloring family for cactus-grid graphs. Given a cactus grid graph , we first look at the columns it intersects and that forms our set and then the number of vertices it intersects in each column makes the the tuple . Finally for each of the columns there exists a function in the perfect -hash family that maps the elements of clique in this column one to one with ; we store this function corresponding to this column. Now we show that the function corresponding to this tuple properly colors . The function assigns different values from to the columns in and hence we have that the vertices of clique gets distinct colors as in each column we have a function that is one-to-one on the vertices of . Now we look at the edge with both end-points in the same row. If any of the end-point occurs in column that is not in , then we know that it has been assigned while the vertex from the clique has been assigned color from . If both end-points are from , then the offset we use to give different colors to vertices in these columns ensures that these end-points get different colors. This shows that is indeed a proper coloring of . This shows that for every cactus-grid graph we have a function . Finally, the bound on the size of is as follows,
[TABLE]
This concludes the proof. ∎
The bound achieved in Equation 1 on the size of is sufficient for our purpose but it is not as small as that one can obtain using a simple application of probabilistic methods. We provide a family of size below which could be of independent algorithmic interest.
Lemma 2.9**.**
There exists explicit construction of coloring family for cactus-grid graphs of size .
Proof.
We incurred a factor of in the construction given in Lemma 2.8 because for every column we applied hash functions from . Loosely speaking, if we could replace these by , then the size of family will be and then . Next we describe a procedure to do this by incurring an extra cost of . To do this we use the following classical lemma proved by Fredman, Komlós and Szemerédi [38].
Lemma 2.10** ([38]).**
Let with . The mapping such that is one-to-one when restricted to for at least half of the values . Here is any prime between and .
The idea is to use Lemma 2.10 to choose multipliers ( in the above description) appropriately. Let us fix a prime between and . Given a set and a tuple we make a partition of set as follows for . Now let us fix a set , by our construction we know that the size of intersection of the clique with each of the columns in is roughly same. For simplicity of argument, let us fix a clique of some cactus grid graph . Consider a bipartite graph where contains a vertex for each column in and consists of numbers from . Now we give an edge between vertex and if we can use as a multiplier in Lemma 2.10, that is, the map is one-to-one when restricted to the vertices of the clique to the column .
Observe that because of Lemma 2.10, every vertex in has degree at least and hence there exists a vertex that can be used as a multiplier for at least half of the elements in the set . We can repeat this argument by removing a vertex , that could be used as a multiplier for half of the vertices in , and all the columns for which it can be multiplier. This implies that there exits a set of size that could be used as a multiplier for every column in . Now we give a description of a function that consists of a tuple having
- •
a set ;
- •
a tuple where , and ;
- •
, , ; Here is a partition of and the interpretation is that for every column in we will use as a multiplier for range reduction;
- •
functions where and is a -family of perfect hash functions.
This completes the description. Now given a tuple
[TABLE]
we define the coloring function as follows. Every element in is mapped to . Now for vertices in (vertices in column ), we do as follows. Suppose then we define . We do this for every between and . This concludes the description for . Observe that given a vertex in column we first use the function in Lemma 2.10 to reduce its range to roughly and still preserving that for every subset of size at most there is some multiplier which maps it injective. It is evident from the above description that this is indeed a coloring family of cactus grid graphs. The range of any function in is and the size of this family is
[TABLE]
The last assertion follows from the fact that and . This concludes the proof. ∎
2.2 ** Independent Set**
The lower bounds in Section 2.4 for (Permutation) Clique obviously hold for the analogous (Permutation) Independent Set problem: by taking the complement of the graph, we can reduce one problem to the other. We state here a version of the independent set problem that will be a convenient starting point for reductions in later sections:
Bipartite Permutation Independent Set
Input:
A graph over the vertex set where every edge is between and .
Parameter:
Question:
Is there an independent set , , in for some permutation of ?
That is, the upper left quadrant and the lower right quadrant induce independent sets, and every edge is between these two independent sets. The requirement that the solution is a subset of means that for and for .
Theorem 2.11**.**
Assuming the ETH, there is no time algorithm for Bipartite Permutation Independent Set.
Proof.
Given an instance of Permutation Independent Set, we construct an equivalent instance of Bipartite Permutation Independent Set the following way. For every and , , we add an edge between and in . If there is an edge between and in , then we add an edge between and in . This completes the description of .
Suppose that has a solution , , for some permutation of . Then it is obvious from the construction of that , , , , , is an independent set of and , , , , , is clearly a permutation of . Suppose that , , is solution of for some permutation of . By definition, for . We claim that , , is an independent set of . Observe first that for every : otherwise there is an edge between and in . If there is an edge between and in , then by construction there is an edge between and in , contradicting the assumption that , , is an independent set in . ∎
2.3 ** Hitting Set**
Hitting Set is a W[2]-complete problem, but if we restrict the universe to a table where only one element can be selected from each row, then it can be solved in time by brute force.
Hitting Set
Input:
Sets .
Parameter:
Question:
Is there a set containing exactly one element from each row such that for any ?
We say that the mapping hits a set , if for some . Note that unlike for Clique and Independent Set, the size of the Hitting Set instance cannot be bounded by a function of .
It is quite easy to reduce Independent Set to Hitting Set: for every pair , of adjacent vertices, we need to ensure that they are not selected simultaneously, which can be forced by a set that contains every element of rows and , except and . However, in Section 3.1 we prove the lower bound for Closest String by reduction from a restricted form of Hitting Set where each set contains at most one element from each row. The following theorem proves the lower bound for this variant of Hitting Set. The basic idea is that an instance of Bipartite Permutation Independent Set can be transformed in an easy way into an instance of Hitting Set where each set contains at most one element from each column and we want to select exactly one element from each row and each column. By adding each row as a new set, we can forget about the restriction that we want to select exactly one element from each row: this restriction will be automatically satisfied by any solution. Therefore, we have a Hitting Set instance where we have to select exactly one element from each column and each set contains at most one element from each column. By changing the role of rows and columns, we arrive to a problem of the required form.
Theorem 2.12**.**
Assuming the ETH, there is no time algorithm for Hitting Set, even in the special case when each set contains at most one element from each row.
Proof.
To make the notation in the proof less confusing, we introduce a transposed variant of the problem (denote by Hitting SetT), where exactly one element has to be selected from each column. We prove the lower bound for Hitting SetT with the additional restriction that each set contains at most one element from each column; this obviously implies the theorem.
Given an instance of Bipartite Permutation Independent Set, we construct an equivalent Hitting SetT instance on the universe . For , let set contain the first elements of row and for , let set contain the last elements of row . For every edge in instance , we construct a set the following way. By the way Bipartite Permutation Independent Set is defined, we need to consider only edges connecting some and with and . For such an edge , let us define
[TABLE]
Suppose that , , is a solution of for some permutation of . We claim that it is a solution of . As is a permutation, the set satisfies the requirement that it contains exactly one element from each column. As if and only if , the set is hit for every . Suppose that there is an edge connecting and such that set of is not hit by this solution. Elements and are selected and we have and . Thus if these two elements do not hit , then this is only possible if and . However, this means that the solution for contains the two adjacent vertices and , a contradiction.
Suppose now that , , is a solution for . Because of the sets , , the solution contains exactly one element from each row, i.e., is a permutation of . Moreover, the sets , , have to be hit by the elements in the first columns. This means that if and consequently if . We claim that , , is also a solution of . It is clear that the only thing that has to be verified is that these vertices form an independent set. Suppose that and are connected by an edge . We can assume that and , which implies and . The solution for hits set , which means that either the solution selects an element or an element . Elements and are the only elements of this form in the solution, but neither of them appears in . Thus , , is indeed a solution of ∎
3 Closest String
Computational biology applications often involve long sequences that have to be analyzed in a certain way. One core problem is finding a “consensus” of a given set of strings: a string that is close to every string in the input. The Closest String problem defined below formalizes this task.
Closest String
Input:
Strings , , over an alphabet of length each, an integer
Parameter:
Question:
Is there a string of length such for every ?
We denote by the Hamming distance of the strings and , that is, the number of positions where they have different characters. The solution will be called the center string.
Closest String and its generalizations (Closest Substring, Distinguishing (Sub)string Selection, Consensus Patterns) have been thoroughly explored both from the viewpoint of approximation algorithms and fixed-parameter tractability [55, 66, 56, 40, 51, 16, 32, 39, 49, 25]. In particular, Gramm et al. [40] showed that Closest String is fixed-parameter tractable parameterized by : they gave an algorithm with running time . The algorithm works over an arbitrary alphabet (i.e., the size of the alphabet is part of the input). It is an obvious question whether the dependence on can be reduced to single exponential, i.e., whether the running time can be improved to . For small fixed alphabets, Ma and Sun [55] achieved single-exponential dependence on : the running time of their algorithm is . Improved algorithms with running time of this form, but with better constants in the exponent were given in [66, 16]. We show here that the and dependence are best possible (assuming the ETH): the dependence cannot be improved to or to . More precisely, what our proof actually shows is that dependence is not possible for the parameter . In particular, single exponential dependence on cannot be achieved if the alphabet size is unbounded.
Theorem 3.1**.**
Assuming the ETH, there is no or time algorithm for Closest String.
Proof.
We prove the theorem by a reduction from the Hitting Set problem considered in Theorem 2.12. Let be an instance of Hitting Set with sets , , ; each set contains at most one element from each row. We construct an instance of Closest String as follows. Let , , and (this means that the center string has to have at least one character common with every input string). Instance contains input strings (, ). If set contains element from row , then the -th character of is ; if contains no element of row , then the -th character of is . Thus string describes the elements of set , using a certain dummy value between and to mark the rows disjoint from . The strings , , differ only in the choice of the dummy values.
We claim that has a solution if and only if has. Suppose that , , is a solution of for some mapping . Then the center string is a solution of : if element of the solution hits set of , then both and have character at the -th position. For the other direction, suppose that center string is a solution of . As the length of is , there is a that does not appear in . If the -th character of is some , then let ; otherwise, let (or any other arbitrary value). We claim that , , is a solution of , i.e., it hits every set of . To see this, consider the string , which has at least one character common with . Suppose that character appears at the -th position in both and . It is not possible that : character is the only character larger than that appears in , but does not appear in . Therefore, we have and , which means that element of the solution hits .
The claim in the previous paragraph shows that solving instance using an algorithm for Closest String solves the Hitting Set instance . Note that the size of the instance is polynomial in and . Therefore, a or a algorithm for Closest String would give a time algorithm for Hitting Set, violating the ETH (by Theorem 2.12). ∎
4 Distortion
Given an undirected graph with the vertex set and the edge set , a metric associated with is , where the distance function is the shortest path distance between and for each pair of vertices . We refer to as to the graph metric of . Given a graph metric and another metric space with distance functions and , a mapping is called an embedding of into . The mapping has contraction and expansion if for every pair of points in , and respectively. We say that is non-contracting if is at most . A non-contracting mapping has distortion if is at most . One of the most well studied case of graph embedding is when the host metric is and is the Euclidean distance. This is also called embedding the graph into integers or line. Formally, the problem of Distortion is defined as follows.
Distortion
Input:
A graph , and a positive integer
Parameter:
Question:
Is there an embedding such that for all , ?
The problem of finding embedding with good distortion between metric spaces is a fundamental mathematical problem [45, 52] that has been studied intensively [3, 4, 5, 48]. Embedding a graph metric into a simple low-dimensional metric space like the real line has proved to be a useful algorithmic tool in various fields (for an example see [43] for a long list of applications). Bădoiu et al. [4] studied Distortion from the viewpoint of approximation algorithms and exact algorithms. They showed that there is a constant , such that -approximation of the minimum distortion of embedding into the line, is NP-hard and provided an exact algorithm computing embedding of a vertex graph into line with distortion in time . Subsequently, Fellows et al. [33] improved the running time of their algorithm to and thus proved Distortion to be fixed parameter tractable parameterized by . We show here that the dependence in the running time of Distortion algorithm is optimal (assuming the ETH). To achieve this we first obtain a lower bound on an intermediate problem called Constrained Permutation, then give a reduction that transfers the lower bound from Constrained Permutation to Distortion. The superexponential dependence on is particularly interesting, as time algorithms for finding a minimum distortion embedding of a graph on vertices into line have been given by Fomin et al. [37] and Cygan and Pilipczuk [20].
Constrained Permutation
Input:
Subsets , , of
Parameter:
Question:
A permutation of such that for every , there is a such that .
Given a permutation of , we say that and are neighbors if for some . In the Constrained Permutation problem the task is to find a permutation that hits every set in the sense that there is a pair that are neighbors in .
Theorem 4.1**.**
Assuming the ETH, there is no time algorithm for Constrained Permutation.
Proof.
Given an instance of Bipartite Permutation Independent Set, we construct an equivalent instance of Constrained Permutation. Let and for ease of notation, let us identify the numbers in with the elements , , , for , . The values represent the rows and the values represent the columns. If and are neighbors in , then we interpret it as selecting element from row . More precisely, we want to construct the sets , , in such a way that if , , is a solution of , then the following permutation of is a solution of :
[TABLE]
The first property that we want to ensure is that every solution of looks roughly like above: pairs and pairs alternate in some order. Then we can define a permutation such that if is followed by the pair . The sets in instance will ensure that this permutation is a solution of . Let instance contain the following groups of sets:
For every and , there is a set , 2. 2.
For every and , there is a set , 3. 3.
For every , , , there is a set , 4. 4.
For every , there is a set , 5. 5.
For every , there is a set , 6. 6.
For every two adjacent vertices and , there is a set .
Recall that every edge of instance goes between the independent sets and . Let us verify first that if is a solution of , then the permutation described above satisfies every set. It is clear that sets in the first two groups are satisfied. To see that every set in group 3 is satisfied, consider a set corresponding to a particular , , . If , then and are neighbors and both appear in the set; if , then and are neighbors and both appear in the set. Sets in group 4 and 5 are satisfied because for and for . Finally, let and be two adjacent vertices and consider the corresponding set in group 6. As the solution of is an independent set, either or . In the first case, and are neighbors and both appear in the set; in the second case, and are neighbors and both appear in the set.
Next we show that if is a solution of , then a solution for exists. We say that an element is good if its neighbors are and for some and . Similarly, an element is good if its neighbors are and for some and . Our first goal is to show that every and is good. The sets in group 1 and 2 ensure that and are neighbors, and and are neighbors.
We claim that for every , and , if elements and are not neighbors, then both of them are good. Let us build a -vertex graph whose vertices are , (). Let us connect by an edge those vertices that are neighbors in . Moreover, let us make and adjacent for every . Observe that the degree of every vertex is at most 2 (as has only one neighbor besides ). Moreover, is bipartite: in every cycle, edges of the form alternate with edges not of this form. Therefore, there is a bipartition of such that the set (and hence ) contains exactly one of and for every . Group 3 contains a set and a set : as contains exactly one of and , there is a choice of that yields these sets. Permutation satisfies and , thus each of and contains a pair of neighboring elements. By assumption, this pair cannot be and . As induces an independent set of , this pair cannot be contained in either. Thus the only possibility is that one of and is the neighbor of an element of . If, say, is a neighbor of an element , then is good. In this case, is not the neighbor of any element of , which means that the only way two members of are neighbors if is a neighbor of a member of , i.e., is also good.
At most one of and can be the neighbor of , thus we can assume that and are not neighbors for some . By the claim in the previous paragraph, and are both good. In particular, this means that is not the neighbor of and , hence applying again the claim, it follows that and are both good. Thus is good for every and , and the pigeonhole principle implies that is good for every and .
As every is good, the sets in groups 4 and 5 can be satisfied only if every has a neighbor . Let if is the neighbor of ; clearly is a permutation of . We claim that is a solution of . The sets in group 4 and 5 ensure that for every and if . To see that , , is an independent set, consider two adjacent vertices and . We show that it is not possible that and . Consider the set in group 6 corresponding to the edge connecting and . As , , and every is good, then only way is can be satisfied is that or is the neighbor of some appearing in . If and , then the and are the neighbors of and , respectively, but and do not appear in . This shows that if there is a solution for , then there is a solution for as well.
The size of the constructed instance is polynomial in . Thus if can be solved in time , then this gives a time algorithm for Bipartite Permutation Independent Set. ∎
Theorem 4.2**.**
Assuming the ETH, there is no time algorithm for Distortion.
Proof.
We prove the theorem by a reduction from the Constrained Permutation problem. Let be an instance of Constrained Permutation consisting of subsets , , of . Now we show how to construct the graph , an input to Distortion corresponding to . For an ease of presentation we identify with vertices . We also set and . The vertex set of consists of the following set of vertices.
- •
A vertex for every and . We also denote the set by .
- •
A vertex for each set .
- •
Two cliques and of size consisting of vertices and respectively.
- •
A path of length (number of edges) consisting of vertices .
We add the following more edges among these vertices. We add edges from all the vertices in clique but to and add edges from all the vertices in clique but to . For all and , make adjacent to , and . For , make adjacent to , . Finally make adjacent to if . This concludes the construction. A figure corresponding to the construction can be found in Figure 1.
For our proof of correctness we also need the following known facts about distortion embedding of a graph into integers. For an embedding , let , be an ordering of the vertices such that . If is such that for all , , then the mapping is called pushing embedding. It is known that pushing embeddings are always non-contracting and if can be embedded into integers with distortion , then there is a pushing embedding of into integers with distortion [33].
Let a permutation of be a solution to , an instance of Constrained Permutation. This automatically leads to a permutation on that we represent by . There is a natural bijection between and with being mapped to . So when we write then this means that the vertices of are permuted with respect to and being identified with its counterpart in . Now we give a pushing embedding for the vertices in with being placed at [math]. All the vertices except the set vertices appear in the following order
[TABLE]
Since is a solution to we know that for every there exists a such that . We place between and . By our construction the given embedding is pushing and hence non-contracting. To show that for every pair of vertices , , we only have to show that for every edge , . This can be readily checked from the construction. What needs to be verified is that for any two adjacent vertices and , the sequence of vertices between and in the pushing embedding give a total distance at most . The cruical observation is that the distance between two consecutive vertices from is , and hence it must be at least distance apart on the line. If is adjacent to two consecutive vertices in we can “squeeze” in between those two vertices without disturbing the rest of the construction.
In the reverse direction, assume that we start with a distortion pushing embedding of . Consider the layout of the graph induced on and the vertex . This is a clique of size minus an edge and hence can be layed out in two ways: or . Since we can reverse the layout, we can assume without loss of generality that it is . Without loss of generality we can also assume that is placed on position [math]. Since every vertex in is adjacent to and the negative positions are taken by the vertices in , the vertices of must lie on the positions . We first argue that no vertex of occupies the position . Suppose it does. Then the rightmost vertex of (to the right of in the embedding) must be on position at least . Simultaneously must be on position at most since is already occupied and is adjacent to . But is adjacent to the rightmost vertex of and hence the distance on the line between them becomes at least , a contradiction. So must use only positions in . Since the distance between two consecutive vertices in is together with the fact that we started with a pushing embedding imply that the vertices of occupy all odd positions of . Now, must be on the positions in with the rightmost vertex in being on at least . Since is occupied by someone in and is adjacent to both and the rightmost vertex of it follows that must be on position .
We can now argue similarly to the previous paragraph that does not use position , and hence is on position while must use the odd positions of . We can repeat this argument for all and position the vertex of the path at and place the vertices of at odd positions between and . Of course, all the vertices of the clique will come after .
Consider the order in which the embedding puts the vertices of . We claim that it must put the vertices of in the same order. Look at the embedding of and from left to right and let be the first index where of is placed between [math] and while of is placed between and and . This implies that appears further back in the permutation of and hence the distance between the positions of and in is more than while and are adjacent to each other in the graph. By repeating this argument for all and we can show that order of all ’s is the same. Consider . It must be put on some even position, with some vertices of coming before and after . But then, because we started with pushing embedding we have that is adjacent to both those vertices, and hence as is adjacent to only the vertices in .
Now we take the permutation for , imposed by the ordering of , as a solution to the instance of Constrained Permutation. For every set we need to show that there exists a such that . Consider the corresponding in the embedding and look at the vertices that are placed left and right of it. Let these be and . Then by construction and are neighbors to in and hence and belong to . Now since the ordering of ’s are same we have that they are consecutive in the permutation . This concludes the proof in the reverse direction.
The claim in the previous paragraph shows that an algorithm finding a distortion embedding of into line solves the instance of Constrained Permutation. Note the number of vertices in is bounded by a polynomial in and . Therefore a algorithm for Distortion would give a algorithm for Constrained Permutation, violating the ETH by Theorem 4.1. ∎
5 Disjoint Paths
There are many natural graph problems that are fixed-parameter tractable parameterized by the treewidth of the input graph. In most cases, these results can be obtained by well-understood dynamic programming techniques. In fact, Courcelle’s Theorem provide a clean way of obtaining such results. If the dynamic programming needs to keep track of a permutation, partition, or a matching at each node, then running time of such an algorithm is typically of the form on graphs with treewidth [64]. We demonstrate a problem where this form of running time is necessary for the solution and it cannot be improved to . We start with definitions of treewidth and pathwidth.
Definitions of Treewidth and Pathwidth.
A tree decomposition of a graph is a pair where is a tree and is a collection of subsets of such that:
, 2. 2.
for each edge , for some ; 3. 3.
for each the set induces a connected subtree of .
The width of the tree decomposition is . The treewidth of a graph is the minimum width over all tree decompositions of . We denote by the treewidth of graph . If in the definition of treewidth we restrict the tree to be a path then we get the notion of pathwidth and denote it by .
Now we return to our problem. Given an undirected graph and vertex pairs , the Disjoint Paths problem asks whether there exists mutually vertex disjoint paths in linking these pairs. This is one of the classic problems in combinatorial optimization and algorithmic graph theory, and has many applications, for example in transportation networks, VLSI layout, and virtual circuits routing in high-speed networks. The problem is NP-complete if is part of the input and remains so even if restrict the input graph to be planar [47, 54]. However if is fixed then the problem is famously fixed-parameter tractable as a consequence of the seminal Graph Minors theory of Robertson and Seymour [63]. A basic building block in their algorithm for Disjoint Paths is an algorithm for Disjoint Paths on graphs of bounded treewidth. To our interest is the following parameterization of Disjoint Paths.
Disjoint Paths
Input:
A graph together with a tree-decomposition of width , and vertex pairs .
Parameter:
Question:
Does there exist mutually vertex disjoint paths in linking to ?
The best known algorithm for this problem runs in time [64] and here we show that this is indeed optimal. To get this lower bound we first give a linear parameter reduction from Hitting Set to Directed Disjoint Paths, a variant of Disjoint Paths where the input is a directed graph, parameterized by pathwidth of the underlying undirected graph. Finally we obtain a lower bound of on Disjoint Paths parameterized by pathwidth under the ETH, by giving a linear parameter reduction from Directed Disjoint Paths parameterized by pathwidth to Disjoint Paths parameterized by pathwidth. Obviously, this proves the same lower bound under the (potentially much smaller) parameter treewidth as well.
Theorem 5.1**.**
Assuming the ETH, there is no time algorithm for Directed Disjoint Paths.
Proof.
The key tool in the reduction from Hitting Set to Directed Disjoint Paths is the following gadget. For every and set , we construct the gadget the following way (see Figure 2 for illustration).
- •
For every , it contains vertices , .
- •
For every , it contains a vertex and edges , .
- •
For every , it contains a directed path .
- •
For every , it contains vertices , , and edges , , , , , .
- •
It contains two vertices and , and for every , there are two edges , .
The demand pairs in the gadget are as follows:
- •
For every , there is a demand .
- •
For every , there is a demand .
- •
There is a demand .
This completes the description of the gadget. The intuition behind the construction is the following. To satisfy the demand , the path needs to leave to for some . Thus if a collection of paths form a solution for the gadget, then for every , exactly one of the vertices , , is used by the paths. We say that a solution represents the mapping if for every , vertex is used by the paths in the solution. Moreover, if the path satisfying leaves to , then it enters the path via the vertex , and reaches on the path . In this case, the demand cannot use vertex , and has to use the part of from to . Then these two paths leave free only vertex of and no other . This means that the and vertices behave exactly the opposite way: if is used by the solution, then every vertex , , is used, with the exception of . The following claim formalizes this important property of the gadget.
Claim 5.2**.**
For every and , gadget has the following properties:
For every that hits , gadget has a solution that represents , and is not used by the paths in the solution for any . 2. 2.
If has a solution that represents , then hits and vertex is used by the paths in the solution for every and .
Proof.
To prove the first statement, we construct a solution the following way. Demand is satisfied by the path , where we use a subpath of to go from to . For every , if , then the demand is satisfied by the path . If , then vertex is already used by the demand . In this case demand is satisfied by the path . Finally, as hits , there is a such that and hence the edges and exist. Therefore, we can satisfy the demand via . Note that this vertex is not used by the other paths: the path satisfying demand uses only from to , the path satisfying demand uses from to , and no other path reaches . This also implies that is used by none of the paths, as required.
For the second part, consider a solution of representing some mapping . This means that the path of demand uses vertex and hence . The only way to reach from without going through any other terminal vertex is using the path . This means that demand cannot use vertex , hence it has to use the path . It follows that for every and , vertices and are used by the paths satisfying demands and . This shows that every with is used by the paths in the solution. Moreover, the path satisfying has to go through vertex for some . By the way the edges incident to and are defined, this is only possible if , that is, hits . ∎
Let , , be the sets appearing in the Hitting Set instance . We construct an instance of Directed Disjoint Paths consisting of gadgets , , , where gadget is a copy of the gadget defined above. For every and every , we identify vertex of and vertex of . This completes the description of the instance of Directed Disjoint Paths.
We have to show that the pathwidth of the constructed graph of is and that has a solution if and only if has. To bound the pathwidth of , for every , , let us define the bag such that it contains vertices , , , , , , , , , , , and the path of gadget (unless ), and vertices , , , , , of gadget (unless ). It can be easily verified that the size of each bag is and if two vertices are adjacent, then they appear together in some bag. Furthermore, if we order the bags lexicographically according to , then each vertex appears precisely in an interval of the bags. This shows that the pathwidth of is .
Next we show that if has a solution , then also has a solution. As hits every , by the first part of the Claim, each gadget has a solution representing . To combine these solutions into a solution for , we have to make sure that the vertices , that were identified are used only in one gadget. Since the solution for gadget represents , it uses vertices , , , but no other vertex. As vertex of gadget was identified with vertex of gadget , these vertices might be used by the solution of as well. However, the solution of also represents and as claimed in the first part of the Claim, the solution does not use vertices , , . Therefore, no conflict arises between the solutions of and .
Finally, we have to show that a solution for implies that a solution for exists. We say that a solution for is normal with respect to if the paths satisfying the demands in do not leave (the vertices , that were identified are considered as part of both gadgets, so we allow the paths to go through these vertices). We show by induction that the solution for is normal for every . Suppose that this is true for . If some path satisfying a demand in leaves , then it has to enter either or . If enters a vertex of that is not in , then it cannot go back to : the only way to reach a vertex of is from vertex , which has indegree 0. Therefore, let us suppose that enters at some vertex of . The only way the path can return to is via some vertex of with . By the induction hypothesis, the solution is normal with respect to , thus the second part of the Claim implies that there is a unique such that is not used by the paths satisfying the demands in . As can use only this vertex , it follows that and hence path does not use any vertex of not in , In other words, does not leave .
Suppose now that the solution is normal with respect to every , which means that it induces a solution for every gadget. Suppose that the solution of gadget represents mapping . We claim that every is the same. Indeed, if , then the solution of uses vertex of , which is identical to vertex of . This means that the solution of does not use , and by the second part of the Claim, this is only possible if . Thus for every , let be this mapping. Again by the claim, hits every set in instance , thus is a solution of . ∎
For our main proof we will also need the following lemma.
Lemma 5.3** ([7]).**
Let be a graph (possibly with parallel edges) having pathwidth at most . Let be obtained from by subdividing some of the edges. Then the pathwidth of is at most .
Theorem 5.4**.**
Assuming the ETH, there is no time algorithm for Disjoint Paths.
Proof.
Let be a instance of Directed Disjoint Paths on a directed graph having pathwidth . We transform into an undirected graph , where two adjacent vertices , correspond to each vertex of , and if is an edge of , then we introduce a new vertex that is adjacent to both and . It is not difficult to see that the pathwidth of is at most : can be obtained from the underlying graph of by duplicating vertices (which at most doubles the size of each bag) and subdividing edges (which increases pathwidth at most by one).
Let be an instance of Disjoint Paths on where there is a demand corresponding to every demand of of . It is clear that if has a solution, then has a solution as well: every directed path from to in can be turned into a path connecting and in . However, the converse is not true: it is possible that an undirected path in reaches from and instead of continuing to , it continues to some . In this case, there is no directed path corresponding to in . We add further edges and demands to forbid such paths.
Let , , be a path decomposition of having width . For every vertex of , let and be the index of the first and last bags, respectively, were appears. It is well-known that the decomposition can be chosen such that for any two vertices and .
We modify to obtain a graph the following way. If vertex has inneighbors , , in , then has neighbors in : and vertices , , . Suppose that the neighbors of are ordered such that . We introduce new vertices , , , , , such that and are both adjacent to and . For every , we introduce a new demand . Repeating this procedure for every vertex of creates an instance of undirected Disjoint Paths on a graph .
We show that these new vertices and edges increase the pathwidth at most by a constant factor. Observe that can be obtained from by adding two parallel edges between and and subdividing them. Thus by Lemma 5.3, all we need to show is that adding these new edges increases pathwidth only by a constant factor. If , then the parallel edges between and can be added without changing the path decomposition: bag contains both vertices. If , then let us insert vertex into every bag for . Now bag contains both and , thus we can add two parallel edges between them. Note that vertex appears in every bag where is inserted: if not, then either does not appear in bags with index at most , or it does not appear in bags with index at least , contradicting the fact that is adjacent to both and . Furthermore, vertices and are not inserted into the same bag for any : if , then . Therefore, the number of new vertices in each bag is at most the original size of the bag, i.e., the size of each bag increases by at most a factor of 2.
We claim that has a solution if and only if has. If has a solution, then the directed path satisfying demand gives in a natural way an undirected path in that satisfies demand . Thus we can obtain a pairwise disjoint collection of paths that satisfy the demands of the form . Note that if , , , are the neighbors of in , then the paths in this collection use at most one of the vertices , , , say, . Now we can satisfy the demands for every : for , we can use the path , and for , we can use the path . Thus instance has a solution.
For the other direction, suppose that has a solution. Let us call a path of this solution a main path if it satisfies a demand of the form . We claim that if is an internal vertex of a main path , then contains as well. Otherwise, has to contain at least two of the neighbors , , of . In this case, less than vertices out of , , remain available for the demands , , , a contradiction.
Consider a main path that satisfies a demand of . Clearly, cannot go through any terminal vertex other than and . As has indegree 0 in , path has to go to some and then to after starting from . By our claim in the previous paragraph, the next vertex has to be , then again some and and so on. Thus there is a directed path in that corresponds to in . This means that directed paths corresponding to the main paths of the solution for form a solution for . ∎
6 Chromatic Number
In this section, we give another lower bound result for a problem that is known to admit an algorithm with running time on graphs with treewidth . In particular we show that the running time cannot be improved to unless the ETH collapses. Given a graph , a function , is called an -proper coloring of , if for any edge , we have that . The chromatic number of a graph is the minimum positive integer for which admits an proper -coloring and is denoted by . In the Chromatic Number problem, we are given a graph and objective is to find the value of . It is well known that if has treewidth then . Using, this we can obtain an algorithm for Chromatic Number running in time on graphs with treewidth [46]. We show that in fact this running time is optimal.
In what follows, we give a lower bound for a parameter even larger than the treewidth of the input graph. Given a graph , a subset of vertices is called vertex cover if for every , either or . In other words, is an independent set. In particular, we will study the following parameterization of the problem.
Chromatic Number
Input:
A graph together with a vertex cover of size at most and a positive integer .
Parameter:
Question:
Is ?
It is well known that if has a vertex cover of size , then its treewidth is upper bounded by and thus we can test whether in time .
Theorem 6.1**.**
Assuming the ETH, there is no time algorithm for Chromatic Number parameterized by vertex cover number.
Proof.
We prove the theorem by a reduction from the Permutation Clique problem. Let be an instance of Permutation Clique consisting of a graph over the vertex set and a positive integer . Recall that in the Permutation Clique problem, the goal is to check whether there is a clique containing exactly one vertex from each row, and containing exactly one vertex from each column. In other words, the vertices selected in the solution are , , for some permutation of .
Now we show how to construct the graph , an input to Chromatic Number starting from . The vertex set of consists of the following set of vertices and edges.
- •
We have two cliques and of size . The vertex set of , , consists of .
- •
For every , and , for which and are not adjacent in , we have a new vertex . We first make adjacent to and . Finally, we add edges between and .
This concludes the construction.
We now show that has a permutation clique if and only if . Let the vertices selected in the permutation clique are , , for some permutation of . Now we define a proper -coloring of . For every , we color the vertex with and the vertex with . The only vertices that are left uncolored are . Observe that the only colors that we can use for are . Thus, if we can show that is non-empty then we can use any color in to color . But that follows since there is an edge between and and there is no edge between and by definition of .
Next we show the reverse direction. Let be a proper -coloring function for . Without loss of generality we can assume that . For every , define . Observe that since is a clique and is a proper -coloring for and hence in particular for , we have that is a permutation of . We claim that , , forms a permutation clique of . Towards this we only need to show that there is an edge between every and in . For contradiction assume that and are not adjacent in . Consider, the vertex in . It can only be colored with either or . However, and . This contradicts the fact that is a proper -coloring of . This concludes the proof in the reverse direction.
Finally, observe that the vertices of and form a vertex cover for of size . The claim in the previous paragraph shows that an algorithm finding a solves the instance of Permutation Clique. Note the number of vertices in is bounded by a polynomial in and the vertex cover of is bounded by . Therefore a algorithm for Chromatic Number would give a algorithm for Permutation Clique, violating the ETH by Theorem 2.5. ∎
7 Conclusion
In this paper we showed that several parameterized problems have slightly superexponential running time unless the ETH fails. In particular we showed for four well-studied problems arising in three different domains that the known superexponential algorithms are optimal: assuming the ETH, there is no or time algorithm for Closest String, time algorithm for Distortion, and time algorithm for Disjoint Paths and Chromatic Number parameterized by treewidth. We believe that many further results of this form can be obtained by using the framework of the current paper. Two concrete problems that might be amenable to our framework are:
- •
Are the known parameterized algorithms for Point Line Cover [50, 41] and Directed Feedback Vertex Set [15], parameterized by the solution size, running in time optimal?
In the conference version of this paper [53], we asked further questions of this form, which have been answered by now.
- •
Is the time parameterized algorithm for Interval Completion [65] optimal? In 2016, Cao [13] showed that this is not the case: the problem can be solved in single-exponential time . In fact, recently Bliznets et al. [8] obtained an algorithm with running time for Interval Completion.
- •
Are the known parameterized algorithms for Hamiltonian Path [34], Connected Vertex Cover [58] and Connected Dominating Set [24], parameterized by the treewidth of the input graph, running in time optimal? In 2011, Cygan et al. introduced the technique of Cut & Count [19], which is able to give time randomized algorithms for all these problems. Later, deterministic algorithms with this running time were found [9, 36]. Cygan et al. showed also that, assuming the ETH, there is no time algorithm for Cycle Packing on graphs of treewidth .
It seems that our paper raised awareness in the field of parameterized algorithms that tight lower bounds are possible even for running times that may look somewhat unnatural, and in particular if a problem can be solved in time , then it is worth exploring whether this can be improved to single-exponential or a lower bound can be proved. The invention of the Cut & Count technique and the related results of Cygan et al. [19] seem to be influenced by this realization. By now, there are other papers building on our work and investigating the optimality of time algorithms in the context of bounded-treewidth graphs or graph modification problems [10, 11, 61, 30]
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] N. Alon, D. Lokshtanov, and S. Saurabh , Fast FAST , in Proceedings of the 36th International Colloquium, on Automata, Languages and Programming (ICALP), vol. 5555 of Lecture Notes in Computer Science, Springer, 2009, pp. 49–58.
- 2[2] N. Alon, R. Yuster, and U. Zwick , Color-coding , J. Assoc. Comput. Mach., 42 (1995), pp. 844–856.
- 3[3] M. Bădoiu, J. Chuzhoy, P. Indyk, and A. Sidiropoulos , Low-distortion embeddings of general metrics into the line , in Proceedings of the 37th Annual ACM Symposium on Theory of Computing (STOC), ACM, 2005, pp. 225–233.
- 4[4] M. Bădoiu, K. Dhamdhere, A. Gupta, Y. Rabinovich, H. Räcke, R. Ravi, and A. Sidiropoulos , Approximation algorithms for low-distortion embeddings into low-dimensional spaces , in Proceedings of the 16th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), ACM and SIAM, 2005, pp. 119–128.
- 5[5] M. Bădoiu, P. Indyk, and A. Sidiropoulos , Approximation algorithms for embedding general metrics into trees , in Proceedings of the 18th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), ACM and SIAM, 2007, pp. 512–521.
- 6[6] A. Becker, R. Bar-Yehuda, and D. Geiger , Randomized algorithms for the loop cutset problem , J. Artif. Intell. Res. (JAIR), 12 (2000), pp. 219–234.
- 7[7] D. Bienstock , Graph searching, path-width, tree-width and related problems (a survey) , in Reliability of computer and communication networks (New Brunswick, NJ, 1989), vol. 5 of DIMACS Ser. Discrete Math. Theoret. Comput. Sci., Amer. Math. Soc., Providence, RI, 1991, pp. 33–49.
- 8[8] I. Bliznets, F. V. Fomin, M. Pilipczuk, and M. Pilipczuk , Subexponential parameterized algorithm for interval completion , in Proceedings of the 27th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), ACM and SIAM, 2016, pp. 1116–1131.
