Chapter 9 Lower bounds based on the Exponential-Time...

Chapter 9

Lower bounds based on theExponential-Time Hypothesis

In the previous chapter we have learnt tools for distinguishing parameterizedproblems that do admit fixed-parameter tractable algorithms from those thatprobably do not. However, as we have seen before, FPT algorithms come witha full variety of running times. On one side we have very e�cient subexpo-nential parameterized algorithms following from bidimensionality (see Sec-

tion 2.6), with a typical running time O⇤(2O(

pk·polylog(k))), and on the other

side lie algorithms derived from Courcelle’s theorem, where the dependencyon the treewidth of the graph cannot be bounded by any q-times exponen-tial function for a constant q. Somewhere in between lie ‘standard’ fixed-parameter tractable problems amenable to other techniques, like branching,color-coding, iterative compression, kernelization, algrabraic tools, represen-tative sets, etc. For these problems the typical running time of an FPT al-gorithm is O⇤(2O(k)), O⇤(2O(k log k)), O⇤(2poly(k)), or doubly-exponential ink. Therefore, it seems that the class FPT has to contain an inner hierarchyof classes, corresponding to respective forms of parameter dependency of therunning times of FPT algorithms. In order to uncover and describe this innerhierarchy we need to develop a methodology for proving lower bounds: Givena particular problem, we need to be able to prove that existence of an FPTalgorithm with a too low function f is implausable. The sole assumptionof FPT 6= W[1] seems too weak to achieve this goal, and therefore we willintroduce stronger complexity assumptions.

The Exponential Time Hypothesis (ETH) is a conjecture stating that,roughly speaking, 3-SAT has no algorithm subexponential in the numberof variables. This conjecture is stronger than the conjecture that FPT 6=W[1], hence it can be also used to give conditional evidence that certainproblems are not fixed-parameter tractable. More importantly, ETH allowsus to prove quantitative results of various forms. For example, we can proveresults saying that (assuming ETH) a problem cannot be solved in time2o(n), or a parameterized problem cannot be solved in time f(k)no(k), or afixed-parameter tractable parameterized problem cannot be solved in time2o(k)nO(1). In many cases, the lower bounds obtained this way match (up

257

258 9 Lower bounds based on the Exponential-Time Hypothesis

to small factors) the best known algorithm, giving a tight understanding ofthe complexity of the problem. In recent years, the field of parameterizedcomplexity has been completely revolutionized by the fact that such tightlower bounds can be proved. Obtaining tight lower bounds seems to be areachable goal for many problems and working towards this goal opens upnew algorithmic questions to explore. A variant of ETH, called the StrongExponential Time Hypothesis (SETH) can be used to give even more refinedlower bounds saying, e.g., that a parameterized problem cannot be solved intime (2 � ")knO(1) for any " > 1.

9.1 The Exponential-Time Hypothesis

9.1.1 Motivation and basic results

The starting point of our considerations will be hardness of the CNF-SATproblem. Recall that in the CNF-SAT problem we are given a propositionalformula ' on n boolean variables x

1

, x2

, . . . , xn that is in conjuntive normalform (CNF). This means that ' = C

1

^ C2

^ . . . ^ Cm, where Ci-s, calledclauses, are of the form Ci = ì

1

_ ì1

_ . . . _ ìri

for lij-s being literals, that is,appearances of some variable in a negated or non-negated form. The questionis whether there exists an assignment of true/false values to the variables sothat ' becomes true. By restricting the number of variables appearing ineach clause to some constant q we arrive at the q-SAT problem.

Since for q � 3 the q-SAT is NP-complete, we do not expect it to be solv-able in polynomial time. Our current knowledge, however, is very far from thisunattainable goal. Obviously, the general CNF-SAT problem can be solvedin O⇤(2n) time by trying all possible true/false assignments. Apparently, wedo not know any algorithm that is substantially faster than this brute-forcesolution. Some improvement is possible, however, when the length of clausesis restricted: for every q � 3, there exists �q = 1 � ⇥( 1

q ) and an algorithm

resolving q-SAT in time O⇤(2�qn). For the most studied case of q = 3, thecurrent champion achieves �

3

= 0.386.

The current status of research on satisfiability problems suggests thatthe following two natural barriers are hard to break:

1. Obtaining a subexponential algorithm for 3-SAT, i.e., one with run-ning time 2o(n).

2. Finding an algorithm for the general CNF-SAT problem with run-ning time O⇤((2 � ")n) for any " > 0.

9.1 The Exponential-Time Hypothesis 259

These two barriers motivate the complexity assumptions that we will in-troduce in a moment. For q � 3, let �q be the infimum of the set of constantsc for which there exists an algorithm solving q-SAT in time O⇤(2cn). In thisdefinition we allow only deterministic algorithms; we will discuss random-ized analogues in the sequel. The Exponential-Time Hypothesis and StrongExponential-Time Hypothesis are then defined as follows.

Conjecture 9.1 (Exponential-Time Hypothesis, ETH).

�3

> 0

Conjecture 9.2 (Strong Exponential-Time Hypothesis, SETH).

limq!1 �q = 1

Intuitively, ETH states that any algorithm for 3-SAT needs search throughan exponential number of alternatives, while SETH states that as q grows toinfinity, then brute-force check of all possible assignments becomes more andmore inevitable. As we will see later, ETH actually implies that FPT 6= W[1],which supports the intuition that we are introducing strogner assumptionsin order to obtained sharper estimates of the complexity of parameterizedproblems.

Looking back at the motivating barriers, note that ETH implies that 3-SAT cannot be solved in 2o(n) time, while SETH implies that CNF-SATcannot be solved in O⇤((2 � ")n) time for any " > 0. However, the converseimplications are unclear. It appears that these (possibly slightly stronger)statements of ETH and SETH are much more robust when it comes to in-ferring their corollaries via reductions. As we will see later, SETH actuallyimplies ETH; see Theorem 9.5.

Let us briefly discuss the possibility of definining the randomized versionsof ETH and SETH. Here, we modify the definition of �q by allowing alsorandomized two-sided error algorithms; let �?q �q be the modified constantfor q-SAT. Then randomized ETH and randomized SETH state that �?

3

> 0and limq!1 �?q = 1, respectively. Clearly, randomized ETH and SETH areat least as strong assumptions as their deterministic analogues. In principle,whenever existence of a deterministic algorithm with some running time canbe excluded under deterministic ETH, the same chain of reductions usuallyshows that a randomized algorithm with the same running time is excludedunder randomized ETH.

Allowing randomization in the definitions of ETH and SETH seems rea-sonable from the point of view of the research on satisfiability: the vast ma-jority of fast algorithms for q-SAT are inherently randomized, including thecurrently fastest O⇤(20.386n) algorithm for 3-SAT. On the other hand, frompragmatic point of view tugging the awkward assumption of allowing ran-domization via multiple reductions would result in much more technical and


obfuscated proofs. Therefore, we decided to use the deterministic versions ofETH and SETH as our main assumptions, and the reader is asked to verifythe steps where randomization creates technical di�culties in Exercises 9.1and 9.4. Henceforth, whenever we are referring to an algorithm, we mean adeterministic algorithm.

Before we proceed, let us remark that while ETH is generally considereda plausible complexity assumption, SETH is regarded by many as a quitedoubtful working hypothesis that can be refuted any time. For this reason,lower bounds proven under the assumption of SETH should not be regardedas supported by very strong arguments, but rather that existence of bet-ter algorithms would constitute a major breakthrough in the complexity ofsatisfiability.

The Exponential-Time Hypothesis is most often used in combination withthe following result, called the Sparsification Lemma.

Theorem 9.3 (Sparsification Lemma, [126]). For all " > 0 and positiveq, there is a constant C = C(", q) such that any q-CNF formula ' with nvariables can be expressed as ' =

Wti=1

i, where t 2"n and each i isa q-CNF formula with the same variable set as ' and at most Cn clauses.Moreover, this disjunction can be computed by an algorithm running in timeO⇤(2"n).

Since the proof of the Sparsification Lemma is not necessary to understandthe remainder of this chapter, we omit it in this book and refer for instanceto the book of TODO for a comprehensible exposition.

Before we proceed, let us elaborate on what the Sparsification Lemmaactually says. An arbitrary instance of q-SAT can have up to O(nq) distinctclauses. Thus, the actual size of a typical instance of q-SAT is far larger thann; as we will see in the next chapter, this size cannot be non-trivially shrunkin polynomial time under plausible complexity assumptions. SparsificationLemma provides a reduction that sparsifies the given instance of q-SAT sothat its total size is comparable to the size of its variable set. To circumventthe incompressibility problems we allow the reduction to use exponential timeand output a logical OR of exponentially many instances (i.e., it is a one-to-many reduction), yet these exponential functions can be as small as welike.

The motivation of Sparsification Lemma is that most reductions from,say, 3-SAT output instances of the target problem whose sizes depend onthe actual size of the input formula, rather than on the cardinality of itsvariable set. Therefore, by making the size comparable to the variable set wecan prove sharper lower bounds. The following immediate corollary is usuallysu�cient to achieve this goal.

Theorem 9.4. Unless ETH fails, there exists a constant c > 0 such that noalgorithm for 3-SAT can achieve running time O⇤(2c(n+m)). In particular,3-SAT cannot be solved in 2o(n+m) time.


Proof. Assume that for every c > 0 there exists an algorithm Ac that solves3-SAT in O⇤(2c(n+m)) time. We are going to show that for every d > 0 thereexists an algorithm Bd that solves 3-SAT in O⇤(2dn) time, contradictingETH. Fix any d > 0, and let C be the constant given by Theorem 9.3 for" = d/2 and q = 3. Consider an algorithm Bd for the 3-SAT problem thatworks as follows:

1. Apply the algorithm of Theorem 9.3 to the input formula ' and parameter" = d/2.

2. Apply algorithm Ac0 for c0 = d2(C+1)

to each output formula i, andreturn that ' is satisfiable if at least one of i-s is.

The correctness of the algorithm follows directly from Theorem 9.3. By The-orem 9.3, the first step of the algorithm takes O⇤(2

dn

2 ) time, while the second

takes O⇤(2dn

2 · 2d

2(C+1)

·(C+1)n) = O⇤(2dn) time. Hence, the whole algorithmruns in O⇤(2dn) time.

To see another application of the Sparsification Lemma, we will now showthat SETH implies ETH.

Theorem 9.5. If SETH holds, then so does ETH.

Proof. For the sake of contradiction assume that �3

= 0. Hence, for everyc > 0 there exists an algorithm Ac that solves 3-SAT in O⇤(2cn) time. Wewill show that this implies �q = 0 for every q � 3, which contradicts SETH.

Consider the following algorithm for q-SAT. Given the input formula ',first apply the algorithm of Theorem 9.3 for some " > 0, to be determinedlater. This algorithm runs in O⇤(2"n) time and outputs at most 2"n formulas i such that ' is satisfiable if and only if any of i-s is, and each i hasat most C(", q) · n clauses. We now focus on resolving satisfiability of one = i.

Consider the following standard reduction from q-SAT to 3-SAT: as longas there exists some clause C = `

1

_ `2

_ . . . _ `p for some p � 4, add a freshvariable y and replace C with clauses C

1

= `1

_`2

_y and C2

= ¬y_`3

_. . ._`p.Observe that this transformation preserves satisfiability of the formula, andevery original clause of length p > 3 gives raise to p � 3 new variables andp � 2 new clauses in the output formula. Hence, if we apply this reductionto the formula , we obtain an equivalent formula 0 that is in 3-CNF andthat has at most (1 + q · C(", q)) · n variables. If we now apply algorithmA� to 0, for some 0 < � < 1, then we resolve satisfiability of 0 in timeO⇤(2�

0n) for �0 = � · (1 + q · C(", q)). By applying this procedure to eachof the listed formulas i, we resolve satisfiability of ' in O⇤(2�

00n) time for�00 = "+ �0 = "+ � · (1 + q · C(", q)).

Recall that the constant " in Theorem 9.3 can be chosen to be arbitrarilyclose to 0. Since �

3

= 0, then having chosen " > 0 (and thus C(", q)) we canchoose � so that �0 is arbitrarily close to 0. Therefore, " and � can be chosenin such a manner that �00 is arbitrarily close to 0, which implies that �q = 0.


9.1.2 Immediate consequences for classic complexity

The CNF-SAT and 3-SAT problems lie in the very foundations of the theoryof NP-completeness. Problems around satisfiability of propositional formulaswere the first problems whose NP-completeness has been settled, and thestandard approach to prove NP-hardness of a given problem is to try to finda polynomial-time reduction from 3-SAT, or from some problem whose NP-hardness is already known. Thus, 3-SAT is in some sense the ‘mother of allNP-hard problems’, and the current knowledge about NP-completeness canbe viewed as a net of reduction originating precisely at 3-SAT. Therefore,it should not be surprising that by making a stronger assumption about thecomplexity of 3-SAT, we can infer stronger corollaries about all the problemswhich can be reached via polynomial-time reductions from 3-SAT.

Consider, for instance, a problem A that admits a linear reduction from3-SAT, i.e., a polynomial-time algorithm that takes an instance of 3-SATon n variables and m clauses, and outputs an equivalent instance of A whosesize is bounded by O(n + m). Then, if A admitted an algorithm with run-ning time 2o(|x|) for |x| being the input instance, then composing the reduc-tion with such an algorithm would yield an algorithm for 3-SAT runningin 2o(n+m) time, which contradicts ETH by Theorem 9.4. Actually, manyknown reductions for classic problems are in fact linear. Examples includeVertex Cover, Dominating Set, Feedback Vertex Set, 3-Coloringor Hamiltonian Cycle; the reader is asked to verify this fact in Exercise 9.2.As a corollary we infer that none of these problems admits an algorithm run-ning in subexponential time in terms of the instance size. Hence, while all ofthem can be solved in O⇤(2N ) time for graphs on N vertices and M edges,existence of algorithms with running time 2o(N) or even 2o(M) is unlikely.

Theorem 9.6. Let A be any of the following problems: Vertex Cover,Dominating Set, Feedback Vertex Set, 3-Coloring, HamiltonianCycle. Then A admits a linear reduction from 3-SAT. Therefore, unlessETH fails A does not admit an algorithm working in 2o(N+M) time, whereN, M are the cardinalities of the vertex and edge set of the input graph,respectively.

Of course, if the polynomial-time reduction from 3-SAT to the targetproblem A has a di↵erent output size guarantee than linear, then the trans-ferred lower bound on the complexity of A is also di↵erent. The followingbasic observation can be used to transfer lower bounds.

Observation 9.7. Suppose that there is a polynomial-time reduction fromproblem A to problem B that, given an instance x of A, constructs an equiva-lent instance of B having length at most g(|x|) for some non-decreasing func-tion g. Then an O⇤(2o(f(|x|))) time algorithm for B for some non-decreasingfunction f implies an O⇤(2o(f(g(|x|)))) time algorithm for A.


Therefore, in order to exclude an algorithm for a problem B with run-ning time O⇤(2o(f(|x|))), we need to provide a reduction from 3-SAT toB that outputs instances of size O(g(n + m)), where g is the inverseof f .

Let us now make an example of an application of this framework wheref and g are not linear. To this end, we will consider problems on planargraphs such as Planar Vertex Cover, Planar Dominating Set, Pla-nar Feedback Vertex Set, Planar 3-Coloring or Planar Hamilto-nian Cycle. NP-hardness of these problems can be established by the meansof a pivot problem called Planar 3-SAT. For an instance ' of 3-SAT, wecan consider its incidence graph G' defined as follows: the vertex set of G'

contains one vertex per each variable of ' and one vertex per each clause of', and we put an edge between a variable x and a clause C if and only ifx appears in C. In the Planar 3-SAT problem we require that the inputformula of 3-SAT has planar incidence graph. The following theorem, whichwe leave without a proof due to its technicality, provides a lower bound forPlanar 3-SAT.

Theorem 9.8 ([148]). There exists a polynomial-time reduction from 3-SAT to Planar 3-SAT that, for a given instance ' with n variablesand m clauses, outputs an equivalent instance '0 of Planar 3-SAT withO((n + m)2) variables and clauses such that G'0 is planar. Moreover, thereexists an ordering (x

1

, x2

, . . . , xn0) of the variables of '0 such that G'0 re-mains planar even after adding edges x

1

x2

, x2

x3

, . . . , xn0�1

xn0 , xn0x1

. Con-sequently, even on such instances Planar 3-SAT is NP-hard and does notadmit an algorithm working in 2o(

pn+m) time, unless ETH fails.

Roughly speaking, in the proof of Theorem 9.8 one embeds the inputformula arbitrarily on the plane, and then replaces each crossing of edges ofG' by a constant-size crossover gadget that transfers the information via thecrossing without disturbing planarity. Since the number of edges of G' is atmost 3m, the number of crossings is at most 9m2 and thus the bound on thesize of the output formula follows.

The gist of standard NP-hardness reductions for problems like VertexCover, 3-Coloring or Dominating Set is to replace every variable xwith a variable gadget Hx, replace every clause C with a clause gadget HC ,and wire the gadgets to simulate the behaviour of the input instance of 3-SAT using the properties of the target problem. By dint of Theorem 9.8 wecan use the same approach for planar problems as well: with a little bit ofcarefulness, replacing every variable and clause in a planar embedding of G'

with a respective gadget will not disturb planarity. The reader is asked toverify the following theorem in Exercise 9.3.


Theorem 9.9. Let A be any of the following problems: Planar Ver-tex Cover, Planar Dominating Set, Planar Feedback VertexSet, Planar 3-Coloring, Planar Hamiltonian Cycle. There exists apolynomial-time reduction that takes an instance ' of Planar 3-SAT withn variables, m clauses, and satisfying the additional guarantee given by The-orem 9.8, and outputs an equivalent instance of A whose graph has O(n+m)vertices and edges. Consequently, unless ETH fails none of the aforemen-tioned problems admits an algorithm with running time 2o(

pN), where N is

the number of vertices of the input graph.

Note, however, that all the problems considered in Theorem 9.9 can bein fact solved in 2O(

pN) time: this can be easily seen by pipelining the

fact that a planar graph on N vertices has treewidth O(p

N) with a single-exponential dynamic programming routine on a tree decomposition (see Exer-cise TODO). Thus, we have obtained essentially matching upper and lower

bounds on the complexity: achieving 2O(

pN) is possible, and it is hard to

break this barrier.

9.2 ETH and fixed-parameter tractable problems

9.2.1 Immediate consequences for parameterizedcomplexity

Observe that ETH and SETH can be seen as assumptions about the complex-ity of the q-SAT problems equipped with parameterization by the numberof variables n. Sparsification Lemma serves then as a reduction from param-eterization by n to parameterization by n + m, and Theorem 9.4 establishesa lower bound for the latter one. Therefore, if we consider 3-SAT as a sourceof parameterized reductions rather than classic ones, then we can infer lowerbounds on the parameterized complexity of problems, instead of the standardinstance-size complexity.

Suppose, for instance, that a parameterized problem A admits a linearparameterized reduction from 3-SAT: a polynomial-time algorithm that takesan instance of 3-SAT on n variables and m clauses, and outputs an equivalentinstance of A with parameter k bounded by O(n+m). If A admitted an FPTalgorithm with running time O⇤(2o(k)), then we could compose the reductionwith this algorithm and thus solve 3-SAT in 2o(n+m) time, contradictingETH by Theorem 9.4. Note here that we bound only the output parameter,while the whole output instance may have superlinear size.

Again, for many classic FPT problems on general graphs, like VertexCover or Feedback Vertex Set, the known NP-hardness reductions infact yield linear parameterized reductions from 3-SAT. In the case of thesetwo particular problems this is conclusion trivial: we already know from that

9.2 ETH and fixed-parameter tractable problems 265

Vertex Cover and Feedback Vertex Set admit classic linear reductionsfrom 3-SAT, and parameters in meaningful instances are bounded by thecardinality of the vertex set. This shows that both these problems, and anyother that admit linear parameterized reductions from 3-SAT, probably donot admit subexponential parameterized algorithms, that is, FPT algorithmswith running time O⇤(2o(k)).

Similarly as before, we may prove lower bounds for di↵erent forms of FPTrunning time by having di↵erent guarantees on the output parameter. Thisis encapsulated in the following analogue of Observation 9.7.

Observation 9.10. Suppose that there is a polynomial-time parameterizedreduction from problem A to problem B such that if the parameter of aninstance of A is k, then the parameter of the constructed instance of B isat most g(k) for some non-decreasing function g. Then a O⇤(2o(f(k))) timealgorithm for B for some non-decreasing function f implies an O⇤(2o(f(g(k))))algorithm for A.

Therefore, in order to exclude an algorithm for a parameterized problemB with running time O⇤(2o(f(k))), we need to provide a reduction from3-SAT to B that outputs instances with the parameter k bounded byO(g(n + m)), where g is the inverse of f .

Again, to see how this framework works in practice, consider the exam-ples of Planar Vertex Cover, Planar Dominating Set, and PlanarFeedback Vertex Set problems. By composing Theorems 9.8 and 9.9 weobtain NP-hardness reductions for these problems that start with a 3-SATinstance with n variables and m clauses, and output instances of the targetproblem with at most O((n + m)2) vertices. Obviously, we can assume thatthe requested size of vertex cover/dominating set/feedback vertex set in theoutput instance is also bounded by O((n+m)2). Thus, following the notationof Observation 9.10 these reductions can serve as parameterized reductionsfrom 3-SAT for a quadratic function f . The following corollary is immediate.

Theorem 9.11. Let A be any of the following problems: Planar VertexCover, Planar Dominating Set, Planar Feedback Vertex Set.Then A does not admit an FPT algorithm running in O⇤(2O(

pk)) time, unless

ETH fails.

Recall that in Section 2.6 we have given algorithms for all the problemsmentioned in Theorem 9.11 that run in O⇤(2O(

pk)) time, using the technique

of bidimensionality (see Exercises TODO). Therefore, the lower bound ofTheorem 9.11 essentially matches this upper bound. This shows that appear-ance of the square root in the exponent is not just an artifact of the techniqueof bidimensionality, but rather an intrinsic property of the problems’ com-plexity.


9.2.2 Slightly super-exponential parameterizedcomplexity

One class of problems for which we have some understanding of the method-ology of proving sharp lower bounds, are problems solvable in slightly super-exponential parameterized time, i.e., in time O⇤(2O(k log k)) for k being theparameter. Running time of such form appears naturally in the followingsituations:

(i) A seemingly optimal FPT algorithm is a branching procedure thatperforms O(k) guesses, each time choosing among a set of possibili-ties of cardinality kO(1). We have seen examples of such algorithmsin Chapter ??. TODO: synchronize

(ii) The parameter is the treewidth t of a given graph, and the naturaldynamic programming routine has 2O(t log t) states per bag of thetree decomposition, usually formed by partitions of the bag. Anexample of such an algorithm is the one given by Theorem 2.12 forthe Steiner Tree problem

By excluding existence of an O⇤(2o(k log k)) algorithm for the problem underETH, we can support the claim that the obtained slightly super-exponentialupper bound is not just a result of the approach taken, but such runningtime is necessary because of the nature of the problem itself.

We now aim at providing a base set of auxiliary problems that will be help-ful for further reductions. At the end of this section we will see some examplesof how they can be utilized for proving lower bounds for ‘real-life’ parameter-ized problems, say of type (i) or (ii) from the list above. The following problemwill be our ‘canonical’ example where slightly super-exponential running timeis both achievable and optimal under ETH. Intuitively, it reflects a genericsituation with which we are faced when approaching a parameterized problemof type (i).

In the k ⇥ k Clique problem we are given a graph H on a vertex set[k] ⇥ [k]. In other words, the vertex set is formed by a k ⇥ k table, andvertices are of form (i, j) for 1 i, j k. The question is whether thereexists a clique X in H that contains exactly one vertex from each row of thetable, i.e., for each i 2 [k] there is exactly one element of X that has i onthe first coordinate. Note that without loss of generality we may assume thateach row of the table forms an independent set.

Obviously, k ⇥k Clique can be solved in O⇤(kk) time by trying all possi-ble choices of vertices from the consecutive rows. It appears that this runningtime is essentially optimal assuming ETH, which is proven in the followingtheorem. In the proof we will use the fact that the 3-Coloring problem ad-


mits a linear reduction from 3-SAT, and hence does not admit a subexponen-tial algorithm in terms of the instance size, unless ETH fails; see Theorem 9.6and Exercise 9.2.

Theorem 9.12. Unless ETH fails, k⇥k Clique cannot be solved in O⇤(2o(k log k))time.

Proof. We shall present a polynomial-time reduction that takes a graph Gon N vertices, and outputs an instance (H, k) of k ⇥ k Clique such that (i)(H, k) is a yes-instanceif and only if G is 3-colorable, and (ii) k 2 O(N/ log N).Pipelining this reduction with a O⇤(2o(k log k)) algorithm for k ⇥ k Cliquewould yield an algorithm for 3-Coloring working in 2o(N) time, which wouldcontradict ETH by Theorem 9.6.

Let k = d 2Nlog

3

N e. Arbitrarily partition the vertex set of the input graph into

k parts V1

, V2

, . . . , Vk, so that each part Vi has cardinality at most d log

3

N2

e.For every part Vi, list all the possible 3-colorings of G[Vi]; note that there

are at most 3|Vi

| 3dlog

3

N

2

e 3p

N such colorings. If for some part nocoloring has been found, we may conclude that the input instance was a no-instanceand output a trivial no-instanceof, say, 2 ⇥ 2 Clique. Observe alsothat without loss of generality we may assume that 3

pN k, since otherwise

N is bounded by a universal constant and we may solve the input instanceby brute-force.

Copy some of the listed colorings if necessary, so that for each part Vi wehave a list of exactly k 3-colorings. Let ⌘1

i , ⌘2

i , . . . , ⌘ki be the 3-colorings listed

for Vi. For each i 2 [k] and j 2 [k], create a vertex (i, j). For every pair ofvertices (i

1

, j1

) and (i2

, j2

) make them adjacent if and only if i1

6= i2

and⌘j

1

i1

[ ⌘j2

i2

is a valid 3-coloring on G[Vi1

[Vi2

]. This concludes the constructionof the graph H, and of the output instance.

We now argue equivalence of the instances. If ⌘ is a valid 3-coloring of G,then ⌘|V

i

is a valid 3-coloring of G[Vi]. Hence, for each i 2 [k] there existsan index ji 2 [k] such that ⌘j

i

= ⌘|Vi

. By the construction it follows thatvertices (i, ji) for i 2 [k] form a k-clique in H: for each i

1

, i2

2 [k], i1

6= i2

,

we have that ⌘ji

1

i1

[ ⌘ji

2

i2

is equal to ⌘|Vi

1

[Vi

2

, and hence is a valid 3-coloringof G[Vi

1

[ Vi2

].Conversely, assume that a set {(i, ji) | i 2 [k]} induces a k-clique in H.

We claim that ⌘ =S

i2[k]

⌘ji

i is a valid 3-coloring of G. Take any uv 2 E(G);we prove that ⌘(u) 6= ⌘(v). If u, v 2 Vi for some i 2 [k], then we have⌘(u) 6= ⌘(v) since ⌘j

i

i = ⌘|Vi

was a valid 3-coloring of G[Vi]. Suppose thenthat u 2 Vi

1

and v 2 Vi2

for i1

6= i2

. Since (i1

, ji1

) and (i2

, ji2

) are adjacent

in H, we have that ⌘ji

1

i1

[ ⌘ji

2

i2

is a valid 3-coloring of G[Vi1

[ Vi2

], and hence

⌘(u) = ⌘ji

1

i1

(u) 6= ⌘ji

2

i2

(v) = ⌘(v).

In the k⇥k Clique problem the constraint is that each row of the table hasto contain one vertex of the clique. It is natural to ask about the more robustversion of this problem, where we additionally require that each column of the


table also needs to contain one vertex of the clique, or, equivalently, that thevertices of the clique must induce a permutation of [k]. We call this problemk ⇥ k Permutation Clique. The following theorem provides a randomizedlower bound for this version.

Theorem 9.13. Assume there exists an algorithm solving k ⇥ k Permuta-tion Clique in O⇤(2o(k log k)) time. Then there exists a randomized algo-rithm solving k ⇥ k Clique in O⇤(2o(k log k)) time. The algorithm can haveonly false negatives, that is, on a no-instanceit always gives a negative an-swer, whereas on a yes-instanceit gives a positive answer with probability atleast 1

2

.

Proof. Suppose that we are given an algorithm for k ⇥ k PermutationClique that works in O⇤(2o(k log k)) time. We are going to present a random-ized algorithm for k ⇥ k Clique with the stated specification.

Let (H, k) be the input instance of k ⇥ k Clique. Consider the followingalgorithm: for each row i of the table, uniformly and independently at randompick a permutation ⇡i of [k], and permute the vertices of this row according to⇡i keeping the original adjacencies. Let H 0 be the obtained graph. Apply thesupposed algorithm for k ⇥k Permutation Clique to the instance (H 0, k);if this algorithm has found a solution to (H 0, k), then return a positive answer,and otherwise provide a negative answer.

Let ⇡ =S

i2[k]

⇡i be the permutation of [k] ⇥ [k] that defines the graphH 0. Obviously, if a solution X 0 in the instance (H 0, k) of k⇥k PermutationClique has been found, then in particular ⇡�1(X 0) is a solution to the inputinstance (H, k) of k⇥k Clique. Therefore, if the algorithm returns a positiveanswer, then it is always correct. Assume now that the input instance (H, k)admits some solution X; we would like to show that with high probabilitythe shu✏ed instance (H 0, k) admits a clique that induces a permutation of[k]. Let X 0 = ⇡(X). Obviously X 0 is still a clique in H 0 and it contains onevertex from each row; we claim that with high probability it also containsone vertex from each column.

Let fX and fX0 be functions from [k] to [k] such that (i, fX(i)) 2 Xand (i, fX0(i)) 2 X 0 for each i 2 [k]. We have that fX0 = fX � ⇡ and weneed to provide a lower bound on the probability that fX0 is a permutation.However, by the choice of ⇡ for every index i 2 [k] the value of ⇡(fX(i)) ischosen uniformly and independently at random among the elements of [k].Hence, every function from [k][k] is equally probable as fX0 . Since there arek! permutations of [k], and kk functions in [k][k] in total, we infer that

Pr (fX0 is a permutation) =k!

kk� e�O(k);

the latter inequality follows from standard Stirling approximation. Hence,with probability at least e�O(k) the instance (H 0, k) will be a yes-instanceofk ⇥ k Permutation Clique, and the algorithm will provide a positive an-swer.


Using the standard technique of independent runs, we repeat the algorithmeO(k) times in order to improve the error probability from 1 � e�O(k) to 1

2

.

Note that thus the whole procedure runs in time eO(k) · O⇤(2o(k log k)) =O⇤(2o(k log k)).

The presented proof of Theorem 9.13 gives a randomized Turing reductionfrom k ⇥ k Clique to k ⇥ k Permutation Clique. It is therefore easy tosee that existence of an O⇤(2o(k log k)) algorithm for k ⇥ k PermutationClique can be refuted under the stronger assumption of randomized ETH;the reader is asked to verify this fact in Exercise 9.4. However, since thereduction of Theorem 9.13 is randomized, we cannot a priori state the samelower bound under deterministic ETH. Fortunately, the construction can bederandomized using hashing families, and thus we may obtain a deterministicTuring reduction. Hence, we have in fact the following lower bound; we omitits proof due to technicality.

Theorem 9.14 ([151]). Unless ETH fails, k ⇥ k Permutation Cliquecannot be solved in O⇤(2o(k log k)) time.

Let us now define the k ⇥ k Hitting Set problem: we are given a familyF of subsets of [k] ⇥ [k], and we would like to find a set X, consisting ofone vertex from each row, such that X \ F 6= ; for each F 2 F . Again, inthe permutation variant we again ask for X that induces a permutation of[k]. Hardness for k ⇥ k (Permutation) Hitting Set follows from an easyreduction from k ⇥ k (Permutation) Clique.

Theorem 9.15. Unless ETH fails, k ⇥ k (Permutation) Hitting Setcannot be solved in O⇤(2o(k log k)) time.

Proof. Let (H, k) be an instance of k⇥k (Permutation) Clique. Constructan instance (F , k) of k⇥k (Permutation) Hitting Set as follows: for eachpair of non-adjacent vertices (i

1

, j1

) and (i2

, j2

) where i1

6= i2

, introduce aset F 2 F that comprises all pairs in rows i

1

and i2

apart from pairs (i1

, j1

)and (i

2

, j2

). Thus, any set X that contains one vertex from each row has anon-empty intersection with F if and only if both pairs (i

1

, j1

) and (i2

, j2

)are not included in X simultaneously. It follows that any such X is a solutionto the instance (F , k) of k ⇥ k (Permutation) Hitting Set if and only ifit is a solution to the instance (H, k) of k ⇥ k (Permutation) Clique, andso the instances (H, k) and (F , k) are equivalent. The theorem follows froman application of Theorems 9.12 and 9.14.

It turns out that for further reductions it is most convenient to have onemore assumption about the k ⇥ k (Permutation) Hitting Set problem.We namely say that an instance (F , k) of one of these problems uses onlythin sets if each F 2 F contains at most one vertex from each row. Note thatthe instance obtained in the reduction of Theorem 9.15 does not have thisproperty; however, hardness can be also obtained under this assumption.


Theorem 9.16 ([151]). Unless ETH fails, k ⇥ k (Permutation) HittingSet with thin sets cannot be solved in O⇤(2o(k log k)) time.

The proof of Theorem 9.16 is a chain of three technical reductions, andwe give it as Exercises 9.5, 9.6 and 9.7.

As already mentioned in the beginning of this section, the presented prob-lems form a convenient base for further reductions. We now provide one suchexample. The problem of our interest will be the Closest String problem:We are given a finite alphabet ⌃, a set of strings {x

1

, x2

, . . . , xn} over ⌃,each of length L, and an integer d. The question is whether there exists onestring y 2 ⌃L such that xi and y di↵er on at most L positions, for each i.The Closest String problem can be solved in O⇤(dd) and O⇤(|⌃|d) time;see Exercise TODO. We can now show that both these running times areessentially optimal.

Theorem 9.17. Unless ETH fails, Closest String cannot be solved inO⇤(2o(d log d)) nor O⇤(2o(d log |⌃|)) time.

Proof. We provide a polynomial-time algorithm that takes an instance (F , k)of k ⇥ k Permutation Hitting Set with thin sets, and outputs anequivalent instance (⌃, d, {x

1

, x2

, . . . , xn}) of Closest String with L = k,d = k�1 and |⌃| = k+1. If there existed an algorithm for Closest Stringwith running time O⇤(2o(d log d)) or O⇤(2o(d log |⌃|)), then pipelining the re-duction with this algorithm would give an algorithm for k⇥k PermutationHitting Set with thin sets with running time O⇤(2o(k log k)), contradict-ing ETH by Theorem 9.16.

Let ⌃ = [k][{�} for some additional symbol � that the reader may viewas ‘mismatch’. First, introduce k strings x

1

, x2

, . . . , xk such that xi = ik, i.e.,symbol i repeated k times. Then, for every F 2 F introduce a string zF

constructed as follows. For each i 2 [k], if F contains some pair (i, ji) in rowi, then put ji on the i-th position of zF . Otherwise, if no such pair exists,put � on the i-th position of zF . Note that this definition is valid due to allthe sets being thin. Finally, we set d = k � 1 and conclude the construction.

We now formally argue that instances (F , k) and (⌃, k � 1, {xi : i 2 [k]} [{zF : F 2 F}) are equivalent. Assume first that X is a solution to the instance(F , k). For each i 2 [k], let ji 2 [k] be such an index that (i, ji) 2 X.Construct a string y by putting ji on the i-th position of y for each i 2 [k].Note that since X induces a permutation of [k], then for every j 2 [k] thereexists i 2 [k] such that j = ji, and so y and xj di↵er on at most k�1 positions.Moreover, since X \F is non-empty for each set F 2 F , then y coincides withzF on at least one position, so it di↵ers on at most k � 1 positions. Hence yis a solution to the constructed instance of Closest String.

Conversely, take any solution y to output instance of Closest String.For each j we have that xj and y di↵er on at most k � 1 positions, so theycoincide on at least one. Therefore y needs to contain every j 2 [k] at leastonce. Since |y| = k, then we infer that y contains every j 2 [k] exactly once,


and it does not contain any �. Let X = {(i, y[i]) : i 2 [k]}. We already knowthat X ✓ [k] ⇥ [k] and that X induces a permutation of [k]. We are leftwith proving that X has a non-empty intersection with every F 2 F . Weknow that y and zF coincide on at least one position, say i. As y does notcontain any �, we have that zF [i] = y[i] = ji for some ji 2 [k]. Consequently(i, ji) 2 X and (i, ji) 2 F by the definitions of X and zF , so X \ F 6= ;.

Recall that another class of problems where the complexity of the formO⇤(2O(k log k)) appears naturally, are treewidth parameterizations where thenatural space of states of the dynamic programming routine is formed bypartitions of the bag. In Chapter 2 we have presented one such dynamic pro-gram running in O⇤(2O(t log t)) time, for the Steiner Tree problem. Whilein Chapter 5 we have seen that Steiner Tree can be solved faster, inO⇤(2O(t)) time, for some other problems the presented framework can beused to show that the running time of O⇤(2O(t log t)) is essentially optimal.The next theorem, which we leave without a proof, provides some examples.

Theorem 9.18 ([151]). Unless ETH fails, the following problems cannot besolved in time O⇤(2o(p log p)) for p being the width of a given path decomposi-tion of the graph: Cycle Packing, Vertex Disjoint Paths.

Note that Theorem 9.18 is stated in terms of a path decomposition andnot tree decomposition, which makes the lower bound stronger.

The idea behind the proof of Theorem 9.18 is to reduce from k ⇥ k (Per-mutation) Hitting Set with thin sets and try to embed the search spaceof this problem, which has size roughly kk, into the states of the standarddynamic program working on a path decomposition. We create a graph whichhas a long path decomposition of width O(k) and using problem-dependantcombinatorics we make sure that the choice the solution makes on the firstbag (for instance, a choice of a matching for the Cycle Packing problem)is propagated along the decomposition to all the other bags. This propagatedchoice has to reflect the intended solution of the input k⇥k (Permutation)Hitting Set with thin sets instance. Then we attach multiple gadgetsalong the path decomposition, one for every set to be hit. Each gadget shouldhave O(k) pathwidth, and its role is to verify that the propagated solutionfrom the first bag indeed hits the corresponding set. Thus, all the gadgets aresatisfied if and only if the chosen and propagated solution hits all the sets. Wewill look more closely on reductions of this type in Section 9.4.2, where wediscuss optimality of bounded-treewidth dynamic programming under SETH.

In essence, the outcoming message is that the nature of problems ex-emplified by those mentioned in Theorem 9.18 makes it necessary tohave 2⌦(t log t) states per bag of the decomposition. The space of statescannot be pruned substantially, since each state is, roughly speaking,meaningful on its own.


TODO: make sure that these problems were defined earlier

9.2.3 Doubly exponential parameterized complexity

Recall that in Chapter ?? we have considered the Edge Clique Coverproblem: given a graph G and integer k, verify whether G contains k sub-graphs C

1

, C2

, . . . , Ck such that each Ci is complete andSk

i=1

E(Ci) = E(G).Already very simple reduction rules yield a kernel for Edge Clique Cover

with at most 2k vertices, and the problem can be solved in O⇤(22

O(k)

) timeby performing Set Cover-like dynamic programming on the edge set of thekernel TODO: ref. In the light of our lower bound methodology, it is naturalto ask whether such running time is optimal under ETH. This appears to bethe case.

Theorem 9.19 ([63]). There exists a polynomial-time algorithm that, givena 3-SAT instance ' on n variables and m clauses, constructs an equivalentEdge Clique Cover instance (G, k) with k = O(log n) and |V (G)| = O(n+

m). Consequently, Edge Clique Cover cannot be solved in O⇤(22

o(k)

) timeunless ETH fails.

The proof of Theorem 9.19 is a technical reduction that we omit in thisbook. Again, Theorem 9.19 shows that, despite the simplicity of the kernel-ization approach, nothing substantially better can be achieved. The reasonfor this lies not in the naivety of the technique, but in the problem itself.

9.3 ETH and W[1]-hard problems

In Sections 8.1–8.3, we have seen techniques for giving evidence that a prob-lem is not fixed-parameter tractable, that is, the parameter k has to appearin the exponent of the running time. But we have not explored the questionhow exactly the exponent has to depend on k for a W[1]-hard problem: for allwe know, it is possible that a W[1]-hard problem has a 2O(k) · nO(log log log k)

time algorithm, which would be “morally equivalent” to the problem beingFPT. In Section 9.2, we have seen how ETH can be used to classify FPTproblems by giving (often tight) lower bounds on the function f(k) appear-ing in the running time. It turns out that ETH also allows us to prove (oftentight) lower bounds on how the exponent of the running time needs to de-pend on k. The first such lower bound result we present is for Clique (or,equivalently, for Independent Set).

Theorem 9.20. Assuming ETH, there is no f(k)no(k) time algorithm forClique or Independent Set for any computable function f .

9.3 ETH and W[1]-hard problems 273

Proof. We will show that if there is an f(k)no(k) time algorithm for Cliquefor some computable function f , then ETH fails. Suppose that Clique onevery graph H can be solved in time f(k)|V (H)|k/s(k), where s(k) is a non-decreasing unbounded function. We use this algorithm to solve 3-Coloringon an n-vertex graph G in time 2o(n); by Theorem 9.6, this contradicts ETH.The reduction is similar to the proof of Theorem 9.12, but instead of split-ting the vertices into k = O(n/ log n) groups, the number k of groups nowdepends on the functon f(k).

We split the vertices in the 3-Coloring instance into roughly f�1(n)groups, where f�1 is the inverse of f (e.g., if f(k) = 2⇥(k), thenf�1(k) = ⇥(log n)). We create a Clique instance where each vertexrepresents a 3-coloring of one of the groups. The created graph H hassize at most k · 3n/k = k · 3n/f�1

(n) = 2o(n). We can observe that therunning time of the assumed f(k)|V (H)|o(k) time algorithm for Cliqueon H is 2o(n): we have f(k) = f(f�1(n)) = n and |V (H)|o(k) is roughly(3n/k)o(k) = 2o(k).

Determining the number k of groups we need requires some care; onereason is that we have no assumption on the time needed to compute f(k),besides that it is computable. We may assume that the computable functionf satisfies f(k) � k for every k � 1 (e.g., by replacing it with f 0(k) =max{f(k), k} if necessary). Let us start computing the values f(k) for k =1, 2, . . . ; we stop this computation when either a k with f(k) > i is reached orthe computation takes more than n steps. Let k be the last value for whichwe computed f(k) and we have f(k) n (we may assume that f(1) nand we can compute f(1) in n steps, otherwise n is bounded by a universalconstant). The value k selected this way is a function of n only, that is, wehave computed the value k = g(n) for some computable function g(n). Notethat the function g is nondecreasing (by definition), g is unbounded (as f(k)is unbounded), g(n) k (as f(k) � k), and f(g(n)) n (by definition).

Split the vertices of G into k groups V1

, . . . , Vk of size at most dn/ke each.Let us build a graph H where each vertex corresponds to a proper 3-coloringof one of the groups. The number of vertices in H is at most

|V (H)| k · 3dn/ke k · 32(n/k) = k · 32(n/g(n)) = 2o(n)

(we used that k = g(n) n in the first inequality and the fact that g(n) isnondecreasing and unbounded in the last equality). We connect two verticesof H if they are not conflicting. That is, if u represents a coloring of G[Vi]and v represents a coloring of G[Vj ] for some i 6= j, then u and v are adjacentonly if the union of the colorings corresponding to u and v is a valid coloringof G[Vi [Vj ]. It is easy to verify that a k-clique of H corresponds to a proper3-coloring of G and one can construct the coloring in time polynomial in the


size of H, that is, in time 2o(n). Therefore, using the assumed algorithm forClique, a 3-coloring of G can be found in time

f(k)|V (H)|k/s(k) n(3dn/ke)k/s(k) n(32n/k)k/s(k) = n32n/s(g(n)) = 2o(n)

(we have used f(k) = f(g(n)) n in the first inequality, k = g(n) n inthe second inequality and the fact that s(g(n)) is monotone and unboundedin the last equality). ut

In particular, Theorem 9.20 shows that, assuming ETH, Clique is notFPT. Therefore, Theorem 9.20 shows that ETH implies that FPT 6= W[1].

Having established a tight lower bound for Clique, we can easily transferit to other problems with parameterized reductions. As in Observation 9.10,the strength of the lower bound on the target problem depends on the boundon the new parameter in the reduction.

Observation 9.21. Suppose that there is a polynomial-time parameterizedreduction from problem A to problem B such that if the parameter of aninstance of A is k, then the parameter of the constructed instance of B is atmost g(k) for some non-decreasing function g. Then an f(k) · no(h(k)) timealgorithm for B for some computable function f and non-decreasing functionh implies an f(g(k)) · no(h(g(k))) algorithm for A.

Therefore, in order to exclude an algorithm for a parameterized problemB with running time f(k) ·no(h(k)) for some computable function f , weneed to provide a reduction from Clique to B that outputs instanceswith the parameter k bounded by O(g(k)), where g is the inverse of h.

Observing that most of the parameterized reductions in Chapter 8 have linearparameter dependence, we can obtain tight lower bounds for a number ofproblems.

Corollary 9.22. Assuming ETH, there is no f(k)no(k) time algorithm forthe following problems for any computable function f :

• Clique on regular graphs,• Independent Set on regular graphs,• Multicolored Clique on regular graphs,• Multicolored Independent Set on regular graphs,• Dominating Set,• Dominating Set on Tournaments,• Connected Dominating Set,• Balanced Vertex Separator parameterized by the size k of the solu-

tion,• List Coloring parameterized by the treewidth k.


Let us point out the surprising fact that we have the same lower bound herefor Dominating Set and Dominating Set on Tournaments (exponentof n cannot be o(k)), despite the significant di↵erence in complexity for theunparameterized versions: only 2⌦(n) time algorithms are known for Domi-nating Set, while Dominating Set on Tournaments can be solved intime nO(log n). From the viewpoint of Observation 9.21, all that matters isthat the reduction of Theorem 8.14 has the property that the new parameteris linear in the original parameter. The double-exponential dependence on kin the running time of the reduction does not a↵ect the quality of the lowerbound obtained in terms of the exponent of n.

There are W[1]-hard problems for which it seems hard to obtain tight lowerbounds using a parameterized reduction from Clique and Observation 9.21;we need new technology to make the lower bounds tighter for these prob-lems. Consider, for example, the Odd Set problem. In Theorem 8.31, wehave presented a parameterized reduction from Multicolored Clique toOdd Set. A crucial idea of the reduction was to represent both the verticesand the edges of the k-clique in the Odd Set instance, and this was thereason why the parameter of the constructed instance was k +

�k2

�

= O(k2).

Therefore, Observation 9.21 with g(k) = O(k2) and h(k) =p

k implies that,

assuming ETH, there is no f(k)no(

pk) time algorithm for Odd Set for any

computable function f . The naive algorithm solves the problem in time nO(k)

by brute force, giving a significant gap between the upper and lower bound.The quadratic blow up in the parameter seems to be unavoidable: as we havediscussed in Section 8.2, it is unlikely that we can reduce Clique to OddSet by representing only the vertices of the k-clique, and representing the�k2

�

edges of the k-clique inevitably leads to a quadratic blow up.A key idea of making these reductions from Clique tighter is to interpret

them as reductions from Subgraph Isomorphism instead. In the SubgraphIsomorphism problem, we are given two graphs H and G; the task is to de-cide if H is isomorphic to a (not necessarily induced) subgraph of G. Param-eterized reductions from Clique where vertices and edges are represented bygadgets (e.g, Theorem 8.31) can be usually generalized to reductions fromSubgraph Isomorphism with minimal modifications. As finding a k-cliqueis a special case of Subgraph Isomorphism, Theorem 9.20 implies that,assuming ETH, there is no f(k)no(

pk) time algorithm for Subgraph Iso-

morphism for any computable function f , where k is the number of verticesof the smaller graph H. The following result, whose proof is beyond the scopeof this chapter, gives a lower bound parameterized by the number of edges ofH:

Theorem 9.23 ([160]). Assuming ETH, there is no f(k)no(k/ log k) time al-gorithm for Subgraph Isomorphism, where k is the number of edges of thesmaller graph H and f is a computable function.

We remark that it is an interesting open question if the factor log k in theexponent can be removed, making this result tight. We can modify the re-


duction of Theorem 8.31 to be a reduction from Subgraph Isomorphism toOdd Set, where the new parameter is linear in the number of edges of thesmaller graph H (Exercise 9.10). Then Theorem 9.23 and Observation 9.21give a tighter lower bound, almost matching the trivial nO(k) time algorithm.

Theorem 9.24. Assuming ETH, there is no f(k)no(k/ log k) time algorithmfor Odd Set.

Similarly, one can modify the reduction in the proof of Theorem 8.33 toget tighter lower bounds for Strongly Connected Steiner Subgraph(Exercise 9.11).

Theorem 9.25. Assuming ETH, there is no f(k)no(k/ log k) time algorithmfor Strongly Connected Steiner Subgraph.

Closest Substring (a generalization of Closest String) is an extremeexample where reductions increase the parameter exponentially or even dou-ble exponentially, and therefore we obtain very weak lower bounds. In thisproblem, the input consists of strings s

1

, . . . , st over an alphabet ⌃, integersL and d. The task is to find a string s of length L such that si has a sub-string s0i of length L with d(s, si) d for every 1 i t. Here d(s, si) is theHamming-distance of the two strings, that is, the number of positions wherethey di↵er.

Let us restrict our attention to the case where the alphabet is of constantsize, say binary. There is a (very involved) reduction from Clique (with kbeing the size of the clique we are looking for) to Closest Substring. where

d = 2O(k) and t = 22

O(k)

in the constructed instance. Therefore, we get weaklower bounds with only o(log d) and o(log log t) in the exponent. Interestingly,these lower bounds are actually tight, as there are algorithms matching thesebounds.

Theorem 9.26 ([158]). Closest Substring over an alphabet of constantsize can be solved in time f(d)nO(log d) or in time f(d, t)nO(log log t). Further-more, assuming ETH, there are no algorithms for the problem with runningtime f(t, d)no(log d) or f(t, d)no(log log t) for any computable function f .

9.3.1 Planar and geometric problems

We have seen in earlier chapters that many parameterized problems are fixed-parameter tractable when restricted to planar graphs. There are powerfultechniques available for attacking planar problems, for example, the shift-ing strategy (Section 2.6.2) or bidimensionality (Section 2.6.3). Nevertheless,there exist natural parameterized problems that are W[1]-hard on planargraphs. In this section, we develop a convenient technology for proving the


S1,1:

(1,1)(3,1)(2,4)

S1,2:

(5,1)(1,4)(5,3)

S1,3:

(1,1)(2,4)(3,3)

S2,1:

(2,2)(1,4)

S2,2:

(3,1)(1,2)

S2,3:

(2,2)(2,3)

S3,1:

(1,3)(2,3)(3,3)

S3,2:

(1,1)(1,3)

S3,3:

(2,3)(5,3)

Fig. 9.1: An instance of Grid Tiling with k = 3 and n = 5. The red pairsform a solution.

W[1]-hardness of these problems. Moreover, assuming ETH, this technology

allows us to prove that there is no f(k) · no(

pk) algorithm for the problem

for any computable function f . This is very often matched by a correspond-ing algorithm, giving us tight understanding of the complexity of a planarproblem.

The key tool of the section is the following (somewhat artificial) problem,which will be a convenient starting point for reductions to planar problems.The input of Grid Tiling is an integer k, an integer n, and a collection Sof k2 nonempty sets Si,j ✓ [n] ⇥ [n] (1 i, j k). The task is to find, foreach 1 i, j k, a pair si,j 2 Si,j such that

• If si,j = (a, b) and si+1,j = (a0, b0), then a = a0.• If si,j = (a, b) and si,j+1

= (a0, b0), then b = b0.

In other words, if (i, j) and (i0, j0) are adjacent in the first or second coordi-nate, then si,j and si0,j0 agree in the first or second coordinate, respectively.An instance of Grid Tiling with a solution is shown in Figure 9.1: we imag-ine Si,j to be in row i and column j of a matrix. Observe that the constraintsensure that the first coordinate of the solution is the same in each column andthe second coordinate is the same in each row. We can prove the hardness ofGrid Tiling by a simple reduction from Clique.

Theorem 9.27. Grid Tiling is W[1]-hard and, unless ETH fails, it has nof(k)no(k) time algorithm for any computable function f .

Proof. The proof is by reduction from Clique. Let (G, k) be an instanceClique. Let n = |V (G)|; we assume that the vertices of G are the integers


in [n]. We construct an instance of Grid Tiling as follows. For every 1 i, j k, we define

Si,j =

(

{(a, a) | 1 a n} if i = j,

{(a, b) | vertices a and b are adjacent in G} if i 6= j.

We claim that the constructed instance of Grid Tiling has a solution ifand only if G contains a k-clique. First, suppose that vertices v

1

, . . . , vk aredistinct and form a clique in G. Then it is easy to verify that si,j = (vj , vi)(note that the order of i and j is swapped in the indices1) is a solution of GridTiling. Conversely, suppose that the pairs si,j (1 i, j k) form a solution.As si,j and si+1,j agree in the first coordinate and si,j and si,j+1

agree inthe second coordinate, it follows that there are values v

1

, . . . , vk, v01

, . . . , v0ksuch that si,j = (vj , v0i) for every 1 i, j k. As Si,i = {(a, a) | 1 a n},this is only possible if vi = v0i for every 1 i k. It follows that vi and vj

are two adjacent (distinct) vertices: as (vj , vi) = (vj , v0i) 2 Si,j , the definitionof Si,j implies that {vi, vj} is an edge of G. Therefore, v

1

, . . . , vk is indeed ak-clique in G. ut

There are two aspects of Grid Tiling that make it particularly suitedfor reducing it to planar problems:

1. If the sets are represented by gadgets, then each gadget has tointeract only with the gadgets representing adjacent sets, makingthe high-level structure of the constructed instance planar.

2. The constraint that needs to be enforced on adjacent gadgets isfairly simple: equality of the first/second coordinate of the value.

The following reduction demonstrates the first aspect of Grid Tiling. InSection 8.6, we have shown, by a reduction from Multicolored Clique,that List Coloring is W[1]-hard parameterized by treewidth. Furthermore,in Section 9.3, we have observed that the reduction actually shows that ithas no f(w)no(w) time algorithm for any computable function f , unless ETHfails. As the reduction in Theorem 8.30 was from Multicolored Clique,the created instance is highly non-planar (see Figure 8.4), being essentially asubdivided clique. On the other hand, when we reduce from Grid Tiling,the resulting graph is grid-like, and hence planar.

Theorem 9.28. List Coloring on planar graphs parameterized by thetreewidth w is W[1]-hard and, unless ETH fails, it has no f(w)no(w) timealgorithm for any computable function f .

1 We could have defined Grid Tiling by swapping the meaning of the coordinates of si,j ,that is, si,j and si,j+1

have to agree in the first coordinate. Then we would have avoidedthe unnatural swap of indices in this proof. However, as we shall see, in many proofs (e.g.,Theorems 9.31 and 9.33), the current definition is much more convenient.


u1,1 u

1,n

un,1 un,n

h1,1,.,.

v1,1,.,.

Fig. 9.2: The graph G0 of the List Coloring instance constructed in thereduction of Theorem 9.28 for k = 4.

Proof. We present a parameterized reduction from Grid Tiling. Let (n, k, S)be an instance of of Grid Tiling. The set C of colors will correspond to[n] ⇥ [n]; then every set Si,j can be interpreted as a set of colors. We con-struct a graph G0 the following way (see Figure 9.2).

(i) For every 1 i, j k, we introduce a vertex ui,j with L(ui) = Si,j .(ii) For every 1 i < k, 1 j k and for every pair (a, b), (a0, b0) 2

[n] ⇥ [n] with a 6= a0, we introduce a vertex vi,j,(a,b),(a0,b0) whose list is{(a, b), (a0, b0)} and make it adjacent to ui,j and ui+1,j .

(iii) For every 1 i k, 1 j < k and for every pair (a, b), (a0, b0) 2[n] ⇥ [n] with b 6= b0, we introduce a vertex hi,j,(a,b),(a0,b0) whose list is{(a, b), (a0, b0)} and make it adjacent to ui,j and ui,j+1

.

To bound the treewidth of G0, observe that every vertex other than thevertices ui,j has degree 2. Suppressing degree-2 vertices of G0 does not changeits treewidth (reference?) (assuming its treewidth is at least 3) and gives ak ⇥ k-grid with parallel edges, which has treewidth k + 1.

Suppose that si,j 2 Si,j is a solution for the Grid Tiling instance; letsi,j = (ai,j , bi,j). We can construct the following list coloring of G0. First,we set the color of ui,j to si,j 2 Si,j = L(ui,j). Then for every vertexvi,j,(a,b),(a0,b0), it is true that either ui,j has a color di↵erent from (a, b), orui+1,j has a color di↵erent from (a0, b0) (as ai,j = ai+1,j , while a 6= a0). There-fore, one of the two colors appearing in the list of vi,j,(a,b),(a0,b0) is not used onits neighbors, hence we can extend the coloring to this vertex. The argumentis similar for the vertices hi,j,(a,b),(a0,b0).

For the reverse direction, suppose that c : V (G0) ! V (G) is a list coloringof G0. We claim that the pairs si,j = c(ui,j) 2 L(ui,j) = Si,j form a solutionfor the Grid Tiling instance. For a contradiction, suppose that si,j = (a, b)


and si+1,j = (a0, b0) do not agree in the first coordinate, that is, a 6= a0. Thenthe vertex vi,j,(a,b),(a0,b0) exists in G with list {(a, b), (a0, b0)}. However, thisvertex is adjacent to both ui,j and ui+1,j , which have colors (a, b) and (a0, b0)i n the coloring, hence hence vi,j,(a,b),(a0,b0) cannot have either color on its list,a contradiction. The argument is similar in the case when si,j and si,j+1

donot agree in the second coordinate; in this case, we arrive to a contradictionby observing that both colors in the list vertex hi,j,(a,b),(a0,b0) are already usedby its neighbors. ut

The second reason why Grid Tiling is a useful starting point for reduc-tions to planar problems is that the constraints between adjacent gadgets arevery simple: it requires that the first/second coordinates of the values of theto gadgets are equal. This can be much simpler than testing adjacency of twovertices in a reduction from Multicolored Clique and is similar to theprojection constraint between edge gadgets and vertex gadgets (see Theo-rem 8.31). In Theorem 9.28, the List Coloring problem was very powerfuland it was easy to express arbitrary binary relations, hence this aspect ofGrid Tiling was not exploited.

There are reduction, however, where it does matter that the constraintsbetween the gadgets are simple. We introduce a variant of Grid Tilingwhere the constraints are even more suited for planar problems. The input ofGrid Tiling with is the same at the input of Grid Tiling, but we haveless than or equal constraints between the first/second coordinates instead ofequality (see Figure 9.3). That is, the task is to find, for each 1 i, j k, avalue si,j 2 Si,j such that

• If si,j = (a, b) and si+1,j = (a0, b0), then a a0.• If si,j = (a, b) and si,j+1

= (a0, b0), then b b0.

This variant of Grid Tiling is very convenient when we want to provelower bounds for a problem involving planar/geometric objects or distancesbetween points: the constraints have natural interpretations in such prob-lems.

We show first that the lower bounds of Theorem 9.27 hold for Grid Tilingwith as well.

Theorem 9.29. Grid Tiling with is W[1]-hard and, unless ETH fails,it has no f(k)no(k) time algorithm for any computable function f .

Proof. Given an instance (n, k, S) of Grid Tiling, we construct an equiva-lent instance (n0, k0, S 0) of Grid Tiling with with n0 = 3n2(k+1)+n2+1and k0 = 4k. For every set Si,j of the input instance, there are 16 correspond-ing sets S0

i0,j0 (4i � 3 i0 4i, 4j � 3 j0 4j) in the constructed instance(see Figure 9.4). We call these sets the gadget representing Si,j. The 4 innersets S

4i�2,4j�2

, S4i�2,4j�1

, S4i�1,4j�2

, S4i�1,4j�1

are dummy sets containingonly the single pair shown in the figure. The 12 outer sets are defined asfollows. We define the mapping ◆(a, b) = na + b and let N = 3n2. For every


S1,1:

(1,1)(3,1)(2,4)

S1,2:

(5,1)(1,4)(5,3)

S1,3:

(1,1)(2,5)(3,3)

S2,1:

(2,2)(1,4)

S2,2:

(3,1)(2,2)

S2,3:

(3,2)(2,3)

S3,1:

(1,3)(2,3)(3,3)

S3,2:

(1,1)(2,3)

S3,3:

(5,4)(3,4)

Fig. 9.3: An instance of Grid Tiling with with k = 3 and n = 5. Thered pairs form a solution.

(a, b) 2 Si,j , we let z = ◆(a, b) and introduce the pairs shown in Figure 9.4 intothe 12 outer sets. It can be easily verified that both coordinates of each pairare positive and at most n0. This concludes the description of the constructedinstance.

The intuition behind the construction is the following. Selecting a pairfrom one of the 12 outer sets in a gadget selects a pair of Si,j . We showthat in every solution, a “vortex” on the 12 outer sets ensures that eachof them select the same pair si,j 2 Si,j . Then we show that the inter-action of the outer sets of the gadgets enforce exactly the constraintsof the Grid Tiling problem. For example, the second set of the lastrow of the gadget representing Si,j and the second set of the first row ofthe gadget representing Si+1,j interact in a way that ensures that thefirst coordinate of si,j is at most the first coordinate of si+1,j , while thethird sets of these rows ensure the reverse inequality, implying that thetwo first coordinates are equal.

Let si,j 2 Si,j for 1 i, j k be a solution of the Grid Tiling instance.For every si,j = (a, b), we select the corresponding pairs from the 16 sets inthe gadget of Si,j , as shown in Figure 9.4. First, it is easy to verify that theconstraints are satisfied between the sets of the same gadget. Consider nowthe last row of the gadget of Si,j and the first row of the gadget of Si+1,j . Forthe first sets in these rows, the constraints are satisfied: the pair selected fromS0

4i,4j�3

has first coordinate at most iN + n2 + 1 < (i + 1)N , while the pairselected from S0

4(i+1)�3,4j�3

= S04i+1,4j�3

is at least (i+1)N . Similarly, thereis not conflict between the last sets of these rows. If ai,j ai+1,j are the first


S04i�3,4j�3

:

(iN � z, jN + z)

S04i�3,4j�2

:

(iN + a, jN + z)

S04i�3,4j�1

:

(iN � a, jN + z)

S04i�3,4j :

(iN + z, jN + z)

S04i�2,4j�3

:

(iN � z, jN + b)

S04i�2,4j�2

:

((i + 1)N, (j + 1)N)

S04i�2,4j�2

:

(iN, (j + 1)N)

S04i�2,4j :

(iN + z, (j + 1)N + b)

S04i�1,4j�3

:

(iN � z, jN � b)

S04i�1,4j�2

:

((i + 1)N, jN)

S04i�1,4j�2

:

(iN, jN)

S04i�1,4j :

(iN + z, (j + 1)N � b)

S04i,4j�3

:

(iN � z, jN � z)

S04i,4j�2

:

((i+1)N +a, jN � z)

S04i,4j�1

:

((i+1)N �a, jN � z)

S04i,4j :

(iN + z, jN � z)

Fig. 9.4: The 16 sets of the constructed Grid Tiling with instance rep-resenting a set Si,j of the Grid Tiling in the reduction in the proof ofTheorem 9.29, together with the pairs corresponding to a pair (a, b) 2 S0

i,j

(with z = ◆(a, b)).

coordinates of si,j and si+1,j , then the first coordinates of the sets selectedfrom the second sets of the rows, S0

4i,4j�2

and S04i+4j�2

, are (i + 1)N + ai,j

and (i + 1)N + ai+1,j , respectively, and the former is at most the latter. Onecan show in a similar way that there is no conflict between the third sets ofthe rows, and that there is no conflict between the last column of the gadgetrepresenting Si,j and the first column of the gadget representing Si,j+1

.For the reverse direction, suppose that s0i,j for 1 i, j k0 is solution of

the constructed Grid Tiling with instance. Consider the 12 outer setsin the gadget representing Si,j . The 12 pairs selected in the solution fromthese sets defines 12 values z; let z

4i�3,4j�3

etc. be these 12 values. We claimthat all these 12 values are the same. The first coordinate of the set selected


from S04i�3,4j�3

is iN +z4i�3,4j�3

, the first coordinate of the set selected fromS0

4i�3,4j�2

is iN + z4i�3,4j�2

, hence the definition of Grid Tiling with implies z

4i�3,4j�3

z4i�3,4j�2

. With a similar reasoning, by going aroundthe outer sets, we get the following inequalities.

z4i�3,4j�3

z4i�3,4j�2

z4i�3,4j�1

z4i�3,4j (first row)

z4i�3,4j z

4i�2,4j z4i�1,4j z

4i,4j (last column)

�z4i,4j�3

�z4i,4j�2

�z4i,4j�1

�z4i,4j (last row)

�z4i�3,4j�3

�z4i�2,4j�3

�z4i�1,4j�3

�z4i,4j�3

(first column)

Putting together, we get a cycle of inequalities showing that these 12 valuesare all equal; let zi,j be this common value a let si,j = (ai,j , bi,j) be thecorresponding pair, that is, ◆(ai,j , bi,j) = zi,j . The fact that zi,j was definedusing the pairs appearing in the gadget of Si,j implies that si,j 2 Si,j . Letus show now that ai,j = ai+1,j . The pair selected from S0

4i,4j�2

has firstcoordinate (i + 1)N + ai,j , while the pair selected from S0

4(i+1)�3,4j�2

=

S04i+1,4j�2

has first coordinate (i + 1)N + ai+1,j . The definition of GridTiling with implies now that ai,j ai+1,j holds. Similarly, by comparingthe first coordinates of the pairs selected from S0

4i,4j�1

and S04i+1,4j�1

shows�ai,j �ai+1,j , hence ai,j = ai+1,j follows. A similar argument, by lookingat the last column of the gadget representing Si,j and the first column of thegadget representing Si,j+1

shows bi,j = bi,j+1

. Therefore, we have proved thatthe constructed si,j ’s indeed form a solution of the Grid Tiling instance.

utScattered Set is a generalization of Independent Set: given a graph

G and integers k and d, the task is to find a set S of k vertices in G such thatthe distance of any two distinct u, v 2 S is at least d. Clearly, IndependentSet is the special case d = 2, hence there is no f(k)no(k) time algorithmfor Scattered Set on general graphs, unless ETH fails (Corollary 9.22).On planar graphs, we have seen that the special case Independent Set isFPT (parameterized by k) and has subexponential parameterized algorithms.Moreover, we can show that Scattered Set remains FPT on planar graphsfor any fixed d, or with combined parameters k and d (Exercise 2.76). If d ispart of the input, we can do somewhat better than finding a solution by anO(k) time brute force algorithm.

Theorem 9.30 ([162]). Scattered Set on planar graphs can be solved in

time nO(

pk).

We show now that the algorithm of Theorem 9.30 is optimal with respectto the dependence of the exponent on k.

Theorem 9.31. Scattered Set is W[1]-hard and, unless ETH fails, it has

no f(k)no(

pk) time algorithm for any computable function f .


R1,1

v1,11,1 v1,1

1,5

v1,15,5v1,1

5,1

R1,3

R3,3R

3,1

↵1,1

�1,1

�1,1

�1,1

Fig. 9.5: Theorem 9.31: reducing the instance of Grid Tiling with inFigure 9.3 with k = 3 and n = 5 to an instance of Scattered Set. Thered edges represent paths of length L, the circled vertices correspond to thesolution shown in red in Figure 9.3.

Proof. We present a parameterized reduction from Grid Tiling. Let (n, k, S)be an instance of Grid Tiling. We represent each Si,j with an n⇥n grid Ri,j ;

let vi,ja,b be the vertex of this grid in row a and column b. Let L = 100n and

d = 3L + n + 2. We construct a graph G0 the following way (see Figure 9.5).

(i) For every 1 i, j k and (a, b) 2 Si,j , we introduce a vertex wi,ja,b and

connect it to vertex vi,ja,b with a path of length L.

(ii) For every 1 i k, 1 j < k, we introduce two new vertices ↵i,j , �i,j ,

connect ↵i,j to vi,ja,n for every a 2 [n], connect �i,j to vi,j+1

a,1 for everya 2 [n], and connect ↵i,j and �i,j with a path of length L.

(iii) For every 1 i < k, 1 j k, we introduce two new vertices �i,j ,

�i,j , connect �i,j to vi,jn,b for every b 2 [n], connect �i,j to vi+1,j

1,b for everyb 2 [n], and connect �i,j and �i,j with a path of length L.


We may assume that the solution selects exactly one vertex wi,ja,b from

each grid Ri,j . The locations of these vertices correspond to a solutionof the Grid Tiling with instance. The distance constraint of Scat-tered Set ensures that the row number of the selected vertex in Ri,j

is at most the row number of the selected vertex in Ri+1,j , and thecolumn number of the selected vertex in Ri,j is at most the columnnumber of the selected vertex in Ri,j+1

.

Suppose that si,j 2 Si,j is a solution for the Grid Tiling instance; let

si,j = (ai,j , bi,j). For every 1 i, j k, let Z contain zi,j = wi,jai,j

,bi,j

.We claim that vertices in Z are at distance at least d from each other. If|i� i0|+ |j � j0| � 2, then every path between zi,j and zi0,j0 has to go throughat least 4 paths of length L, hence their distance is at least 4L > d. Considernow the vertices zi,j and zi+1,j . If a path P connecting these two vertices haslength less than 4L, then P has to go through �i,j and �i,j . The distance ofzi,j and �i,j is L+n�ai,j+1 and the distance of zi+1,j and �i,j is L+ai+1,j+1.Thus the distance of zi,j and zi+1,j is 3L+n+2+(ai+1,j�ai,j) � 3L+n+2 = d,since si,j and si+1,j satisfy the constraint that the first coordinate of si,j is atmost the first coordinate of si+1,j . A similar argument (using that the secondcoordinate of si,j is at most the second coordinate of si,j+1

) shows that thedistance of zi,j and zi,j+1

is at least d. Therefore, the distance of any twovertices in Z is at least d.

For the reverse direction, suppose that Z is a set of k2 vertices with pair-wise distance at least d. Let Xi,j be the set of all vertices that are at dis-tance at most L + n + 2 < d/2 from Ri,j . Observe that the distance ofany two vertices in Xi,j is less than d, hence Xi,j can contain at most onevertex of Z. Furthermore, observe that the union of the Xi,j ’s cover the en-tire graph. Therefore, each of the k2 vertices of Z appear in at least oneof these sets, which is only possible if each Xi,j contains exactly one ver-tex of Z and each vertex of Z appears in only one Xi,j . In particular, thismeans that the vertices of G contained in more than one Xi,j cannot bepart of the solution Z. Consider a vertex of Xi,j that is not in any other setXi0,j0 (and hence can be a candidate for being in the solution). This vertex

has to be on some vi,jai,j

,bi,j

� wi,jai,j

,bi,j

path for some (ai,j , bi,j) 2 Si,j , oth-erwise it would be too close to an adjacent grid. We may actually assumethat this vertex is the degree-1 vertex wi,j

ai,j

,bi,j

at the end of the path: mov-ing the vertex closer to the end of the path does not make it any closer tothe other vertices of Z. Let us define zi,j = wi,j

ai,j

,bi,j

and si,j = (ai,j , bi,j);we claim that the pairs si,j form a solution for the Grid Tiling instance.First, si,j = (ai,j , bi,j) 2 Si,j follows from the way the graph is defined. Tosee that ai,j ai+1,j , let us compute the distance between zi,j and zi+1,j .

The distance of zi,j = wi,jai,j

,bi,j

and �i,j is L + n � ai,j + 1, the distance of

zi+1,j = wi+1,jai+1,j

,bi+1,j

and �i,j is L + ai+1,j + 1, hence the distance of zi,j and


zi+1,j is 3L+n+2+(ai+1,j �ai,j) = d+(ai+1,j �ai,j). As we know that thisdistance is at most d, the inequality ai,j ai+1,j follows. By a similar argu-ment, computing the distance of zi,j and zi,j+1

shows that bi,j bi,j+1

holds.Thus the pairs si,j indeed form a solution of the Grid Tiling instance. ut

We finish this section with a geometric problem. Given a set of disks ofunit diameter in the plane (described by the coordinates of their centers)and an integer k, Unit Disk Independent Set asks for a subset S of kdisks that are pairwise disjoint. In other words, we need to select k centerssuch that any two of them are at distance at least 1 from each other. It ispossible to solve the problem more e�ciently than the nO(k) time brute forcealgorithm.

Theorem 9.32 ([3]). Unit Disk Independent Set can be solved in time

nO(

pk).

We show that the exponent O(p

k) in Theorem 9.32 is best possible by areduction from Grid Tiling with . In the proof, we face a minor notationaldi�culty. When defining the Grid Tiling problem, we imagined the sets Si,j

arranged in a matrix, with Si,j being in row i and column j. When reducingGrid Tiling to a geometric problem, the natural idea is to represent Si,j

with a gadget located around coordinate (i, j). However, this introduces anunnatural 90 degrees rotation compared to the layout of the Si,j ’s in thematrix, which can be confusing in the presentation of a reduction. Therefore,we slightly change the notation for Grid Tiling: we assume that the setsare denoted S[x, y] ✓ [n] ⇥ [n] (0 x, y k � 1) and we have to selecta pair s[x, y] from S[x, y]. The constraints are the same as before: if (x, y)and (x0, y0) are adjacent in the first or second coordinate, then the first andsecond coordinates of s[x, y] and s[x0, y0] have to agree, respectively. That is,

• If s[x, y] = (a, b) and s[x + 1, y] = (a0, b0), then a = a0.• If s[x, y] = (a, b) and s[x, y + 1] = (a0, b0), then b = b0.

Grid Tiling with can be defined similarly with a a0 and b b0. Withthis definition, we can give a very clean and transparent reduction to UnitDisk Independent Set.

Theorem 9.33. Unit Disk Independent Set is W[1]-hard and, unless

ETH fails, it has no f(k)no(

pk) time algorithm for any computable function

f .

Proof. It will be convenient to work with open disks of diameter 1

2

(that is,radius 1) in this proof: then two disks are nonintersecting if and only if thedistance of their centers is at least 1. The proof is by reduction from GridTiling with . Let I = (n, k, S) be an instance of Grid Tiling with .We construct a set D of unit disks such that D contains a set of k2 pairwisenonintersecting disks if and only if I is a yes-instance.


S[0, 2]:

(1,1)(2,5)(3,3)

S[1, 2]:

(3,2)(2,3)

S[2, 2]:

(5,4)(3,4)

S[0, 1]:

(5,1)(1,4)(5,3)

S[1, 1]:

(3,1)(2,2)

S[2, 1]:

(1,1)(2,3)

S[0, 0]:

(1,1)(3,1)(2,4)

S[1, 0]:

(2,2)(1,4)

S[2, 0]:

(1,3)(2,3)(3,3)

Fig. 9.6: An instance of Grid Tiling with with k = 3 and n = 5 and thecorresponding instance of Unit Disk Independent Set constructed in thereduction of Theorem 9.33. The small dots show the potential positions forthe centers, the large dots are the actual centers in the constructed instance.The shaded disks with red centers correspond to the solution of Grid Tilingwith shown on the left.

Let " = 1/n2. For every 0 x, y k � 1 and every (a, b) 2 S[x, y] ✓ [n] ⇥[n], we introduce into D an open disk of diameter 1

2

centered at (x+"a, y+"b);let D[x, y] be the set of these |S[x, y]| disks introduced for a fixed x and y (seeFigure 9.6). Note that the disks in D[x, y] all intersect each other. Therefore,if D0 ✓ D is a set of pairwise nonintersecting disks, then |D0| k2 and|D0| = k2 is possible only if D0 contains exactly one disk from each D[x, y]. Inthe following, we prove that there is such a set of k2 pairwise nonintersectingdisks if and only if I is a yes-instance.

We need the following observation first. Consider two disks centered at(x+ "a, y + "b) and (x+1+ "a0, y + "b0) for some (a, b), (a0, b0) 2 [n]⇥ [n]. Weclaim that they are nonintersecting if and only if a a0. Indeed, if a > a0,then the square of the distance of the two centers is

(1 + "(a0 � a))2 + "2(b0 � b)2 (1 + "(a0 � a))2 + "2n2

(1 � ")2 + " = 1 � "+ "2 < 1

(in the first inequality, we have used a0, a n; in the second inequality, wehave used a � a0 + 1 and " = 1/n2). On the other hand, if a a0, then thesquare of the distance is at least (1 + "(a0 � a))2 � 1, hence the two disks donot intersect (recall that the disks are open). This proves our claim. A similarclaim shows that disks centered at (x+"a, y+"b) and (x+"a0, y+1+"b0) in arenonintersecting if and only if b b0. Moreover, it is easy to see that the disks


centered at (x + "a, y + "b) and (x0 + "a0, y0 + "b0) for some 1 a, a0, b, b0 ncannot intersect if |x � x0| + |y � y0| � 2: the square of the distance of thetwo centers is at least 2(1 � "n)2 > 1.

Let the pairs s[x, y] 2 S[x, y] form a solution of instance I; let s[x, y] =(a[x, y], b[x, y]). For every 0 x, y k � 1, we select the disk d[x, y] centeredat (x+"a[x, y], y+"b[x, y]) 2 D[x, y]. As we have seen, if |x�x0|+ |y�y0| � 2,then d[x, y] and d[x0, y0] cannot intersect. As the s[x, y]’s form a solution ofinstance I, we have that a[x, y] a[x + 1, y]. Therefore, by our claim inthe previous paragraph, the disks d[x, y] and d[x + 1, y] do not intersect.Similarly, we have b[x, y] b[x, y +1], implying that d[x, y] and d[x, y +1] donot intersect either. Hence there is indeed a set of k2 pairwise nonintersectingdisks in D.

Conversely, let D0 ✓ D be a set of k2 pairwise independent disks. This isonly possible if for every 0 x, y k � 1, set D0 contains a disk d[x, y] 2D[x, y], that is, centered at (x+"a[x, y], j+"b[x, y]) for some (a[x, y], b[x, y]) 2[n] ⇥ [n]. We claim that the pairs s[x, y] = (a[x, y], b[x, y]) form a solution ofinstance I. First, d[x, y] 2 D[x, y] implies that s[x, y] 2 S[x, y]. As we haveseen above, the fact that d[x, y] and d[x + 1, y] do not intersect implies thata[x, y] a[x + 1, y]. Similarly, the fact that d[x, y] and d[x, y + 1] do notintersect each other implies that b[x, y] b[x, y + 1]. Thus the s[x, y]’s forma solution for the Grid Tiling with instance I. ut

9.4 Lower bounds based on the StrongExponential-Time Hypothesis

In essence, ETH enables us to estimate the optimal magnitude of the para-metric dependency of the running time of parameterized algorithms. SETH isa more precise tool, using which one can pinpoint almost exactly the asymp-totic behaviour of the optimal running time, at a cost of adopting a muchstronger complexity assumption. For instance, suppose we are working witha parameterized problem admitting an O⇤(3k) algorithm. A typical lowerbound under ETH is of the form ‘No algorithm with running time O⇤(2o(k))can be expected’. Under SETH one can prove statements like ‘For any " > 0,no algorithm with running time O⇤((3 � ")k) can be expected’, thus showingthat even the constant 3 in the base of the exponent is hard to improve.

Observe that for any constant c, saying that there exists an algorithm withrunning time O⇤((c � ")k) for some " > 0 is equivalent to saying that thereexists an algorithm with running time O⇤(c�k) for some � < 1. While the firstnotation gives more intuitive feeling about what the lower bound actuallymeans, the second is more convenient when it comes to formal proofs. Wewill hence use both notations, jumping between them implicitly.

Lower bounds under SETH can be proved by providing reductions fromvariants of CNF-SAT, similarly as for ETH. However, they are typically

9.4 Lower bounds based on the Strong Exponential-Time Hypothesis 289

much more delicate. For ETH we are usually interested only in the asymp-totics of how the parameter is transformed — it is relevant whether theoutput parameter is linear or quadratic in the input one, but the preciseleading coe�cient of the linear function does not play any role. For SETH itis precisely this coe�cient that is crucial. To see it on an example, say thatwe provide two reductions from CNF-SAT to some parameterized problemL, where in the first reduction the output parameter k is equal to 2n (forn being the number of variables), and in the second reduction the outputparameter is equal to n. Then the first reduction shows only that, for any" > 0, no O⇤((

p2 � ")k) algorithm can be expected assuming SETH, while

the second one improves this lower bound to nonexistence of an O⇤((2� ")k)algorithm.

Interestingly, observe that in the presented example we could state thelower bound under a slightly weaker assumption that the general CNF-SATproblem cannot be solved in O⇤((2�")n) time for some " > 0. This is a com-mon phenomenon in many lower bounds under SETH, where the reductioncan be assumed to start from general CNF-SAT, rather than from q-SATfor increasing, yet constant values of q. However, there are examples whereit is helpful to use the full power of SETH; we will see one such lower boundalready in the next section.

9.4.1 Hitting Set parameterized by the size of theuniverse

Recall that the Hitting Set problem can be solved by a brute force search intime O⇤(2n), where n is the size of the universe. It is natural to ask whetherthe constant 2 in the base of the exponent could be improved, or in otherwords, whether one can search through significantly less than 2n possiblecandidates for the solution. It appears that this is not the case under theassumption of SETH — the barrier of brute-force 2n enumeration is hard tobreak.

The first natural idea for a reduction from CNF-SAT would be the fol-lowing. Create two elements of the universe tx, fx per each variable x, andadd a set containing this pair to the constructed family. Set budget for thesize of the hitting set to be equal to n, so that in each of these two-elementsets exactly one of the elements must be chosen. Choosing tx correspondsto setting the variable to true, and choosing fx corresponds to setting it tofalse, so we have one-to-one correspondence between assignments of the vari-ables and candidate solutions. Now satisfaction of clauses can be encodeddirectly as hitting sets: for instance for a clause x _ ¬y _ z we will create aset {tx, fy, tz}, which is hit if and only if the clause is satisfied.

Unfortunately, this reduction gives only an O⇤((p

2 � ")n) lower bound,since the universe in the output instance is of size 2n. The problem is about


redundancy: if we know that some tx is chosen to the solution, then we aresure that fx is not chosen, and thus we did not exploit the whole 22n searchspace of the output instance, but rather a subspace of cardinality 2n. Wehence need a smarter way of packing the information.

Suppose that the reduction we are going to construct will create a universeU of size n0, which is slightly larger than n; for now think that n0 = n +O(log n). Suppose further that k is the intended size of the hitting set. Nowobserve that k must be very close to n0/2 for the following reason. If k <0.49 · n0 or k > 0.51 · n0 for some n0, then the solution might be found bybrute force verification of all the sets of

� U<0.49n0

�

or� U>0.51·n0

�

, and thereare only O((2 � ")n) such sets for some " > 0. Therefore, the intuition isthat the 2n search space of CNF-SAT has to be embedded roughly into� Un0/2

�

; since�

�

�

� Un0/2

�

�

�

�

= O⇣

2

n

0p

n0

⌘

by Stirling approximation, the additional

additive O(log n) factor in n0 should be su�cient to ensure enough space toaccomodate all possible variable assignments.

It seems, however, challenging to implement such an embedding so that theclauses can be also conveniently checked. Now is the point when it becomesuseful to start with q-SAT instead of general CNF-SAT. Let us arbitrarilypartition the variable set into large, but constant-size groups. Let p be thesize of the group. Each group X will have a corresponding part of the universeUX of size p0 = p + O(log p), and the space of assignments of variables of X

will be embedded roughly into� U 0

p0/2

�

, which has size� p0

p0/2

�

> 2p. Thus we

have n0 = p0

p · n, and when p grows to infinity then n0 becomes bounded by

(1+↵) ·n, for any ↵ > 0. Finally, providing that we start with q-SAT insteadof general CNF-SAT, every clause touches at most q groups of size p each,and hence it can be modelled using a constant (yet exponential in q and p)number of sets in the family.

We now proceed to a formal explanation.

Theorem 9.34. Unless SETH fails, there is no algorithm for Hitting Setthat achieves running time O⇤((2 � ")n) for any " > 0, where n is the size ofthe universe.

Proof. We shall present a reduction that for any constants ↵ > 0 and q � 3,takes an instance of q-SAT on n variables and transforms it in polynomialtime into an equivalent instance of Hitting Set on a universe of size at most(1 +↵) · n. We note that in this reduction we will treat q and ↵ as constants,and thus both the size of the family of the output Hitting Set instance,and the running time of the reduction can depend exponentially on q and1/↵.

We first verify that existence of such a reduction will provide us the claimedlower bound. For the sake of contradiction, assume that Hitting Set indeedcan be solved in O⇤(2�n) time for some constant � < 1. Fix some ↵ > 0so that �0 := � · (1 + ↵) < 1. Assuming ETH, there exists a constant qsuch that �q > �0, i.e., q-SAT cannot be solved in O⇤(2�

0n) time. Consider


now the following algorithm for q-SAT: apply the presented reduction forparameters ↵ and q, and then solve the resulting instance of Hitting Setusing the assumed faster algorithm. Thus we could solve q-SAT in timeO⇤(2�·(1+↵)·n) = O⇤(2�

0n), which contradicts our choice of q.We now proceed to the reduction itself. Let ' be the input instance of

q-SAT, let Vars be the variable set of ', let Cls be the clause set of ',and let n = |Vars|, m = |Cls|. We fix some odd constant p � 3 such thatp + 2dlog

2

pe (1 + ↵/3) · p. Let p0 = p + 2dlog2

pe; note that p0 is also odd.Without loss of generality we will assume that n is divisible by p. This canbe achieved by adding at most p � 1 dummy variables not appearing in anyclause, which increases the size of the variable set by multiplicative factor atmost 1 + ↵/3, unless the input instance is of constant size and we may solveit by brute-force.

Partition Vars into n/p groups of variables Vars1

,Vars2

, . . . ,Varsn/p,each of size p. For each group Varsi we create a set of elements Ui of size p0.Let A#

i =� U

i

p

0�1

2

�

and A"i =

� Ui

p

0+1

2

�

. Note that |A#i | = |A"

i | � 2

p

0

1+p0 � p2

1+p0 · 2p.

It can be readily checked that for p � 3 it holds that p2 � 1 + p0, so |A#i | =

|A"i | � 2p. Therefore, let us fix an arbitrary injective mapping ⌘i from the set

Vars

{?,>}i of all the true/false assignments of the variables of Varsi to the

set A#i . Let Bi = A#

i \ Im(⌘i), where Im(⌘i) denotes the image of ⌘i.Take any clause C 2 Cls and let Varsj

C,1

,VarsjC,2

, . . . ,VarsjC,r

C

be allthe variable groups that contain any variable appearing in C. Since C has atmost q literals, we have that rC q. Hence the set VarsC :=

SrC

t=1

VarsjC,t

has cardinality at most p0 · q, which is a constant. Now consider all thetrue/false assignments of the variables of VarsC , and let ZC be the set ofthose assignments for which the clause C is not satisfied. For each ⇣ 2 ZC

construct a set FC⇣ by taking

FC⇣ =

rC

[

t=1

⌘jC,t

(⇣|Vars

j

C,t

).

Now we construct the universe of the output Hitting Set instance by takingU =

Sn/pi=1

Ui, while the family F is defined as follows:

F =

n/p[

i=1

(A"i [ Bi) [ �

FC⇣ : C 2 Cls, ⇣ 2 ZC

.

Finally, we set budget k = n/p · p0+1

2

and output the instance (U, F , k) ofHitting Set. Note that |U | (1 + ↵/3) · n, which together with the pre-liminary blow-up of the universe size due to introducing dummy variables,gives a total increase of the universe size by a multiplicative factor at most(1 + ↵/3)2 1 + ↵.


We now argue equivalence of the instances. Assume first that ' admits asatisfying assignment : Vars ! {?, >}. Construct a set X by taking

X =

n/p[

i=1

Ui \ ⌘i( |Vars

i

),

and observe that |X| = k. We claim that X is a solution to the HittingSet instance (U, F , k). For any i 2 [n/p] and any F 2 A"

i we have that

|F | = |X \Ui| = p0+1

2

and |Ui| = p0, so X \F must be non-empty. Moreover,we have that Ui \ X 2 Im(⌘i) by the definition of X, so X \ F 6= ; for anyF 2 Bi.

Now consider any C 2 Cls and any ⇣ 2 ZC . Since C is satisfied by theassignment , there exists a variable x that belongs to some group Varsj

C,t

and whose literal satisfies C. Let j = jC,t. Since ⇣ does not satisfy C, wein particular have that |

Vars

j

6= ⇣|Vars

j

. Hence FC⇣ \ Uj = ⌘j(⇣|Vars

j

) 6=⌘j( |

Vars

j

) = Uj \ X. Since |X \ Uj | = p0+1

2

, |FC⇣ \ Uj | = p0�1

2

, |Uj | = p0 and

FC⇣ \ Uj 6= Uj \ X, we have that FC

⇣ \ X \ Uj 6= ; and we are done with thefirst implication.

Conversely, assume that there exists a set X ✓ U , |X| k, that has a

non-empty intersection with every set of F . First observe that |X\Ui| � p0+1

2

for each i 2 [n/p], since otherwise |Ui \ X| � p0+1

2

and X would not hit any

subset of Ui \ X of size p0+1

2

, but A"i ✓ F . Since |X| k = n/p · p0

+1

2

and

sets X \ Ui are pairwise disjoint, we infer that |X| = k and |X \ Ui| = p0+1

2

for each i 2 [n/p]. Moreover, since X \ F 6= ; for each F 2 Bi, we inferthat Ui \X 2 Im(⌘i). For each i let us construct an assignment i : Varsi !{?, >} by taking i = ⌘�1

i (Ui\X). We claim that =Sn/p

i=1

i is a satisfyingassignment for '.

Take any clause C 2 Cls, and assume for the sake of contradiction that does not satisfy C. Let ⇣ = |

Vars

C

, then we have that ⇣ 2 ZC by thedefinition of ZC . Since X was a solution, we have that X \ FC

⇣ 6= ;; hence

X \ FC⇣ \ Uj 6= ; for some j = jC,t. By the definition of FC

⇣ we have that

FC⇣ \ Uj = ⌘j(⇣|Vars

j

) = ⌘j( |Vars

j

). On the other hand, by the definition of

we have that Uj \ X = ⌘j( |Vars

j

). Consequently Uj \ X = FC⇣ \ Uj , and

so X \ FC⇣ \ Uj = ;, a contradiction.

Observe that the proof of Theorem 9.34 substantially depends on the factthat the starting point is an instance of q-SAT for a constant q, instead ofarbitrary CNF-SAT. This is used to be able to construct the families ZC :if a clause could be arbitrarily large, then the size of family ZC would beexponential in n, and the reduction would use exponential time. Hence, thelower bound of Theorem 9.34 holds only under the assumption of SETH,and not under the weaker assumption that CNF-SAT cannot be solved inO⇤((2 � ")n) time for any " > 0.


Lower bounds of a similar flavour to Theorem 9.34 can be proven for someother problems; examples include Set Splitting parameterized by the sizeof the universe, or NAE-SAT parameterized by the number of variables.Both these problems do not admit O⇤(2�n) algorithms for any � < 1, unlessSETH fails.

Recall, however, that for the Hitting Set problem we have also anO⇤(2m) algorithm for m being the size of the family, obtained via dynamicprogramming; see also TODO. Equivalently, Set Cover can be solved inO⇤(2n) time, where n is the size of the universe. Is the constant 2 in the baseof the exponent optimal also in this case? Actually, we neither have a fasteralgorithm, nor are able to link non-existence of such to SETH. This motivatesthe following conjecture; q-Set Cover is the Set Cover problem with anadditional assumption that every F 2 F has cardinality at most q.

Conjecture 9.35 (Set Cover Conjecture, [59]). Let �q be the infinimum of theset of constants c such that q-Set Cover can be solved in time O⇤(2cn) ,where n is the size of the universe. Then limq!1 �q = 1. In particular, thereis no algorithm for the general Set Cover problem that runs in O⇤((2�")n)for any " > 0.

It appears that several essentially tight lower bounds for classic parameter-ized problems can be established under the Set Cover Conjecture. Therefore,the question of finding links between SETH and the Set Cover Conjectureseems like a natural research direction.

Theorem 9.36 ([59]). Unless the Set Cover Conjecture fails,

• Steiner Tree cannot be solved in O⇤((2�")k) time for any " > 0, wherek is the target size of the tree;

• Connected Vertex Cover cannot be solved in O⇤((2 � ")k) time forany " > 0, where k is the target size of the solution;

• Subset Sum cannot be solved in O⇤((2 � ")m) time for any " > 0, wherem is the number of bits of the encoding of the target sum t.

9.4.2 Dynamic programming on treewidth

Recall that in Chapter 2 we have learnt how to design dynamic program-ming routines working on a tree decomposition of a graph. For many classicproblem with simple formulations, the straightforward dynamic program hasrunning time O⇤(ct) for some typically small constant c. For instance, for In-dependent Set one can obtain running time O⇤(2t), while for DominatingSet it is O⇤(3t). The intuitive feeling is that this running time should be op-timal, since the natural space of states exactly corresponds to the informationabout a subtree of the tree decomposition that needs to be remembered forfuture computations. In other words, every state is meaningful on its own,


and can lead to an optimal solution at the end. It is natural to ask whetherunder the assumption of SETH we can support this intuition by a formallower bound.

This is indeed the case, and we can use a similar approach as for Theo-rem 9.18 (we sketched the main ideas behind its proof in the discussion afterthe statement). In this section we will discuss in details the case of the In-dependent Set problem parameterized by pathwidth, which turns out notto admit an O⇤((2 � ")p) algorithm for any " > 0, assuming SETH. Beforewe proceed with a formal argumentation, let us discuss the intuition behindthe approach. Note that a lower bound for pathwidth is even stronger thanfor treewidth.

We start the reduction from an arbitrary CNF-SAT instance on n vari-ables and m clauses. The idea is to create a bundle of n very long pathsP

1

, P2

, . . . , Pn of even length, corresponding to variables x1

, x2

, . . . , xn. As-sume for now that on each of these path the solution is allowed to make one oftwo choices: either incorporate into the independent set all the odd-indexedvertices, or all the even-indexed vertices. Then for every clause we construct aclause verification gadget and attach it to some place of the bundle. The gad-get is adjacent to paths corresponding to variables appearing in the clause,and the attachement points reflect whether the variable’s appearence is posi-tive or negative (glance at Figure 9.8 for an idea how this will be technicallycarried out). The role of the clause gadget is to verify whether at least oneof the attachment points is not chosen to the constructed independent set,which corresponds to the clause being satisfied. Fortunately, it is possible toconstruct a gadget with exactly the requested property: the behaviour insidethe gadget can be set optimally if and only if at least one of the attachmentpoints is free, and moreover the gadget has constant pathwidth, so it doesnot increase much the width of the whole construction. See Figure 9.7 andClaim 9.38 for the implementation.

One technical problem that we still need to overcome is the first techni-cal assumption about the choices the solution makes on the paths Pi. It isnamely not true that on a path of even length there are only two maximum-size independent sets, being the odd-indexed vertices and the even-indexedvertices. The solution can first start with picking only odd-indexed vertices,then make a gap of two vertices, and continue further with even-indexed ver-tices. Thus, on each path there can be one ‘cheat’ where the solution flipsfrom odd indices to even indices. The solution to this problem is a remarkablysimple trick that is commonly used in similar reductions. We namely repeatthe whole sequence of clause gadgets n+1 times, which ensures that at mostn copies are spoiled by possible cheats, and hence at least one of the copiesis attached to area where no cheat happens, and hence the behaviour of thesolution on the paths Pi correctly encodes some satisfying assignment of thevariable set.

We now proceed to the formal argumentation.


1

2

3

4

Fig. 9.7: Gadget M4

Theorem 9.37. Suppose there exists a constant " > 0 and an algorithm that,given an integer t and a graph G with its path decomposition of width p, checkswhether G admits an independent set of size t in time O⇤((2 � ")p). ThenCNF-SAT can be solved in O⇤((2� ")n) time, and in particular SETH fails.

Proof. We provide a polynomial-time reduction that takes a CNF-SAT in-stance ' on n variables, and constructs an instance (G, t) of IndependentSet together with a path decomposition of G of width n + O(1). Providedthat the supposed faster algorithm for Independent Set existed, we couldcompose the reduction with this algorithm and solve CNF-SAT in timeO⇤((2 � ")n).

We first make an auxiliary gadget construction that will be useful in the re-duction. Let Mr be the graph depicted on Figure 9.7, consisting of a sequenceof r triangles with each two consecutive connected by two edges, and two pen-dant vertices attached to the first and the last triangle. By

1

,2

, . . . ,r wedenote the degree-2 vertices in the triangles, as shown on Figure 9.7, and wealso denote I = {

1

,2

, . . . ,r}. The following claim, whose proof is left tothe reader as Exercise 9.13, summarizes all the properties of Mr that we willneed.

Claim 9.38. Assume r is even. Then the maximum size of an independentset in Mr is equal to r + 2, and each independent set of this size has anonempty intersection with I. Moreover, for every a = 1, 2, . . . , r there existsan independent set Za in Mr such that |Za| = r + 2 and Za \ I = {a}.Finally, the graph Mr has pathwidth at most 3.

Thus, graph Mr can be thought of as a gadget encoding a single 1-in-rchoice. A similar behaviour could be modelled by taking Mr to be a cliqueon r vertices, but the crucial property is that Mr has constant pathwidth. Inthe reduction we will use multiple copies of Mr for various values of r. For acopy H of Mr, by a(H), Za(H), and I(H) we denote the respective objectsin H.

We now proceed to the construction itself. Let Vars = {x1

, x2

, . . . , xn},Cls = {C

1

, C2

, . . . , Cm} be the variable and the clause set of ', respectively.For C 2 Cls, by |C| we will denote the number of literals appearing inC, and let us enumerate them arbitrary as `C

1

, `C2

, . . . , `C|C|. By duplicating

some literals if necessary we will assume that |C| is even for each C 2 Cls.


P 6P 5P 4P 3P 2P 1

2j

2j

+1

G1

G2

G3

...

Fig. 9.8: Constructions in the proof of Theorem 9.37: connections adjacent toa clause gadget Hj for Cj = x

1

_ ¬x2

_ ¬x4

_ x6

(left), and arranging copiesof G

0

into G (right).

Without loss of generality we assume that no clause of Cls contains twoopposite literals of the same variable, since such clauses are satisfied in everyassignment.

We first construct an auxiliary graph G0

as follows. Introduce n pathsP 1, P 2, . . . , Pn, each having 2m vertices. Let pi

0

, pi1

, . . . , pi2m�1

be the verticesof P i in the order of their appearance. For each clause Cj , construct a graphHj being a copy of M|C

j

|. For every a = 1, 2, . . . , r, let xia

be the variable

appearing in literal `C

j

a . If `C

j

a = xia

then connect a(Hj) with pia

2j , and if

`C

j

a = ¬xia

then connect a(Hj) with pia

2j+1

. This concludes the constructionof the graph G

0

.To construct the output graph G, we create n + 1 copies of the graph

G0

; denote them G1

, G2

, G3

, . . . , Gn+1

. We follow the same convention thatan object from copy Ga, for a = 1, 2, . . . , n + 1, is denoted by putting Ga

in brackets after the object’s name in G0

. Connect the copies sequentiallyas follows: for each a = 1, 2, . . . , n and each i = 1, 2, . . . , n, connect verticespi2m�1

(Ga) and pi0

(Ga+1

). This concludes that construction of graph G. The


following claim, whose proof is left to the reader as Exercise 9.14, verifiesthat G indeed has low pathwidth.

Claim 9.39. G admits a path decomposition of width at most n + 3, whichfurthermore can be computed in polynomial time.

Finally, we set the expected size of the independent set to be t =

(n + 1) ·⇣

mn +Pm

j=1

(|Cj | + 2)⌘

. It now remains to argue that G admits

an independent set of size t if and only if ' is satisfiable.Assume first that ' admits a satisfying assignment : Vars ! {?, >}.

We first construct an independent set X0

of size mn+Pm

j=1

(|Cj |+2) in G0

.

For every i = 1, . . . , n, if (xi) = ? then in X0

we include all vertices pib

with even b, and if (xi) = > then we include all vertices pib with odd b. For

each clause Cj fix an index aj such that the literal `C

j

aj

satisfies Cj in theassignment ; let xi

j

be the variable appearing in this literal. Then includeinto X

0

the independent set Zaj

(Hj) given by Claim 9.38.Clearly |X

0

| = mn+Pm

j=1

(|Cj |+2). We now verify that X0

is independentin G

0

. From the construction it directly follows that the vertices of X lyingon paths P i are pairwise non-adjacent, and also vertices lying in di↵erentgadgets Hj are non-adjacent as well. Vertices of X

0

lying in the same gadgetHj are non-adjacent by Claim 9.38. It remains to verify that no vertex of X

0

belonging to a gadget Hj can see any vertex of X0

lying on any path P i.The only vertices of Hj adjacent to the vertices outside Hj are vertices ofI(Hj), and we have X

0

\I(Hj) = {aj

(Hj)}. The only neighbour of aj

(Hj)

outside Hj is the vertex pij

2j in case `C

j

aj

= xij

, or pij

2j+1

in case `C

j

aj

= ¬xij

.

Since `C

j

aj

satisfies Cj in the assignment , it follows from the definition ofX

0

that precisely this vertex on P ij is not chosen to X

0

. So indeed X0

is anindependent set in G

0

.Let X

1

, X2

, . . . , Xn+1

be the images of X0

in the copies G1

, G2

, . . . , Gn+1

,and let X =

Sn+1

i=1

Xi. Clearly |X| = t, and it follows easily from the con-struction that X is independent: for every edge pi

2m�1

(Ga)pi0

(Ga+1

) con-necting each two consecutive copies, exactly one of the assertions hold:pi2m�1

(Ga) 2 Xa or pi0

(Ga+1

) 2 Xa+1

.

We are left with the converse implication. For i = 1, 2, . . . , n, let P i =G[Sn+1

a=1

V (P i(Ga))]. Observe that P i is a path on (n + 1) · 2m vertices, and

thus the maximum size of an independent set in P i is (n+1)m. Assume thatG admits an independent set X of size t. We then have that |X \ V (P i)| (n + 1)m for each i = 1, 2, . . . , n, and by Claim 9.38 we have that |X \V (Hj(Ga))| |Cj | + 2 for each j = 1, 2, . . . , m and a = 1, 2, . . . , n + 1. Since

the sum of these upper bounds through all the paths P i and gadgets Hj(Ga)is exactly equal to t, we infer that all these inequalities are in fact equalities:|X\V (P i)| = (n+1)m for each i = 1, 2, . . . , n, and |X\V (Hj(Ga))| = |Cj |+2for each j = 1, 2, . . . , m and a = 1, 2, . . . , n + 1.

Examine now one path P i and observe that any independent set of size(n + 1)m in P i can leave at most one pair of consecutive vertices on P i not


chosen. We will say that the copy Ga is spoiled by the path P i if V (P i(Ga))\Xcontains a pair of consecutive vertices on P i(Ga). It then follows that eachpath P i can spoil at most one copy Ga, so there exists at least one copy Ga

0

that is not spoiled at all. Let X0

be the counterimage, i.e. the set of originals,of the set V (Ga

0

)\X in the graph G0

. We then have that X0

contains everysecond vertex on each path P i, beginning with pi

0

and finishing on pi2m�2

,or beginning with pi

1

and finishing on pi2m�1

. Moreover, X0

\ V (Hj) is amaximum-size independent set in each gadget Hj . By Claim 9.38 it followsthat for each j = 1, 2, . . . , m there exists an index aj such that a

j

(Hj) 2 X0

.Let : Vars ! {?, >} be an assignment defined as follows: (xi) =

? if X0

\ V (P i) = {pi0

, pi2

, . . . , pi2m�2

}, and (xi) = > if X0

\ V (P i) ={pi

1

, pi3

, . . . , pi2m�1

}. Consider now any clause Cj , and let xij

be the variable

appearing in the literal `C

j

aj

. Recall that aj

(Hj) 2 X0

, and it is adjacent to

pij

2j in case `C

j

aj

= xij

, or to pij

2j+1

in case `C

j

aj

= ¬xij

. As X0

is independent,

we infer that this vertex on P ij does not belong to X

0

. Hence (xij

) = > in

case `C

j

aj

= xij

and (xij

) = ? in case `C

j

aj

= ¬xij

, by the definition of . In

both cases we can conclude that the literal `C

j

aj

satisfies Cj in the assignment . Since Cj was chosen arbitrarily, we infer that satisfies '.

Under SETH we can also prove optimality of known dynamic programmingroutines for many other problems. The following theorem provides a handfullof most important examples.

Theorem 9.40 ([62, 150]). Assume that CNF-SAT cannot be solved inO⇤((2 � "0)n) time for any "0 > 0. Then for every " > 0 the following holds(p is the width of a given path decomposition of the input graph):

• Dominating Set cannot be solved in O⇤((3 � ")p) time;• Odd Cycle Transversal cannot be solved in O⇤((3 � ")p) time;• q-Coloring cannot be solved in O⇤((q�")p) time, for any constant q > 3;• Steiner Tree cannot be solved in O⇤((3 � ")p) time;• Feedback Vertex Set cannot be solved in O⇤((3 � ")p) time;• Connected Vertex Cover cannot be solved in O⇤((3 � ")p) time.

Note that for the last three points, naıve dynamic programming routineswork in slightly super-exponential time, which can be improved to single ex-ponential using the techniques of Chapter 5 TODO: reference. In particu-lar, the lower bounds given by Theorem 9.40 for Steiner Tree, FeedbackVertex Set, and Connected Vertex Cover match the randomized up-per bounds given by the Cut&Count technique. Therefore, in these examplesthe bases of exponents in running times given by Cut&Count are not justcoincidental numbers stemming from the technique, but match inherent prop-erties of the problems themselves.

Observe also that all the lower bounds mentioned in Theorem 9.40 provethat the optimal base of the exponent is a number larger than 2, in most


cases 3. In the case of Independent Set the reduction intuitively embed-ded the 2n search space into 2p states of the dynamic program, which wasvery convienient as we could use a one-to-one correspondence between vari-ables xi and paths Pi. In the case of, say, Dominating Set, the reductionshould embed 2n possible variable assignments into 3n0

states of the dynamicprogram, where n0 = n · log

3

2. Hence, in the resulting decomposition we can-not have one element of a bag per each variable, but every element of a baghas to bear information about more than one variable; more precisely, aboutlog

2

3 ⇡ 1.585 variables. Needless to say, this creates technical di�culties inthe proof.

These di�culties can be overcome using a similar technique as in the proofof the lower bound for Hitting Set parameterized by the size of the universe(Theorem 9.34). We namely partition the variables into groups of size q for

some large constant q, and assign q0 =l

qlog

2

3

m

vertices of a bag to each

group. In this manner, for each group we can encode all 2q 3q0variable

assignments as solution’s traces on respective elements of a bag. Also, thepathwidth of the resulting graph will be approximately n · q0

q nlog

2

3

· (1+ ⌘)for some ⌘ converging to zero as q grows to infinity. Similarly as in thecase of Theorem 9.34, it is somewhat problematic to extract assignment of aparticular clause from a group in order to check it against a clause gadget.This is done via an additional layer of group gadgets that are responsible fordecoding the assignment for a group; we refer to [62, 150] for details.

9.4.3 A refined lower bound for Dominating Set

In Section 9.3 we have seen that ETH can be used to provide estimates of themagnitude of the function of k appearing in the exponent of XPalgorithms.Again, having assumed SETH we can establish even more precise lowerbounds. This is exemplified in the following theorem.

Theorem 9.41. Unless CNF-SAT can be solved in O⇤((2 � "0)n) time forsome "0 > 0, there do not exist constants " > 0, k � 3 and an algorithmsolving Dominating Set on instances with parameter equal to k that runsin O(Nk�") time, where N is the number of vertices of the input graph.

Proof. For the sake of contradiction assume that such constants " > 0, k � 3and such an algorithm do exist. We are going to present an algorithm forCNF-SAT working in O⇤(2�n) time for � = 1 � "

k < 1.Let ' be the input instance of CNF-SAT, let Vars be the variable set

of ', and let n, m be the numbers of variables and clauses of ', respec-tively. Partition Vars into k parts Vars

1

,Vars2

, . . . ,Varsk, each of size atmost dn/ke. For every part Varsi and each of 2|Varsi

| possible assignments : Varsi ! {?, >}, create a vertex vi

. For each i 2 [k], create an additional


vertex wi and let Vi be the set of vertices vi created for the part Varsi plus

the vertex wi. Make Vi into a clique. For each clause C of ', create a vertexuC . For every i 2 [k] and every assignment of Varsi, create an edge uCvi

ifand only if Vi contains a variable xi whose literal appears in C, and moreover evaluates xi so that this literal satisfies C. Let G be the resulting graphand let N = |V (G)|. Observe that N k · (1 + 2dn/ke) + m = O⇤(2n/k), soG contains at most

�N2

� O⇤(22n/k) O⇤(22n/3) edges. Moreover, G can be

constructed in O⇤(22n/k) O⇤(22n/3) time.We now claim that G admits a dominating set of size k if and only if ' is

satisfiable. If ' admits a satisfying assignment : Vars ! {?, >}, then letus construct a set X = {vi

|V

i

: i 2 [k]}. Observe that |X| = k and X is a

dominating set in G: each clique Vi is dominated by vi |

V

i

, while each vertex

uC is dominated by the vertex vi |

V

i

for any part Vi that contains a variable

whose literal satisfies C.Conversely, let X be a dominating set of size k in G. Since every vertex

wi is dominated by X and N [wi] = Vi, we infer that X contains exactly onevertex from each clique Vi, and no other vertex. Let us define assignment i : Varsi ! {?, >} for each i 2 [k] as follows: if X \ Vi = {wi} then put anarbitrary assignment as i, and otherwise i is such that X \Vi = {vi

i

}. Let =

S

i2[k]

i; we claim that the assigment satisfies the input formula '.Take any clause C and examine vertex uC . Since uC /2 X, uC is dominatedby a vertex ui

i

2 X for some i 2 [k]. By the definition of the edge set ofG we infer that Varsi contains a variable whose literal is present in C, andwhich is evaluated under the assignment i so that C becomes satisfied. Since i = |

Vars

i

, the same literal satisfies C in the assignment .To conclude the proof, observe that we could solve the CNF-SAT prob-

lem by pipelining the presented reduction with the supposed algorithm forDominating Set on instances with parameter k. As argued, the reductionruns in O⇤(22n/3) time, while the application of the algorithm for Dominat-ing Set takes O(Nk�") = 2n·(1�"/k) · (n + m)O(k) time. Since " > 0 and kis a constant, this means that CNF-SAT can be solved in O⇤(2�n) time for� = 1 � "

k < 1.

Note that the trivial algorithm for Dominating Set that verifies all k-tuples of vertices, runs in O⇤(Nk · (N + M)) time on graphs with N verticesand M edges. Hence, Theorem 9.41 essentially states that it is hard to breakthe barrier of the cardinality of the brute-force search space.

Exercises

9.1 (�). Prove the randomized analogues of Theorems 9.4 and 9.5:

(a) Assuming randomized ETH, there exists a constant c > 0 such that no randomizedtwo-sided error algorithm for 3-SAT can achieve running time O⇤(2c(n+m)).


(b) Randomized SETH implies randomized ETH.

9.2. Prove Theorem 9.6, that is, verify that the following problems admit linear reductionsfrom 3-SAT:

(a) Vertex Cover (�),(b) Dominating Set (�),(c) Feedback Vertex Set (�),(d) 3-Coloring,(e) Hamiltonian Cycle.

9.3. Prove Theorem 9.9, that is, verify that the following problems admit reductions withquadratic output size from the Planar 3-SAT problem with the additional property guar-anteed by Theorem 9.8:

(a) Planar Vertex Cover,(b) Planar Dominating Set,(c) Planar Feedback Vertex Set,(d) Planar 3-Coloring ( ),

(e) Planar Hamiltonian Cycle ( ).

9.4 (�). Using Theorem 9.13 as a blackbox, prove that existence of an O⇤(2o(k log k))algorithm for k ⇥ k Permutation Clique would contradict randomized ETH.

9.5. In the 2k ⇥ 2k Bipartite Permutation Independent Set we are given a graphG with the vertex set [2k] ⇥ [2k], where every edge is between I

1

= [k] ⇥ [k] and I2

=([2k]\ [k])⇥([2k]\ [k]). The question is whether there exists an independent set X ✓ I

1

[I2

in G that induces a permutation of [2k]. Construct a polynomial-time reduction that takesan instance of k ⇥ k Permutation Clique and outputs an equivalent instance of 2k ⇥ 2kBipartite Permutation Independent Set. Infer that 2k ⇥ 2k Bipartite PermutationIndependent Set does not admit an O⇤(2o(k log k)) algorithm unless ETH fails.

9.6. Construct a polynomial-time reduction that takes an instance of 2k ⇥ 2k BipartitePermutation Independent Set and outputs an equivalent instance of 2k ⇥ 2k Permu-tation Hitting Set with thin sets. Infer that k ⇥ k Permutation Hitting Set withthin sets does not admit an O⇤(2o(k log k)) algorithm unless ETH fails, which is the firsthalf of Theorem 9.16.

9.7 (�). Construct a polynomial-time reduction that takes an instance of k ⇥ k Permu-tation Hitting Set with thin sets and outputs an equivalent instance of k ⇥ k HittingSet with thin sets. Infer that k ⇥ k Hitting Set with thin sets does not admit anO⇤(2o(k log k)) algorithm unless ETH fails, which is the second half of Theorem 9.16.

9.8 ( ). In the Maximum Cycle Cover problem the input consists of a graph G andinteger t, and the question is whether one can find a collection of at least t vertex-disjointcycles in the graph so that every vertex belongs to exactly one of these cycles. Prove thatunless ETH fails, Maximum Cycle Cover does not admit an FPT algorithm with runningtime O⇤(2o(p log p)), where p is the width of a given path decomposition of G.

9.9 ( ). Using Theorem 9.19 as a blackbox, prove the following statement: There existsa universal constant � > 0 such that, unless P 6= NP, there is no constant � and akernelization algorithm for Edge Clique Cover that reduces the number of vertices toat most � · 2�k. In particular, Edge Clique Cover does not admit a 2o(k) kernel unlessP 6= NP.

9.10 (�). Modify the construction in the proof of Theorem 8.31 to get a parmeterized re-duction from Subgraph Isomorphism to Odd Set where the parameter of the constructedinstance is linear in the number of edges of H in the Subgraph Isomorphism instance.


9.11 (�). Modify the construction in the proof of Theorem 8.33 to get a parmeterizedreduction from Subgraph Isomorphism to Strongly Connected Steiner Subgraphwhere the parameter of the constructed instance is linear in the number of edges of H inthe Subgraph Isomorphism instance.

9.12. The input of the Unit Square Independent Set problem is a set of axis-parallelunit squares in the plane and an integer k; the task is to select a set of k pairwise disjointsquares. Show that Unit Square Independent Set is W[1]-hard and, unless ETH fails,

it has no f(k)no(pk) time algorithm for any computable function f .

9.13 (�). Prove Claim 9.38.

9.14 (�). Prove Claim 9.39.

Hints

9.1 Follow the lines of the proofs of Theorems 9.4 and 9.5, but whenever some algorithmAc is used, repeat its usage many times in order to reduce the error probability.

9.2 Look on classic NP-hardness reductions for these problems that can be found in theliterature.

9.3

(a) Replace variables and clauses by gadgets, but watch out not to spoil planarity arounda variable gadget when edges corresponding to positive and negative occurences inter-leave around the vertex corresponding to the variable. To fix this, use a cycle of length2p for a variable gadget, where p is the number of occurences of the variable.

(b) Design a similar construction as for Planar Vertex Cover, but use a cycle of length3p.

(c) Modify slightly the construction for Planar Vertex Cover by applying the standardreduction from Vertex Cover to Feedback Vertex Set at the end.

(d) Use the additional cycle x1

�x2

� . . .�xn �x1

provided by Theorem 9.8 to propagatecolors chosen to represent true and false assignment. Carefully design a planar variablegadget of size ⇥(p), where p is the number of occurences of the variable. Make sure thatyour gadget both propagates colors representing true and false to the next variable,and also makes use of them in the check against the clause gadget. The clause gadgetcan be of constant size.

(e) Use the additional cycle x1

� x2

� . . . � xn � x1

provided by Theorem 9.8 as the‘spine’ of the intended Hamiltonian cycle. The Hamiltonian cycle should be able tomake small detours from the spine into clause gadgets, and all clause gadgets can bevisited if and only if the input formula is satisfiable. Use the ladder graph depicted onFigure 9.9 as your variable gadget. In the proof of correctness you will need to be verycareful when arguing that the Hamiltonian cycle cannot misbehave and jump betweendistant variable gadgets via clause gadgets.

9.4 Start with the randomized version of Theorems 9.4, i.e. Exercise 9.1.(a), and verifythat the chain of reductions to k⇥k Clique via 3-Coloring gives also a randomized lowerbound.

9.5 By taking the complement of the graph, you may start with k ⇥ k PermutationIndependent Set. In the constructed instance of 2k ⇥ 2k Bipartite Permutation In-dependent Set, the only possible independent sets should induce the same permutation


Fig. 9.9: The ladder graph.

pattern on I1

and on I2

, and this permutation pattern should correspond to a solution tothe input instance of k ⇥ k Permutation Independent Set.

9.6 Encode the constraint imposed by each edge of G using one thin set. Remember toforce the solution to be contained in I

1

[ I2

, which can be also done using thin sets.

9.7 The requirement that each column must contain at least one vertex of the solutioncan be easily encoded using thin sets.

9.8 Follow the strategy sketched in the paragraph after Theorem 9.18. Start from k ⇥ kHitting Set with thin sets and encode choice of the solution as a choice of a matchingin a Kk,k-biclique in the first bag. The main spine of the decomposition should be formedby 2k paths originating in the 2k vertices of the biclique; along these paths k cycles should‘travel’ at each point. A gadget verifying a set should allow closing one cycle and beginningone new in its place if and only if the set is hit by the solution.

9.9 Since Edge Clique Cover is in NP, there exists a polynomial-time reduction fromEdge Clique Cover to 3-SAT. Consider the composition of (a) the reduction of Theo-rem 9.9, (b) a supposed kernelization algorithm, and (c) the reduction back from EdgeClique Cover to 3-SAT. Calculate an upper bound on the size of the output instance interms of the input one.

9.10 Let v1

, . . . , v|V (H)| be the vertices of H. We include Ei,j in the universe only if viand vj are adjacent. The parameter is set to k0 = k + |E(H)|.9.11 Let v

1

, . . . , v|V (H)| be the vertices of H. We include the vertex yi,j and the set ofvertics E0

i,j in G0 only if vi and vj are adjacent. The parameter is set to k0 = k + 1 +2|E(H)| = |K| + k + |E(H)|.9.12 The reduction in the proof of Theorem 9.33 does not work with squares: the squaresat (x + a", y + a") and (x + 1 + a", y + 1 + a") can intersect at their corners, which wasnot an issue for unit disks. We show two possible workarounds.

Solution 1: Represent each pair (a, b) 2 S[x, y] with the 5 squares at (3x + a", 3y + a"),(3x + 1 + a", 3y + a"), (3x + a", 3y + 1 + a"), (3x � 1 + a", 3y + a"), (3x + a", 3y � 1 + a").Set the new parameter to k0 = 5k.

Solution 2: Represent each pair (a, b) 2 S[x, y] with a square at (x+a"�y/2, y+a"+x/2).

Bibliographic notes

The O⇤(20.386n) algorithm for 3-SAT is due to Paturi, Pudlak, Saks, and Zane [173]. ETHand SETH have been first introduced in the work of Impagliazzo, Paturi and Zane [127],which builds upon earlier work of Impagliazzo and Paturi [126]. In particular, the Sparsi-fication Lemma (Theorem 9.3) together with its most important corollary, Theorem 9.4,have been proved in [126]. The work of Impagliazzo and Paturi [126] also describes indetails and larger generality the consequences of ETH that can be obtained via linear re-ductions; Theorem 9.6 is a direct consequence of this discussion. Applicability of ETH to


problems planar graphs and to basic parameterized problems has been first observed byCai and Juedes [33]. In particular, Theorems 9.9 and 9.11 should be attributed to them.

The technique of proving NP-hardness of problems on planar graphs via Planar 3-SAThas been proposed by Lichtenstein [148], and it unified several results that were obtainedbefore. In particular, Exercise 9.3 is motivated by the work of Lichtenstein, apart fromNP-hardness of Planar 3-Coloring. The classic reduction for this problem has been firstgiven by Stockmeyer [191], and proceeds directly from general 3-Coloring by embeddingthe graph on the plane and introducing a cross-over gadget for each crossing of edges.However, it is possible to prove NP-hardness also using Planar 3-SAT, as proposed inExercise 9.3.

The lower bounds for slightly super-exponential parameterized complexity have beenintroduced by Lokshtanov, Marx, and Saurabh [151]. In particular, all results contained inSection 9.2.2 originate in [151], apart from the the lower bound for Cycle Packing (firstpart of Theorem 9.18) that has been proved by Cygan, Nederlof, Pilipczuk, Pilipczuk,van Rooij, and Wojtaszczyk [62] as one of complementary results for their Cut&Counttechnique. Exercise 9.8 originates also in the work of Cygan et al. [62].

The doubly-exponential lower bound for Edge Clique Cover has been given by Cygan,Pilipczuk, and Pilipczuk [63]. Nonexistence of a subexponential kernel under P 6= NP, i.e.Exercise 9.9, is given in the PhD thesis of Pilipczuk [175].

The lower bound of Theorem 9.20 was proved by Chen et al. [41] (conference versionis [39]). A weaker lower bound, which does not allow for the factor f(k) in the runningtime, was proved by Chen et al. [38]. These papers, as well as Chen et al.[40] noted thatlower bounds of this form for W[1]-hard problems can be transferred to other problems viaparameterized reductions that increase the parameter at most linearly.

The lower bound Theorem 9.23 for Subgraph Isomorphism was proved by Marx [160] ascorollary of a much more general result on restricted constraint satisfaction problems wherethe constraint graph has to belong to a certain class. The lower bounds of Theorem 9.26is due to Marx [158].

Alber and Fiala [3] presented an nO(

pk) time algorithm for Unit Disk Independent

Set using a geometric separator theorem. However, as discussed by Marx and Sidiropou-los [167], one can obtain this result by a simple application of the shifting technique. TheW[1]-hardness of Unit Disk Independent Set proved by Marx [155], but with a reduc-tion that increases the parameter more than quadratically, a hence giving only a lowerbound weaker than the one stated in Theorem 9.33. The Grid Tiling problem was for-mulated by Marx [157], obtaining the tight lower bound of Theorem 9.33 for Unit DiskIndependent Set, as well as an analogous result for Unit Square Independent Set.The lower bound of Theorem 9.31 and the algorithm of Theorem 9.30 for Scattered Setis by Marx and Pilipczuk [162]. The Grid Tiling problem was used by Marx [161] to

show that, assuming ETH, there is no f(k) · no(p

`) time algorithm for Edge Multicuton planar graphs with ` terminals for any computable function f , essentially matching

the 2O(`) · nO(

p`) time algorithm of Klein and Marx [136]. Chitnis, Hajiaghayi, and Marx

[49] used Grid Tiling to prove that, assuming ETH, there is no f(k) · no(pk) time algo-

rithm for Strongly Connected Steiner Subgraph on planar graphs, parameterized bythe number k of terminals, for any computable function f . Additionally, they presented

a a 2O(k log k) · nO(

pk) time algorithm for planar graphs (on general graphs, an earlier

algorithm of Feldman and Ruhl [94] solves the problem in time nO(k) time). Marx andPilipczuk [163] presented a number of W[1]-hardness results for various parameterizationsof Subgraph Isomorphism; many of these reductions start from Grid Tiling. The GridTiling with problem was formalized by Marx and Sidiropoulos [167], who also studiedhigher-dimensional generalizations of Grid Tiling and Grid Tiling with and obtainedtight lower bounds for higher-dimensional geometric problems.

The lower bound for Hitting Set parameterized by the size of the universe hasbeen given by Cygan, Dell, Lokshtanov, Marx, Nederlof, Okamoto, Paturi, Saurabh, and


Wahlstrom [59]. The work of Cygan et al. contains a much larger net of reductions, whichlinks many classic parameterized problems either to SETH or to the Set Cover Conjecture(Conjecture 9.35). In particular, the Set Cover Conjecture is formulated in [59].

The framework for proving SETH-based lower bounds for treewidth/pathwidth param-eterizations has been introduced by Lokshtanov, Marx, and Saurabh [150]. In particular,the presented lower bound for Independent Set (Theorem 9.37) is due to them. The firstthree lower bounds of Theorem 9.40 have been also obtained in [150], while the latter threehave been given by Cygan, Nederlof, Pilipczuk, Pilipczuk, van Rooij, and Wojtaszczyk [62]as complementary results for their Cut&Count technique.

The SETH lower bound for Dominating Set, i.e., Theorem 9.41, has been given by

Patrascu and Williams [176]. Interestingly, Patrascu and Williams view this theorem not as

a lower bound, but rather as a possible route of obtaining faster algorithms for CNF-SAT.

Chapter 10

Lower bounds for kernelization

10.1 Compositionality

In Chapters ??, 6, and 7 we have learnt many di↵erent methodologies of ob-taining polynomial kernels. While some parameterized problems are naturallyamenable to various preprocessing techniques, we have so far not discussedwhat properties of a given problem make it resistant from the point of viewof e�cient kernelization. More precisely, under what conditions and whatassumptions can we refute existence of a polynomial kernel for a particularproblem?

The best known so far answer to this question comes via the framework ofcompositionality . It might be argued that the development of this techniquearound year 2008 greatly propelled the popularity of kernelization as a re-search area. We were no longer wandering in the darkness, stumbling uponcoincidental problems for which we could derive preprocessing rules leadingto good guarantees on the output size, but we could start a more systematicclassification of problems into those that do admit polynomial kernels, andthose that probably do not.

In this chapter we introduce the technique of compositionality, and illus-trate it on a few selected examples that reflect various scenarios appearing in‘real life’. Since the principles of the technique are very intuitive, while theformal layer may be slightly di�cult to digest, we first give a description ofthe intuition behind the methodology before going into formal details.

Let us take as the working example the k-Path problem: given a graph Gand integer k, we ask whether G contains a simple path on k vertices. Assumefor a moment that this problem admitted a kernelization algorithm that re-duces the number of vertices to at most k3. More formally, given instance(G, k) it outputs an equivalent instance (G0, k0) such that |V (G0)|, k0 k3.Suppose somebody gave us k7 instances of k-Path with the same parame-ter k; denote them (G

1

, k), (G2

, k), . . . , (Gk7 , k). Consider now graph H ob-tained by taking the disjoint union of graphs G

1

, G2

, . . . , Gk7 , and observe

307

308 10 Lower bounds for kernelization

that H contains a path on k vertices if and only if at least one of the graphsG

1

, G2

, . . . , Gk7 does. In other words, the answer to instance (H, k) is equalto the logical OR of the answers to instances (G

1

, k), (G2

, k), . . . , (Gk7 , k).We will also say that instance (H, k) is an OR-composition of instances(G

1

, k), (G2

, k), . . . , (Gk7 , k).Now apply the assumed kernelization algorithm to instance (H, k), and

obtain some new instance (H 0, k0) such that |V (H 0)|, k0 k3. Observe that(H 0, k0) can be encoded in roughly k6/2 + 3 log k bits: we can encode the

adjacency matrix of H 0 in�k3

2

�

bits, while encoding of k0 takes 3 log k bits.This is, however, much less than k7, the number of the input instances!

Therefore, during the kernelization process the algorithm must have ‘for-gotten’ information about a vast majority of instances. The desired k-path,however, can lure in any of them. Losing information about this instance canchange the global answer to the problem, in case it is the only one with thepositive outcome. Consequently, the kernelization algorithm would need to beable to solve some of the given instances, or at least to reason which of themare less prone to have a positive answer and can be safely discarded. Suchan ability would be highly suspicious for an algorithm running in polynomialtime, since the k-Path problem is NP-hard.

Of course, there is nothing magical in the numbers 3 and 7 that we pickedin this example, and the reasoning is much more general: a kernelizationalgorithm for k-Path with polynomial guarantees on the output size wouldneed to discard some information that it should not be able to identify asuseless. Our goal is therefore to put into formal terms why the describedbehaviour is unlikely, and link this understanding to some well-establishedassumptions from the complexity theory.

10.1.1 Distillation

We first aim to formally capture the intuition that some information has tobe lost when packing too many instances into a too small space in the kernel.In order to achieve it, we introduce the concept of distillation, which willbe a result of pipelining a composition for a parameterized problem with ahypothetical polynomial kernel for it. Thus, by (a) designing a composition,and (b) proving that existence of a distillation is unlikely, we will be ableto refute existence of a polynomial kernel. This section is devoted to under-standing issue (b). Since parameterizations will be needed only to formallycapture the concept of kernelization, the definition of distillation considersonly unparameterized languages.

Let ⌃ be some fixed, constant-size alphabet that we will use for encodingthe instances.

10.1 Compositionality 309

Definition 10.1. Let L, R ✓ ⌃⇤ be two languages. An OR-distillation of Linto R is an algorithm which, given a sequence of strings x

1

, x2

, . . . , xt 2 ⌃⇤,runs in time polynomial in

Pti=1

|xi| and outputs one string y 2 ⌃⇤ suchthat

(a) |y| p(maxti=1

|xi|) for some polynomial p(·), and(b) y 2 R if and only if there exists at least one index i such that xi 2 L.

Thus, the answer to the output instance of R is equivalent to the logicalOR of the answers to the input instances of L. The following theorem is thebackbone result standing behind the compositionality framework.

Theorem 10.2. Let L, R ✓ ⌃⇤ be two languages. Assume that there existsan OR-distillation of L into R. Then L 2 coNP/ poly.

Before we proceed to the proof, let us briefly elaborate on the conse-quences of the theorem. Assume that L was NP-hard and it admitted anOR-distillation into some language R. Then, for any language L0 2 NP wecould construct an algorithm resolving membership in L0 in coNP/ poly asfollows. We first apply the NP-hardness reduction from L0 to L, and thenrun the implied algorithm resolving membership in L in coNP/ poly. Conse-quently NP ✓ coNP/ poly, which is a highly unexpected outcome from thepoint of view of the complexity theory.

The assumption that NP * coNP/ poly may be viewed as a slight strength-ening of the more recognizable statement that NP 6= coNP. We just assumethat it is impossible to construct an algorithm for every problem in NP thatworks in coNP, even if we could give the algorithm access to some polynomial-size advice string that depends on the input length only. It is known thatNP ✓ coNP/ poly implies that ⌃P

3

= PH, that is, the polynomial hierarchycollapses to its third level. This is not as dramatic collapse as P = NP, butit is serious enough to be highly implausible.

Note here that we do not assume anything about the target language R —it can be even undecidable. Therefore, in some sense the theorem has a purelyinformation-theoretical character. It shows that the possibility of packinga lot of information into small space gives raise to a surprising algorithmresolving the problem, lying roughly on the opposite side of the polynomialhierarchy than expected. The way of organizing the information in the outputinstance is not relevant at all.

Proof (Proof of Theorem 10.2). Without loss of generality assume that⌃ = {0, 1}. Let A be the assumed OR-distillation algorithm, and letK = max

0in p(i) be a polynomial bound on the length of the outputstring for input strings of length at most n. Let us fix t = K + 1. Thus, thealgorithm A maps the set D = (⌃n)t of t-tuples of input strings into theset ⌃K .

Let now A = L \ ⌃n and A = ⌃n \ L be the sets of YES- and NO-instances of L of length at most n, respectively. Similarly, let B = R \⌃K


and B = ⌃K \ R. By the assumption that A is an OR-distillation, we havethat A maps (A)t into B, and D \ (A)t into B.

For strings x 2 ⌃n and y 2 ⌃K , we will say that x is covered by y ifthere exists a t-tuple (x

1

, x2

, . . . , xt) 2 D such that (a) x = xi for some i,and (b) A(x

1

, x2

, . . . , xt) = y. In other words, x is contained in some tuplefrom the preimage of y. More generally, for X ✓ D and Y ✓ ⌃K we willsay that X is covered by Y if every element of X is covered by at least oneelement of Y . The following claim will be the core argument in the proof.

Claim 10.3. There exists a set Y ✓ B such that

(a) |Y | n + 1, and(b) Y covers A.

Since A�1(B) = (A)t, no element of B can cover any string x outside A.Of course, B itself covers A, but the size of B can be huge in terms of n. Thegist of the proof is that we can find a covering set of size polynomial in n,rather than exponential. Before we proceed to the proof of Claim 10.3, let usshed some light on its motivation by showing how it implies Theorem 10.2.

We would like to construct an algorithm resolving membership in L whichruns in co-nondeterministic polynomial time and can use polynomial advice.Let us briefly remind what it means. The algorithm is given an input string xof length n, and has access to some advice string ↵n of length polynomial inn, which depends on n only. We can use only co-nondeterministic polynomialtime, that is, the algorithm can take some nondeterministics steps: In casewhen x 2 L, the algorithm should derive this conclusion for every possiblerun, while if x /2 L, then at least one run needs to finish with this conclusion.

In our case the advice ↵n will be an encoding of the covering set Y . SinceY contains at most n+1 strings, each of length at most K, the advice string↵n will be of length polynomial in n. The algorithm works as follows. Giventhe input string x, it tries to prove that x /2 L. If this is the case, thenthere exists a tuple (x

1

, x2

, . . . , xt) 2 D such that x = xi for some i, andA(x

1

, x2

, . . . , xt) 2 Y . The algorithm guesses co-nondeterministically thistuple, computes A(x

1

, x2

, . . . , xt), and checks whether the result is containedin the advice string ↵n. If indeed x /2 L, then for at least one guess we willcompute a string belonging to Y , which is a certificate that x /2 L sinceY ✓ B. If x 2 L, however, then every tuple containing x is mapped to astring outside B, so in particular outside Y .

We now proceed to the proof of Claim 10.3. We will consecutively constructstrings y

1

, y2

, y3

, . . . 2 B up to the point when the set Yi = {y1

, y2

, . . . , yi}already covers the whole A. Let Si be the set of strings from A that arenot covered by Yi; we have that S

0

= A. During the construction we will

guarantee that |Si| |A|2

i

, which is of course satisfied at the beginning. Since

|A| |⌃n| < 2n+1, the construction will terminate after at most n+1 stepswith Si being empty.


x2

x3

Si�1

\ Si

Si�

1

x1

Fig. 10.1: The core combinatorial argument in the proof of Claim 10.3: if asmall t-dimensional product hypercube is contained in a large t-dimensionalproduct hypercube, and it contains at least 1

2

t

fraction of all the tuples, thenthe side of the small hypercube must be at least half as long as the sideof the large one. The balls within the small hypercube depict tuples fromA�1(y) \ (Si�1

)t.

It remains to show how to construct the string yi basing on the knowledgeof Yi�1

. Recall that the algorithm A maps every tuple from the set (Si�1

)t ✓(A)t into B. Since |B| |⌃K | < 2K+1, it follows by the pigeonhole principle

that there exists some y 2 B such that |A�1(y) \ (Si�1

)t| � |(Si�1

)

t|2

K+1

=⇣

|Si�1

|2

⌘t. Observe now that every string from Si�1

that is contained in any

tuple from A�1(y)\ (Si�1

)t, is covered by y. Therefore, if we set yi = y, thenevery string from every tuple from the set A�1(y) \ (Si�1

)t is contained inSi�1

\Si, since it gets covered. Consequently A�1(y)\ (Si�1

)t ✓ (Si�1

\Si)t,and hence

✓ |Si�1

|2

◆t

�

�A�1(y) \ (Si�1

)t�

� �

�(Si�1

\ Si)t�

� = |Si�1

\ Si|t.

We infer that |Si�1

\ Si| � |Si�1

|2

, which means that |Si| |Si�1

|/2 and

condition |Si| |A|2

i

follows by a trivial induction. As we have argued, thismeans that the construction will terminate after at most n+1 steps, yieldinga feasible set Y . This concludes the proof of Claim 10.3, and of Theorem 10.2.

10.1.2 Composition

We now proceed to understanding formally what it means to compose in-stances. Recall that in the k-Path example we assumed that all the input


instances have the same parameter. It appears that we can make even strongerassumptions, which is formalized in the following definition.

Definition 10.4. An equivalence relation R on the set ⌃⇤ is called a poly-nomial equivalence relation if the following conditions are satisfied:

(a) There exists an algorithm that, given strings x, y 2 ⌃⇤, resolves whetherx ⌘R y in time polynomial in |x| + |y|.

(b) Relation R restricted to the set ⌃n has at most p(n) equivalence classes,for some polynomial p(·).

Assume, for instance, that the input to our problem is some fixed encodingof an undirected graph. We can then define R as follows. First, we put into oneequivalence class all the strings from ⌃⇤ that do not encode any graph. Wecall such instances malformed, while all the other instances are well-formed.Next, note that we can choose the encoding in such a manner that graphswith encoding of length at most n have at most n vertices and at most nedges. Therefore, if we say that two well-formed instances are R-equivalent ifthe corresponding graphs have the same numbers of vertices and edges, then⌃n is divided by R into at most n2 classes and condition (b) is satisfied.Of course, provided that we chose a reasonable encoding, condition (a) holdsas well. If the input to the problem was a graph and an integer k, encodedin unary, then we could in addition refine R by requiring that the instancesx and y must have the same value of k — we would just increase the boundon the number of equivalence classes in ⌃n from n2 to n3. In the latersections we will see that the ability of making such assumptions about theinput instances can be very useful for streamlining the composition.

We now proceed to the main definition.

Definition 10.5. Let L ✓ ⌃⇤ be an unparameterized language and Q ✓⌃⇤ ⇥N be a parameterized language. We say that L cross-composes into Q ifthere exists a polynomial equivalance relation R and an algorithm A, calledthe cross-composition, satisfying the following conditions. The algorithm Atakes on input a sequence of strings x

1

, x2

, . . . , xt 2 ⌃⇤ that are equivalentwith respect to R, runs in time polynomial in

Pti=1

|xi|, and outputs oneinstance (y, k) 2 ⌃⇤ ⇥ N such that:

(a) k p(maxti=1

|xi|, log t) for some polynomial p(·, ·), and(b) (y, k) 2 Q if and only if there exists at least one index i such that xi 2 L.

Note that in this definition, contrary to OR-distillation, it is only the out-put parameter that is small, while the whole output string y may be evenas huge as the concatenation of the input instances. Moreover, the outputparameter can also depend poly-logarithmically on the number of input in-stances. This seemingly innocent nuance will be heavily exploited in the latersections.

To give an example, observe that the Hamiltonian Path problem cross-composes to k-Path as follows. For the equivalance relation R we take a


relation that puts all malformed instances into one equivalence class, whileall the well-formed instances are partitioned with respect to the number ofvertices of the graph. The cross-composition algorithm, given a bunch ofmalformed instances, returns some trivial NO-instance of k-Path, while givena sequence of graphs on n vertices, it returns the encoding of their disjointunion together with parameter k = n. For a reasonable encoding we have thatn is bounded by the maximum length of an input string, and so condition (a)holds. Clearly, the disjoint union of graphs on n vertices has an n-vertex pathif and only if one of the input graphs admitted a hamiltonian path. Hencecondition (b) is satisfied as well.

As the reader expects, pipelining the cross-composition from an NP-hardproblem with a polynomial kernel will yield an OR-distillation of the NP-hard problem, implying that NP ✓ coNP/ poly. However, since the output ofan OR-distillation can be an instance any language, we will be able to refuteexistence of a larger class of preprocessing routines.

Definition 10.6. A polynomial compression of a parameterized languageQ ✓ ⌃⇤ ⇥ N into an unparameterized language R ✓ ⌃⇤ is an algorithmthat takes as input an instance (x, k) 2 ⌃⇤ ⇥N, works in time polynomial in|x| + k, and returns a string y such that:

(a) |y| p(k) for some polynomial p(·), and(b) y 2 R if and only if (x, k) 2 Q.

In case |⌃| = 2, the polynomial p(·) will be called the bitsize of the compres-sion.

Whenever we talk about existence of a polynomial compression and wedo not specify the target language R, we mean existence of a polynomialcompression into any language R.

Obviously, a polynomial kernel is also a polynomial compression by treat-ing the output kernel as an instance of the unparameterized version of Q. Themain di↵erence between these notions is that the polynomial compression isallowed to output an instance of any language R, even an undecidable one.Clearly, if R is reducible in polynomial time back to Q, then pipelining thecompression with the reduction gives a polynomial kernel for Q. However, Rcan have much higher complexity than Q, and there are examples of naturalproblems for which there exists a polynomial compression, but a polynomialkernel is not known.

We are now ready to state and prove our main theorem.

Theorem 10.7. Assume that an NP-hard language L cross-composes to aparameterized language Q. Then Q does not admit a polynomial compression,unless NP ✓ coNP/ poly.

Proof. Let A be the assumed cross-composition of L into Q, let p0

(·, ·) bethe polynomial bounding the parameter of the output instance of A, and let


k

1

C

1

c

1

k

2

c

2

k

3

c

3

C

2

C

3

d

1

d

2

d

3

d

2

d

3

d

1

d

L

Q

R

OR(R)

Composition

x

1

x

2

x

3

x

4

x

5

x

6

x

7

x

8

x

9

Composition

Composition

Compression

Compression

Compression

Fig. 10.2: The workflow of the algorithm in the proof of Theorem 10.7.

R be the polynomial equivalence relation used by A. Assume further that Qadmits a polynomial compression C into some language R. Let OR(R) be alanguage consisting of strings of the form d

1

#d2

# . . . #dq such that for atleast one index i it holds that di 2 R. Here, # is some special symbol that isartificially added to ⌃ and is not used in any string from R. We are going toconstruct an OR-distillation of L into OR(R), which by Theorem 10.2 impliesthat NP ✓ coNP/ poly.

Let x1

, x2

, . . . , xt be the sequence of input strings and let n = maxti=1

|xi|.Apply the following polynomial-time preprocessing: examine the strings pair-wise and remove all the duplicates. Note that this step does not changewhether at least one of the strings belongs to L. Observe that the numberof di↵erent strings over ⌃ of length at most n is bounded by

Pni=0

|⌃|i |⌃|n+1. Hence, after removing the duplicates we have that t |⌃|n+1, andso we can assume that log t = O(n).

Partition the input strings into equivalence classes C1

, C2

, . . . , Cq withrespect to the relation R. By the definition of the polynomial equivalencerelation, this step can be performed in polynomial time, and q, the numberof the obtained classes, is bounded by some polynomial p

1

(n).For j = 1, 2, . . . , q, apply the cross-composition A to the strings contained

in the class Cj , obtaining a parameterized instance (cj , kj) such that (a)kj p

0

(maxx2Cj

|x|, log |Cj |), which is polynomially bounded in n and log t,and (b) (cj , kj) 2 Q if and only if there exists at least one instance x 2 Cj

such that x 2 L. Consequently, there exists an index i, 1 i t, suchthat xi 2 L if and only if there exists an index j, 1 j q, such that(cj , kj) 2 Q. Since log t = O(n), we infer that for some polynomial p

2

(·) itholds that kj p

2

(n) for j = 1, 2, . . . , q.


Now apply the assumed compression algorithm C to each instance (cj , kj),obtaining a string dj such that dj 2 R if and only if (cj , kj) 2 Q. Sincekj p

2

(n) and |dj | p3

(kj) for some polynomial p3

(·), then |dj | p4

(n) forsome polynomial p

4

(·).Finally, merge all the strings dj into one instance d = d

1

#d2

# . . . #dq.From the construction it immediately follows that d 2 OR(R) if and only ifthere exists an index i, 1 i t, such that xi 2 L. Hence, condition (b)of OR-distillation is satisfied. For condition (a), we have that q p

1

(n) and|dj | p

4

(n). Consequently |d| p1

(n) · (p4

(n) + 1) � 1, and condition (a)follows.

As an immediate corollary of the described cross-composition of Hamilto-nian Path into k-Path, NP-hardness of the Hamiltonian Path problem,and Theorem 10.7, we obtain the following result.

Corollary 10.8. k-Path does not admit a polynomial kernel unless NP ✓coNP/ poly.

We remark that it is very rare for a problem to admit such a simplecross-composition as in the case of k-Path. Designing a cross-compositionusually requires a very good understanding of the combinatorics of the prob-lem together with a few ingenious insights into how the construction can beperformed. One often needs to make a clever choice of the starting languageL, and/or do a lot of technical work. In Section 10.2 we will see on a numberdi↵erent examples, what kind of strategies can be employed for designing across-composition.

It is somewhat interesting that the composition framework, which is ba-sically the only tool that we have so far for proving kernelization lowerbounds, seems to be unable to distinguish polynomial kernelization from theweaker notion of polynomial compression. Understanding the di↵erence be-tween these two concepts in terms of the computational power is an importantopen problem.

10.1.3 AND-distillations and AND-compositions

In the previous sections we have been always using the OR function as thetemplate of behaviour of distillations and compositions. It is very temptingto conjecture that the same results can be obtained when we substitute ORby AND. We could in the same manner define AND-distillation by replacingcondition (b) of OR-distillation with a requirement that the output string ybelongs to R if and only if all the input strings xi belong to L. Likewise, AND-cross-composition is defined by replacing condition (b) of cross-compositionby requiring that the resulting instance (y, k) belongs to Q if and only if allthe input strings xi belong to L.


The proof of Theorem 10.7 is oblivious to whether we use the OR func-tion or the AND function; the outcome of the constructed distillation will bejust an instance of AND(R) instead of OR(R). Our arguments behind The-orem 10.2, however, completely break when translating them to the ANDsetting. It appears that Theorem 10.2 is still true when we replace OR-distillations with AND-distillations, but the proof is much more di�cult,and hence omitted in this book.

Theorem 10.9 ([89]). Let L, R ✓ ⌃⇤ be two languages. Assume that thereexists an AND-distillation of L into R. Then L 2 coNP/ poly.

Drucker writes only statement that L being NP-hard implies NP ✓coNP/ poly. Check that he has also the above statement. (DL and SS sayyes). Send e-mail to Drucker to make sure.

As we have already mentioned, the proof of Theorem 10.7 can be trans-lated to the AND setting in a straightforward manner; we leave checking thisfact as an easy exercise. Therefore, by replacing usage of Theorem 10.2 withTheorem 10.9 we obtain the following result.

Theorem 10.10. Assume that an NP-hard language L AND-cross-composesto a parameterized language Q. Then Q does not admit a polynomial com-pression, unless NP ✓ coNP/ poly.

As an example of a problem that admits a trivial AND-cross-compositiontake the Treewidth problem: given a graph G and parameter k, verifywhether tw(G) k. Since treewidth of a disjoint union of a family ofgraphs is equal to the maximum over treewidths of these graphs, the disjointunion yields an AND-cross-composition from the unparameterized version ofTreewidth to the parameterized one. Computing treewidth of a graph isNP-hard, so by Theorem 10.10 we infer that Treewidth does not admit apolynomial kernel, unless NP ✓ coNP/ poly. The same reasoning can be per-formed for other graph parameters that behave similarly under the disjointunion, for instance for pathwidth, cliquewidth, or treedepth.

It is noteworthy that problems known to admit AND-cross-compositionsare much scarcer than those amenable to OR-cross-compositions. We hardlyknow any natural examples other than the aforementioned problems of com-puting graph parameters closed under taking the disjoint union. Therefore,when trying to refute existence of a polynomial kernel for a particular prob-lem, it is more sensible to first try to design an OR-cross-composition.

10.2 Examples

We now show four selected proofs of kernelization lower bounds, chosen topresent di↵erent aspects of the compositions framework. We discuss instance

10.2 Examples 317

selectors, a common theme in many compositions appearing in the litera-ture. We also present the so-called polynomial parameter transformations ,which serve the role of hardness reductions in the world of kernelizationlower bounds. We conclude with an example of a problem parameterized bysome structural measure of the input graph and see that the compositionframework works well also in such cases.

10.2.1 Instance selector: Set Splitting

Recall that, when designing a cross-composition, we are to encode a logicalOR of multiple instances x

1

, x2

, . . . , xt of the input language as a single in-stance (y, k) of the output, parameterized one. Clearly, we need to somehowinclude all input instances in (y, k), but we need also to encode the ‘OR’ be-haviour. A natural approach would be to design some gadget that ‘chooses’which instance xi we are going to actually solve. A bit more precisely, suchan instance selector � should interact with a potential solution to (y, k) in tdi↵erent ways, called states. In one direction, if we choose state i on � andsolve the instance xi, we should be able to obtain a valid solution to (y, k).In the second direction, a valid solution to (y, k) that sets � in state i shouldyield a solution to xi.

In the design of instance selectors we will often heavily rely on the fact thatthe parameter k of the output instance (y, k) may depend polylogarithmicallyon the number of input instance. In particular, the state i of the instanceselector will often reflect the binary representation of the integer i.

We now illustrate the concept of instance selector with a simple exampleof the Set Splitting problem. Here, we are given a universe U and a familyF of subsets of U ; the goal is to choose a subset X ✓ U that splits each setin F . We say that a set X splits a set A if both A\X 6= ; and A\X 6= ;. Weare interested in the parameterization k = |U |. We remark that this problemhas a trivial brute-force FPT algorithm running in time O⇤(2k).

It is not hard to prove that Set Splitting is NP-hard by a direct re-duction from the satisfiability of CNF formulas. In this section we prove thefollowing.

Theorem 10.11. There exists a cross-composition from Set Splitting toitself, parameterized by the size of the universe. Consequently, Set Splittingparameterized by |U | does not admit a polynomial compression, unless NP ✓coNP/ poly.

Before we dive into the composition, let us comment what Theorem 10.11actually means: There are instances of Set Splitting where the family Fis much larger than the universe U , and we do not expect that any e�cient(polynomial-time) algorithm is able to sparsify such a family F .


instance selector1 + log t pairs of vertices

universe U

Fig. 10.3: Part of the construction in the proof of Theorem 10.11 for s =log t = 4. The depicted sets are A0 (elements in circles) and A1 (elements inrectangles) for some 4-element set A 2 Fi and i = 5 = 0101

2

.

Proof (Proof of Theorem 10.11). By choosing an appropriate polynomialequivalence relation R, we may assume that we are given a family of t SetSplitting instances (Fi, Ui)

t�1

i=0

where |Ui| = k for each i. Let us arbitrarilyidentify all sets Ui; henceforth we assume that all input instances operate onthe same universe U of size k.

Note that we have numbered the input instances starting from 0: in thisway it is more convenient to work with the binary representations of indicesi. For the same reason, we duplicate some input instances so that t = 2s

for some integer s. Note that this step at most doubles the number of inputinstances.

We now proceed to the construction of an instance selector. The selectorshould have t states; if it attains state i, it should make all input instances‘void’ except for the i-th one. We create 2(s + 1) new vertices � = {d�↵ : 0 ↵ s,� 2 {0, 1}} and define U = U [ � . The new vertices are equiped witha family F� = {{d0

↵, d1

↵} : 0 ↵ s} of sets that force us to choose exactlyone vertex from each pair {d0

↵, d1

↵} into the solution X. Intuitively, the choicewhich vertex to include into the solution X for 1 ↵ s corresponds to thechoice of the input instance (Fi, U); the additional pair for ↵ = 0 is neededto break the symmetry.

We are now ready to formally define the family F for the output instance.We start with F = F� and then, for each input instance (Fi, U) we proceedas follows. Let i = b

1

b2

. . . bs be the binary representation of the index i,b↵ 2 {0, 1} for 1 ↵ s; note that we add leading zeroes so that the lengthof the representation is exactly s. Define b

0

= 0. For each A 2 Fi we insertthe following two sets into the family F (see also Figure 10.3):

A0 = A [ {db↵

↵ : 0 ↵ s} and A1 = A [ {d1�b↵

↵ : 0 ↵ s}.

We output the instance (F , U). Note that |U | = |U |+2(s+1) = k+2(log t+1)and, moreover, the construction can be performed in polynomial time. Thus,

10.2 Examples 319

to finish the proof we need to show that (F , U) is a YES-instance of SetSplitting if and only if one of the instances (Fi, U) is.

In one direction, let X be a solution to the instance (Fi, U) for some0 i < t. Moreover, let b

1

b2

. . . bs be the binary representation of the indexi. Define b

0

= 0 and consider the set X defined as

X = X [ {db↵

↵ : 0 ↵ s}.

Clearly, X splits each set in F� , as for each ↵, 0 ↵ s, it holds thatexactly one of vertices d0

↵ and d1

↵ belongs to X and exactly one does not.The assumption that X is a solution to (Fi, U) implies that X splits alsoeach set A 2 Fi, so in particular it splits A0 and A1. Finally, take any j 6= iand any A 2 Fj . Since j 6= i, indices i and j di↵er on at least one binary

position, say ↵. Now observe that d0

0

2 X \ A0 and d1�b↵

↵ 2 A0 \ X, andd1

0

2 A1 \ X and db↵

↵ 2 A1 \ X. Consequently, X splits both A0 and A1.In the other direction, let X be a solution to (F , U). As U \X is a solution

as well, without loss of generality we may assume that d0

0

2 X. Note thatsince X splits each set of F� , for each 0 ↵ s exactly one of vertices d0

↵

and d1

↵ belongs to X and one does not. Let then b↵ 2 {0, 1} be such an indexthat db

↵

↵ 2 X and d1�b↵

↵ /2 X, for 0 ↵ s. Note that b0

= 0.Let 0 i < t be such that b

1

b2

. . . bs is the binary representation of theindex i. We claim that X = X \U is a solution to the input instance (Fi, U).Consider any A 2 Fi. Observe that X \ � = A0 \ � and, since X splits A0

we have A \ X = A0 \ X 6= ;. Moreover, X \ A1 \ D = ; and, since X splitsA1 we have A\X = A1 \ X 6= ;. Hence X splits A and the lemma is proven.

10.2.2 Polynomial parameter transformations: GraphMotif and Steiner Tree

In the classic theory of NP-hardness we very rarely show that a particularproblem L is NP-hard using the definition. Instead of proving from scratchesthat every problem in NP is polynomial-time reducible to L, we can ben-efit from the work of Cook and Levin who proved this for satisfiability ofpropositional formulas, and just construct a polynomial-time reduction froma problem that is already known to be NP-hard. Thus we can focus on onewell-chosen hard problem as the source language of the reduction, rather thanon an arbitrary problem in NP.

In the world of kernel lower bounds, the situation is somewhat similar:an explicit lower bound via the composition framework does not seem aschallenging as re-proving the Cook-Levin theorem (since we in fact re-usethe result of Fortnow and Santhanam), but in many cases it is easier to‘transfer’ hardness from one problem to another. To be able to do so, weneed an appropriate notion of reduction.


Definition 10.12. Let P, Q ✓ ⌃⇤ ⇥ N be two parameterized problems. Apolynomial-time algorithm A is called a polynomial parameter transformation(PPT, for short) from P to Q if, given an instance (x, k) of the problem P , inpolynomial time outputs an equivalent instance (x, k) of the problem Q, i.e.(x, k) 2 P if and only if (x, k) 2 Q, such that k p(k) for some polynomialp(·).

Let us verify that the reductions defined as above indeed serves our needs.Assume that, apart from a PPT A from P to Q, there exists a compressionalgorithm B for problem Q that, given an instance (x, k), in polynomial timeoutputs an instance y of some problem R of size bounded by pB(k) for somepolynomial pB(·). Consider pipelining algorithms A and B: given an instance(x, k) of P , we first use algorithm A to reduce it to an equivalent instance(x, k) of Q, and then use algorithm B to compress it to an equivalent in-stance y of R. Observe that |y| pB(k) and k p(k), hence |y| is boundedpolynomially in k. Since all computations take polynomial time, we obtaina polynomial compression of P into R. This reasoning allows us to state thefollowing.

Theorem 10.13. Let P, Q ✓ ⌃⇤ ⇥ N be two parameterized problems andassume there exists a polynomial parameter transformation from P to Q.Then, if P does not admit a polynomial compression, neither does Q.

Hence, if we want to show kernelization hardness for problem Q, it su�cesto ‘transfer’ the hardness from some other problem P , for which we alreadyknow that (probably) it does not admit a polynomial compression. We remarkthat Theorem 10.13 uses the notion of compression instead of kernelization:if we liked to prove an analogous statement for polynomial kernelization, wewould need to provide a way to reduce ‘back’ Q to P (in an unparameterizedway). This, in turn, requires some additional assumptions, for example NP-hardness of P and Q 2 NP. Luckily, the composition framework refutesthe existence of not only polynomial kernelization, but also any polynomialcompression, and we can use the (simpler) statement of Theorem 10.13.

We illustrate the usage of PPTs on the example of the Steiner Treeproblem. Here, given a graph G with some terminals T ✓ V (G), and aninteger k one asks for a connected subgraph of G that both contains allterminals and has at most k edges. Note that without loss of generality wemay assume that the subgraph in question is a tree, as we care only aboutconnectivity. We are interested in the parameterization by k.

A direct composition for Steiner Tree may be quite involved and dif-ficult. However, we make our life much easier by choosing an appropriateauxiliary problem: for this problem a composition algorithm is almost trivial,and a PPT reduction to Steiner Tree is also relatively simple.

The auxiliary problem that will be of our interest is called Graph Motif.In this problem we are given a graph G, an integer k and a coloring c ofvertices of G into k colors (formally, any function c : V (G) ! [k]). The task

10.2 Examples 321

G

T

Fig. 10.4: Reduction from Graph Motif to Steiner Tree. Black verticesare terminals. The shape of a non-terminal vertex corresponds to its colourin the input Graph Motif instance. A solution to Graph Motif withadditional edges for corresponding solution to Steiner Tree is highlightedwith thick edges and gray nodes.

is to find a connected subgraph H of G that contains exactly one vertex ofeach colour (and hence has exactly k vertices). The Graph Motif problemis NP-hard even if we restrict the input graphs to be trees of maximum degree3.

Observe now that a disjoint union yields a composition algorithm forGraph Motif. More precisely, given any number of Graph Motif instances(Gi, ki, ci)t

i=1

with the same number of colours k = ki, the connectivity re-quirement ensures that an instance (

Uti=1

Gi, k,St

i=1

ci) is a YES-instance to

Graph Motif if and only if one of the instances (Gi, ki, ci) is; here,Ut

i=1

Gi

denotes the disjoint union of graphs Gi. Hence, using the aforementionedNP-hardness of Graph Motif we may state the following.

Theorem 10.14. Graph Motif cross-composes to itself parameterized byk, the number of colours. Consequently, Graph Motif parameterized by kdoes not admit a polynomial compression, unless NP ✓ coNP/ poly.

Thus, we have obtained a hardness result for Graph Motif almost ef-fortlessly. It remains to ‘transfer’ this result to Steiner Tree.

Theorem 10.15. There exists a PPT from Graph Motif parameterized bythe number of colours to Steiner Tree parameterized by the size of the tree.Consequently, Steiner Tree parameterized by the size of the tree does notadmit a polynomial compression, unless NP ✓ coNP/ poly.

Proof. Let (G, k, c) be a Graph Motif instance. Without loss of generalityassume that k > 1, since otherwise the instance is trivial: we can solve itin polynomial time and output a dummy YES- or NO-instance of SteinerTree. We construct a graph G from G by creating k new terminals T ={t

1

, t2

, . . . , tk}, one for each colour, and making each terminal ti adjacent toc�1(i), that is, to all vertices of colour i; see Figure 10.4. Let k = 2k � 1.


We claim that (G, T , k) is a YES-instance of Steiner Tree if and only if(G, k, c) is a YES-instance of Graph Motif.

In one direction, let H be a solution of the Graph Motif instance(G, k, c). Without loss of generality assume that H is a tree; hence |V (H)| = kand |E(H)| = k � 1. Let vi 2 V (H) be the vertex of colour i in the subgraphH. Observe that H = H [ {viti : 1 i k} is a connected subgraph of G,containing all terminals ti and having exactly 2k � 1 = k edges.

In the other direction, let H be a solution of the Steiner Tree instance(G, T , k). As H is connected at has at most 2k � 1 edges, it contains at mostk non-terminal vertices. Recall that we assumed k > 1. Since ti 2 V (H) forany 1 i k, H needs to contain a neighbour vi of ti in G. By construction,vi 2 V (G) and c(vi) = i; in particular, all vis are pairwise distinct. However,|V (H)| k + 1 = 2k, hence the vertex set of H is exactly T [ {vi : 1 i k}. In particular, each vertex ti is of degree 1 in H and, consequently,H = H \ T is connected. Observe that H is a subgraph of G, and containsexactly one vertex vi of each colour i. Hence, (G, k, c) is a YES-instance toGraph Motif, and the claim is proven.

Finally, observe that the aforementioned construction can be performedin polynomial time, and k = 2k � 1 is bounded polynomially in k. Hence,the presented construction is indeed a PPT from Graph Motif to SteinerTree.

We remark that there are also other natural parameterizations of SteinerTree: we can parameterize by |T |, the number of terminals, or by k+1� |T |,the number of non-terminal vertices of the tree in question. While the latterparameterization yields a W [2]-hard problem, recall that for the parameteri-zation by |T | there exists an FPT algorithm with running time O⇤(2|T |). Sincereference?reference?|T | k + 1, in Theorem 10.15 we have considered a weaker parametereriza-tion than by |T |, and so Theorem 10.15 refutes also existence of a polynomialcompression for the parameterization by |T |, under NP * coNP/ poly.

10.2.3 A more involved one: Set Cover

In the case of Set Splitting the construction instance selector was somehownatural. Here we present a more involved reduction that shows a lower boundfor a very important problem, namely Set Cover. An input to Set Coverconsists of a universe U , a family F of subsets of U and an integer `. The goalis to choose at most ` sets from the family F that cover the entire universeU . That is, we are looking for a subfamily X ✓ F such that |X | ` andSX = U .

It is more convenient for us to work with a graph-theoretic formulationof Set Cover, namely the Red-Blue Dominating Set problem (RBDSfor short): Given a bipartite graph G with partite sets R and B (henceforth

10.2 Examples 323

called red and blue vertices, respectively) and an integer `, find a set X ✓ R ofat most ` vertices that together dominate the entire set B, i.e., N(X) = B.To see that these problems are equivalent, note that given a Set Coverinstance (U, F , `), one may set R = F , B = U , and make each set A 2 Fadjacent to all its elements; the condition

SX = U translates to N(X ) = Uin the constructed graph.

The goal of this section is to show a kernelization lower bound for SetCover, parameterized by the size of the universe, |U |. Recall that for thisparameterization we have a simple FPT algorithm with running O⇤(2|U |)that performs dynamic programming on subsets of U . TODO: referenceEquivalently, we are interested in RBDS, parameterized by |B|.Theorem 10.16. Set Cover, parameterized by the size of the universe,does not admit a polynomial compression unless NP ✓ coNP/ poly.

Our first step is to move to a variant of this problem, called ColoredRed-Blue Dominating Set (Col-RBDS for short), where the red sideR is partitioned into ` sets, R = R1 [ R2 [ . . . [ R`, and the solution setX is required to contain exactly one vertex from each set Ri. We will oftenthink of sets R1, R2, . . . , R` as of colors, and we are looking for a colorfulsolution in a sense that the solution needs to pick exactly one vertex of eachcolor. We parameterize Col � RBDS by |B| + `, that is, we add the numberof colors to the parameter. Observe that RBDS becomes polynomial for` � |B| (each vertex w 2 B may simply greedily pick one ‘private’ neighbourin R), so in this problem the parameterization by |B| + ` is equivalent to theparameterization by |B|. However, this is not the case for Col-RBDS, andtherefore we explicitely add ` to the parameter.

We now formally show that RBDS and Col-RBDS are equivalent.

Lemma 10.17. RBDS, parameterized by |B|, and Col-RBDS, parameter-ized by |B| + `, are equivalent with respect to polynomial parameter transfor-mations. That is, there exists a PPT from one problem to the other, and viceversa.

Proof. In one direction, observe that, given a RBDS instance (G, `), we mayreplace each vertex v 2 R with its ` copies {vj : 1 j `} (keeping theirneighbourhood in B) and define Rj = {vj : v 2 R} for 1 j `. Thisgives a PPT from RBDS to Col-RBDS with considered parameterizations,providing that ` < |B|. Otherwise, as discussed before, the input RBDSinstance is polynomial-time solvable, and having solved it we may output atrivial YES- or NO-instance of Col-RBDS of constant size.

The second direction is a bit more involved. Let (G, `) be an instance ofCol-RBDS. Create a graph G from G by adding ` new vertices w1, w2, . . . , w`

to the blue side B, and making each wj adjacent to all the vertices of Rj ,for 1 j `. We claim that (G, `) is an equivalent instance of RBDS; aswe parameterize Col-RBDS by |B|+ `, this construction will yield a desiredPPT from Col-RBDS to RBDS. To see the claim, note that to dominate


R

1

1

R

2

1

R

3

1

R

4

1

R

5

1

1

. . .

`colours

z}|

{

B

�⇥ {4}

R

1

2

R

2

2

R

3

2

R

4

2

R

5

2

2

. . .

`colours

z}|

{

B

�⇥ {4}

R

1

3

R

2

3

R

3

3

R

4

3

R

5

3

3

. . .

`colours

z}|

{

B

�⇥ {4}

R

1

4

R

2

4

R

3

4

R

4

4

R

5

4

4

. . .

`colours

z}|

{

B

�⇥ {4}

R

1

5

R

2

5

R

3

5

R

4

5

R

5

5

5

. . .

`colours

z}|

{

B

�⇥ {4}

R

1

t

R

2

t

R

3

t

R

4

t

R

5

t

t

. . .

`colours

z}|

{

B

�⇥ {4}

Fig. 10.5: Gadget in the cross-composition for Col-RBDS with ` = 5 colours.The vertices from R1

3

are adjacent to the circle-shaped vertices, and the ver-tices from R4

3

to the square-shaped ones.

each vertex wj it is su�cient and necessary to take a vertex of Rj into theconstructed solution X. Therefore, any solution of the RBDS instance (G, `)needs to contain at least one vertex from each set Rj , and since it containsat most ` vertices in total, it must contain exactly one vertex from each setRj . Consequently, a set X ✓ V (G) of size at most ` is a solution of the Col-RBDS instance (G, `) if and only if it is a solution of the RBDS instance(G, `), and we are done.

Lemma 10.17 allows us to focus on Col-RBDS. The enhanced structureof this problem allows us to design a cross-composition, concluding the proofof Theorem 10.16.

Lemma 10.18. Col-RBDS cross-composes to itself, parameterized by |B|+`.

Proof. By choosing an appropriate polynomial equivalence relation, we mayassume that we are dealing with a sequence (Gi, ì)

t�1

i=0

of Col-RBDS in-stances with equal number of blue vertices, denoted by n, and equal budget` = ì. For a graph Gi, we denote by Bi and Ri = R1

i [R2

i [ . . .[Rì its partite

sets, and the partition of the set of red vertices into ` colors. We remark that

10.2 Examples 325

we again number the input instances starting from 0 in order to make use ofthe binary representation of the index i.

Our first step is to construct a graph H as follows. We first take a disjointunion of the graphs Gi, and then we arbitrarily identify all blue sides Bi intoone set B of size n, which constitutes the blue side of H. The red side ofH is defined as R =

St�1

i=0

Ri, and partitioned into colors Rj =St�1

i=0

Rji , for

1 j `. We remark that the Col-RBDS instance (H, `) is not necessarilyequivalent to the logical OR of all input instances (Gi, ì): a solution to (H, `)may contain vertices that originate from di↵erent input instances Gi. We nowdesign a gadget — an instance selector in fact — that will prohibit such abehaviour.

Let s be the smallest integer such that t 2s; note that s = O(log t). Let� = {d�↵ : 1 ↵ s,� 2 {0, 1}}. For each 1 i t, let b

1

b2

. . . bs be thebinary representation of the index i, and let �(i) = {db

↵

↵ : 1 ↵ s} and�(i) = � \ �(i).

We defineB = B [ (� ⇥ {2, 3, . . . , `}) .

That is, we make ` � 1 copies of the set � , indexed by integers 2, 3, . . . , `,and add them to the blue side of the graph H. Finally, for each 1 i twe make each vertex of R1

i adjacent to all the vertices of �(i) ⇥ {2, 3, . . . , `}and for each 2 j ` we make each vertex of Rj

i adjacent to all the verticesof �(i) ⇥ {j}; see Figure 10.5. Let us denote the resulting graph by G. Weclaim that the Col-RBDS instance (G, `) is a YES-instance if and only ifone of the instances (Gi, ì) is a YES-instance. As the construction can beperformed in polynomial time, and |B| = |B|+ |� |(`�1) = O((|B|+ `) log t),this claim would conclude the proof of the lemma.

Before we start the formal proof, let us give some intuition. To solve (G, `),we need to pick a vertex xj from each colour Rj . We would like to ensurethat whenever x1 2 Ri, then xj 2 Ri as well for all j. This is ensured by theblue vertices in � ⇥ {j}: only x1 and xj may dominate them, and each suchvertex dominates only s = |� |/2 vertices from � ⇥ {j}. Hence, to dominatethe entire � ⇥ {j}, we need to pick such xj that dominates the complementof the neighbourhood of x1. This, in turn, is only satisfied if both x1 and xj

originate from the same input instance. Let us now proceed to the formalargumentation.

In one direction, let X = {x1, x2, . . . , x`} be a solution to an instance(Gi, ì), where xj 2 Rj

i for 1 j `. We claim that X is a solution to (G, `)as well. Clearly, it contains exactly one vertex in each set Rj and B ✓ N

ˆG(X).

It remains to show that X dominates also the new vertices of B. To this end,consider an index j, where 2 j `. By construction, x1 is adjacent to�(i) ⇥ {j}, whereas xj is adjacent to �(i) ⇥ {j}. Hence, � ⇥ {j} ✓ N

ˆG(X).As the choice of j was arbitrary, we have that � ⇥ {2, 3, . . . , `} ✓ N

ˆG(X),

and X is a solution to (G, `).


In the second direction, let X = {x1, x2, . . . , x`} be a solution in theinstance (G, `). We claim that there exists 1 i t such that X ✓ Ri;this would imply that X is a solution to (Gi, ì) as well, finishing the proofof the equivalence. Assume that x1 2 Ri and xj 2 Ri0 for some 1 j `.Consider the vertices of � ⇥{j}. By the construction, the neighbours of x1 inthis set are �(i)⇥ {j}, the neighbours of xj in this set are �(i0)⇥ {j}, and noother vertex of X has a neighbour in �⇥{j}. Since |�(i)| = |�(i0)| = s = |� |/2and �(i)[�(i0) = � , we infer that �(i) = �(i0) and, consequently, i = i0. Thisfinishes the proof of the claim, of Lemma 10.18 and of Theorem 10.16.

We remark here that there are other natural parameters of Set Coverto consider: we may parameterize it by `, or by |F| (which in the languageof RBDS means parameterization by |R|). It is easy to see that the firstparameterization generalizes Dominating Set parameterized by the solu-tion size, and hence is W [2]-hard. For parameterization by |F| we have atrivial FPT algorithm working in O⇤(2|F|) time that checks all subsets of F .It can be proven that also for this parameterization existence of a polyno-mial kernel may be refuted under the assumption of NP * coNP/ poly; seeExercise 10.4.10.

10.2.4 Structural parameters: Clique parameterized bythe vertex cover number

Our last example concerns the so-called structural parameters: instead ofconsidering a natural parameter such as solution size, we parameterize bysome structural measure of the input graph, such as treewidth or cliquewidth.In this section we focus on the classic Clique problem, parameterized by thevertex cover number of the input graph.

More formally, we assume that an input consists of a graph G, and integer` and a vertex cover Z ✓ V (G) of graph G. The task is to check whether Gcontains a complete subgraph on ` vertices. We parameterize by |Z|, the sizeof the vertex cover given as an input.

One may wonder why we assume a vertex cover is given on the input:a second option would be to consider a variant where no vertex cover ispresent, and we only (theoretically) analyse the algorithm in terms of thesize of minimum vertex cover of the input graph. However, as the minimumvertex cover problem admits an e�cient 2-approximation algorithm, from thepoint of view of parameterized algorithms and polynomial kernelization thesevariants are equivalent: we may always compute an approximate vertex coverand use it as the input set Z.

We remark also that Clique, parameterized by the vertex cover number,is trivially fixed-parameter tractable: any clique in G may contain at most onevertex outside Z, so a brute-force algorithm may consider only 2|Z|(|V (G)|�

10.2 Examples 327

P

{gi : 1 i t}

.

.

.

v

1

.

.

.

v

2

.

.

.

v

3

.

.

.

v

4

.

.

.

vn

. . .

1

. . .

2

. . .

3

. . .

`

F

�n2

�triples

uv

all

¬u ¬v

Fig. 10.6: An illustration of the cross-composition for Clique parameterizedby the vertex cover number. The vertex f¬u

uv for u = v2

is adjacent to allvertices in P except for the column with subscript u.

|Z|+1) possible solutions. Recall that, in contrary, the standard solution-sizeparameterization of Clique yields a W [1]-hard problem.

Our goal in this section is to show that our structural parameterizationof Clique does not admit a polynomial compression. That is, we show thefollowing.

Theorem 10.19. Clique cross-composes to itself, parameterized by the ver-tex cover number. Consequently, Clique parameterized by the vertex covernumber does not admit a polynomial compression, unless NP ✓ coNP/ poly.

Proof. By choosing an appropriate polynomial equivalence relation, we mayassume that we are given a sequence (Gi, ì)t

i=1

of (unparameterized) Cliqueinstances, where n = |V (Gi)| and ` = ì for all i. Without loss of generalityassume ` n. Let us arbitrarily identify the vertex sets of the input graphs,so henceforth we assume that V (Gi) = V for each i, 1 i t. We are goingto construct a clique instance (G, ˆ) with vertex cover Z of size boundedpolynomially in n.

The graph G will consist of two parts: one small central part, where theclique in question is chosen, and a large scattered part, where we choosein which input instance the clique resides. The scattered part will be anindependent set: this ensures that the small central part is actually a vertexcover of G.

For the scattered part, we construct simply a vertex gi for each inputgraph Gi. As promised, these vertices are pairwise non-adjacent. The choice


of which vertex gi we include in the solution to (G, ˆ) determines the choiceof the instance where we actually exhibit a solution.

For the central part, we start with creating n` vertices P = {pav : v 2

V, 1 a `}. We make pav adjacent to pb

u if and only if v 6= u and a 6= b.Note that this ensures that every maximum clique in G[P ] has ` vertices: itcontains exactly one vertex pa

v for each index a, and at most one vertex pav for

each index v. We also create 3�n2

�

vertices F = {fall

uv , f¬uuv , f¬v

uv : uv 2 �V2

�} andmake every two of them adjacent if they have di↵erent subscripts. Moreover,the vertex fall

uv is adjacent to all vertices of P , whereas vertex f¬uuv is adjacent

to P \ {pau : 1 a `} and f¬v

uv is adjacent to P \ {pav : 1 a `}; see

Figure 10.6.First, for each input graph i, 1 i t, we make gi adjacent to all the

vertices of P . Then, for each uv 2 �n2

�

, we make gi adjacent to fall

uv if uv 2E(Gi), and to both f¬u

uv and f¬vuv otherwise. Finally, we set ˆ= 1 + ` +

�n2

�

.Clearly, the construction can be performed in polynomial time. Moreover,P [ F is a vertex cover of G of size n` + 3

�n2

�

= O(n2). To finish the proof

of the theorem it su�ces to show that there exists an ˆ-vertex clique in G ifand only if one of the input graph Gi contains an `-vertex clique.

To give some intuition, let us first explore how an ˆ-vertex clique may looklike in graph G. Such a clique X may contain only one vertex gi, at most `vertices of P (one for each index a) and at most

�n2

�

vertices of F (one for

each uv 2 �V2

�

). However, ˆ = 1 + ` +�n2

�

; hence, X contains exactly onevertex gi, exactly one vertex pa

v for each 1 a ` and exactly one vertexamong vertices fall

uv , f¬uuv or f¬v

uv for each uv 2 �V2

�

. The choice of gi determinesthe instance we are actually solving, the choice of the vertices of P encodesa supposed clique in Gi, whereas the vertices in F verify that the chosenvertices of P indeed correspond to a clique in Gi. Let us now proceed to aformal argumentation.

Assume first that X = {x1, x2, . . . , x`} induces an `-vertex clique in someinput graph Gi. Construct X as follows: first, take X = {gi}[{pa

xa

: 1 a `} and then, for each uv 2 �V

2

�

, add fall

uv to X if uv 2 E(Gi), add f¬uuv to X if

uv /2 E(Gi) and u /2 X and add f¬vuv to X if uv /2 E(Gi), u 2 X and v /2 X.

Note that the fact that X induces a clique implies that it is not possiblethat uv /2 E(Gi) and u, v 2 X and hence the presented case distinction isexhaustive. It is straighforward to verify that X induces a clique in G of sizeˆ= 1 + `+

�n2

�

.

In the other direction, let X induce an ˆ-vertex clique in G. As discussed,X needs to contain exactly one vertex gi, exactly one of the vertices fall

uv , f¬uuv

or f¬vuv for each uv 2 �V

2

�

, and exactly one vertex paxa

for each 1 a `, wherethe vertices xa are pairwise di↵erent. We claim that X = {xa : 1 a `} isan `-vertex clique in Gi. Clearly |X| = `, so it remains to prove that Gi[X]is a clique.

By contrary, assume that xaxb /2 E(Gi) for some 1 a, b `, a 6= b. Bythe construction, gi is not adjacent to fall

xaxb

and, consequently, either f¬xa

xaxb

10.3 Weak compositions 329

or f¬xb

xaxb

belongs to X. However, the first one is not adjacent to paxa

2 X, and

the latter is not adjacent to pbxb

2 X. This contradicts the assumption that

X induces a clique in G, and concludes the proof of Theorem 10.19.

10.3 Weak compositions

The tools that we have seen so far are only able to distinguish problems havingpolynomial kernels from those that do not admit such preprocessing routines.However, is it possible to prove more refined lower bounds for problems whichactually do possess polynomial kernels? For example, in Chapter ?? we havelearnt a basic kernelization algorithm for Vertex Cover that returns aninstance with at most 2k vertices, which therefore can be encoded usingO(k2) bits. At first glance, it seems implausible to obtain a kernel that canbe encoded in a subquadratic number of bits. Can we refine our methodologyto develop techniques for proving lower bounds of such type?

The answer to this question is a�rmative, and comes via the framework ofso-called weak compositions. Again, the intuition is very simple. In the pre-vious sections we have not used the full power of the proof of Theorem 10.2.Intuitively, an OR-distillation algorithm has to lose some information fromthe input instances x

1

, x2

, . . . , xt even if the bitsize of the output is boundedby p(maxt

i=1

|xi|) · t1�" for a polynomial p(·) and any " > 0. And indeed,it is easy to verify that our proof of Theorem 10.2 can be adjusted even tothis weaker notion of OR-distillation. Now assume that somebody gave us aversion of cross-composition from some NP-hard language L to the VertexCover problem, whose output parameter k is allowed to be roughly propor-tional to the square root of the number of input instances. More precisely, forany � > 0 we have some polynomial p(·) such that k p(maxt

i=1

|xi|)·t 1

2

+�. Ifthe Vertex Cover problem admitted a compression into bitsize O(k2�"

0)for some fixed "

0

> 0, then by choosing � = "0

/4 and pipelinining the com-position with the compression, we would obtain a contradiction with thestrengthened version of Theorem 10.2.

This motivates the following definition.

Definition 10.20. Let L ✓ ⌃⇤ be an unparameterized language and Q ✓⌃⇤ ⇥ N be a parameterized language. We say that L weakly-cross-composesinto Q if there exists a real constant d � 1, called the dimension, a poly-nomial equivalance relation R, and an algorithm A, called the weak cross-composition, satisfying the following conditions. The algorithm A takes oninput a sequence of strings x

1

, x2

, . . . , xt 2 ⌃⇤ that are equivalent with re-spect to R, runs in time polynomial in

Pti=1

|xi|, and outputs one instance(y, k) 2 ⌃⇤ ⇥ N such that:

(a) for every � > 0 there exists a polynomial p(·) such that k p(maxti=1

|xi|)·t1

d

+�, and


(b) (y, k) 2 Q if and only if there exists at least one index i such that xi 2 L.

The following theorem easily follows from the described adjustments inthe proofs of Theorem 10.2 and Theorem 10.7. We leave its proof as an easyexercise for the reader (Exercises 10.2 and 10.3).

Theorem 10.21. Assume that an NP-hard language L admits a weak cross-composition of dimension d into a parameterized language Q. Assume furtherthat Q admits a polynomial compression with bitsize O(kd�"), for some " > 0.Then NP ✓ coNP/ poly.

Therefore, to refute existence of a polynomial compression for VertexCover with strictly subquadratic bitsize, it su�ces to design a weak cross-composition of dimension 2 from some NP-hard problem to Vertex Cover.It appears that we will be able to elegantly streamline the construction bychoosing the starting problem wisely. The problem of our interest is calledColorful Biclique: We are given a bipartite graph G = (A, B, E) suchthat A is partitioned into k color classes A

1

, A2

, . . . , Ak, each of size n, and Bis partitioned into k color classes B

1

, B2

, . . . , Bk, each of size n. The questionis whether one can pick one vertex from each class Ai and one vertex fromeach class Bi so that the graph induced by the chosen vertices is isomorphicto a complete bipartite graph Kk,k. The Colorful Biclique problem isknown to be NP-hard.

Lemma 10.22. There exists a weak cross-composition of dimension 2 fromthe Colorful Biclique problem to the Vertex Cover problem parame-terized by the solution size.

Proof. By choosing the polynomial equivalence relation appropriately, we canassume that we are given a sequence of well-formed instances I1, I2, . . . , It

having the same values of k and n. More precisely, each Ij contains a bipartitegraph Gj = (Aj , Bj , Ej), each Aj is partitioned into classes Aj

1

, Aj2

, . . . , Ajk,

each Bj is partitioned into classes Bj1

, Bj2

, . . . , Bjk, and |Aj

i | = |Bji | = n for

each i = 1, 2, . . . , k and j = 1, 2, . . . , t. By duplicating some instances ifnecessary, we assume that t = s2 for some integer s.

Construct now a graph H as follows. The vertex set of H consists of 2sclasses of vertices A1, A2, . . . , As, B1, B2, . . . , Bs, each of size kn. Each classA` is further partitioned into classes A`

1

, A`2

, . . . , A`k, each of size n, and the

same is performed for the classes B` as well. The intuition now is that wehave s2 input instances Ij , and s2 pairs (Aj

1 , Bj2) that look exactly as the

partite sets of the graph Gj . Hence, we will pack the information about theedges between Aj and Bj from each input instance Ij into the edge spacebetween Aj

1 and Bj2 for a di↵erent pair of indices (j

1

, j2

).Let ⌧ be any bijecton between [s2] and [s]⇥[s]. The edge set of H is defined

as follows:


ˆ

A

1

1

ˆ

A

1

2

A1

ˆ

A

2

1

ˆ

A

2

2

A2

ˆ

A

3

1

ˆ

A

3

2

A3

ˆ

B

1

1

ˆ

B

1

2B1

ˆ

B

2

1

ˆ

B

2

2B2

ˆ

B

3

1

ˆ

B

3

2B3

�

4

((A

4 ⇥ B

4

) \ E

4

)

Fig. 10.7: The graph H in the proof of Theorem 10.21 constructed for k = 2,n = 3, and t = 9; the highlighted part contains the set of edges between A1

and B2 that is constructed in (c) to encode the input graph G4. To avoidconfusion, the complete bipartite graphs between every pair of classes A`

and between every pair of classes B` have been depicted symbolicly as smallK

2,2-s.

(a) For every 1 `1

< `2

s, introduce an edge between every vertex ofA`

1 and every vertex of A`2 , and an edge between every vertex of B`

1

and every vertex of B`2 .

(b) For every 1 ` s and every 1 i k, make the sets Aì and B`

i intocliques.

(c) For every 1 j t, let ⌧(j) = (j1

, j2

). Fix any bijection �j that, for each

i = 1, 2, . . . , k, matches vertices of Aji with vertices of Aj

1

i , and verticesof Bj

i with vertices of Bj2

i . For every u 2 Aj and v 2 Bj , put an edgebetween �j(u) and �j(v) if and only if the edge uv is not present in Gj .

The role of edges introduced in (a) is to enforce that the solution has a non-trivial behaviour for exactly one of the pairs (Aj

1 , Bj2), which will emulate

the choice of the instance to be satisfied. Edges introduced in (b) and (c)encode the instance itself.

Let us fix the budget for the resulting Vertex Cover instance as k =|V (H)| � 2k = 2snk � 2k. Since s =

pt, this means that the obtained cross-

composition will have dimension 2. We are left with formally verifying thatthe obtained instance (H, k) of Vertex Cover is equivalent to the OR ofthe input instances of Colorful Biclique.

Claim 10.23. If there exists an index j, 1 j t, such that Ij is a YES-instance of Colorful Biclique, then (H, k) is a YES-instance of VertexCover.

Proof. Let Y j be the vertex set of a Kk,k-biclique in the graph Gj , such that

Y j contains exactly one vertex from each color class Aj1

, Aj2

, . . . , Ajk, Bj

1

, Bj2

, . . . , Bjk.

Let us define X = V (H) \ �j(Y j). Since |Y j | = 2k, we have that |X| = k.


We are going to show that X is a vertex cover of H, which will cer-tify that (H, k) is a YES-instance. We prove an equivalent statement thatY = V (H) \ X = �j(Y j) is an independent set in H.

This, however, follows directly from the construction of H. Let (j1

, j2

) =⌧(j) and let us take any distinct u, v 2 Y . If u, v 2 Aj

1 , then u and vhave to belong to two di↵erent classes among Aj

1

1

, Aj1

2

, . . . , Aj1

k , and thereis no edge between any pair of these classes. The same reasoning also holdswhen u, v 2 Bj

2 . However, if u 2 Aj1 and v 2 Bj

2 , then we have that��1

j (u)��1

j (v) 2 Ej , because Y j induces a biclique in Gj . By the constructionof H it follows that uv /2 E(H). y

Claim 10.24. If (H, k) is a YES-instance of Vertex Cover, then thereexists an index j, 1 j t, such that Ij is a YES-instance of ColorfulBiclique.

Proof. Let X be a vertex cover of H of size at most k. Hence, Y = V (H)\Xis an independent set in H of size at least 2k.

We first claim that there are two indices 1 j1

, j2

s such that Y ✓Aj

1 [ Bj2 . Indeed, if there were two di↵erent indices j0

1

and j001

such thatthere existed some u 2 Y \ Aj0

1 and v 2 Y \ Aj001 , then by the construction

of H we would have that uv 2 E(H), which contradicts the fact that Y isan independent set. The same reasoning can be performed for the sets B`.Let then j = ⌧�1(j

1

, j2

); since we have that Y ✓ Aj1 [ Bj

2 , we can defineY j = ��1

j (Y ). The goal is to show that Y j is a solution to the instance Ij .

We now observe that Y j contains at most one vertex from each color classAj

1

, Aj2

, . . . , Ajk, Bj

1

, Bj2

, . . . , Bjk. This follows directly from the fact that each

of the classes Aj1

1

, Aj1

2

, . . . , Aj1

k , Bj2

1

, Bj2

2

, . . . , Bj2

k induces a clique in H. Since|Y j | = |Y | � 2k and there are 2k color classes, we infer that Y j containsexactly one vertex from each color class.

Finally, pick any u 2 Y j \ Aj and v 2 Y j \ Bj , and observe that since�j(u) and �j(v) are not adjacent in H, then u and v are adjacent in Gj .Consequently, Y j induces a Kk,k-biclique in Gj that contains one vertex fromeach color class, and Ij is hence a YES-instance of Colorful Biclique. y

Claims 10.23 and 10.24 conclude the proof of Lemma 10.22.

From Theorem 10.21 and Lemma 10.22 we can derive the following corollary.

Corollary 10.25. For any " > 0, the Vertex Cover problem parameter-ized by the solution size does not admit a polynomial compression with bitsizeO(k2�"), unless NP ✓ coNP/ poly.

Observe now that the lower bounds on the bitsize of a compression canbe transferred in a similar manner via polynomial parameterized transforma-tions as we have seen in Section 10.2.2. It is just the polynomial dependencyof the output parameter on the input one that implies how good lower boundfor the target problem we obtain. For instance, there is a simple polynomial


parameter transformation that takes on input an instance (G, k) of VertexCover and outputs an equivalent instance (G0, k) of Feedback VertexSet: To obtain G0, take every edge uv 2 E(G) and add a vertex wuv thatis adjacent only to u and to v, thus creating a triangle that must be hit bythe solution. By pipelining this reduction with Corollary 10.25, we obtain thefollowing result.

Corollary 10.26. For any " > 0, the Feedback Vertex Set problem pa-rameterized by the solution size does not admit a polynomial compression withbitsize O(k2�"), unless NP ✓ coNP/ poly.

Similarly as with the classic cross-compositions, the lower bounds obtainedvia the framework of weak compositions have a purely information-theoreticalcharacter. We can refute the possibility of packing the information containedin the input instance into a too small bitsize of the output instance, but wehave virtually no control over how the information needs to be organized in,say, the kernel. For instance, Corollaries 10.25 and 10.26 show that obtainingkernels for the Vertex Cover and Feedback Vertex Set problems witha strictly subquadratic number of edges is implausible (since O(k2�") edgescan be encoded in O(k2�" log k) bits). However, for Vertex Cover we knowa kernel that has a linear number of vertices, namely 2k, while no such kernelis known for Feedback Vertex Set: the best known one (given in Chap-ter 6) has O(k2) vertices. It seems hard to understand, using solely weakcompositions as a tool, whether obtaining a kernel for Feedback VertexSet with a subquadratic number of vertices is possible or not.

We state the following theorem for the convenience of the reader, as itprovides a good set of basic problems for further reductions. In the Perfectd-Set Matching problem we are given a universe U , of size divisible by d,and a family F ✓ 2U of subsets of U , each of size d. The question is whetherthere exists a subfamily G ✓ F of size |U |/d such that sets in G are pairwisedisjoint.

Theorem 10.27 ([68, 69]). Let " > 0 be any constant. Unless NP ✓coNP/ poly, the following statements hold:

(a) For any d � 3, the d-SAT problem parameterized by the number of vari-ables n does not have a compression with bitsize O(nd�").

(b) For any d � 2, the d-Hitting Set problem parameterized by |U | doesnot have a compression with bitsize O(|U |d�").

(c) For any d � 3, the Perfect d-Set Matching problem parameterizedby |U | does not have a compression with bitsize O(|U |d�").

Note that for all the considered problems, already the trivial kernelizationalgorithms, which just remove duplicates of clauses or sets in the input, matchthe presented lower bounds.

The proofs of the presented statements are more di�cult, and hence omit-ted in this book. Note that statement (b) for d = 2 is equivalent to Corol-lary 10.25. The proof for d > 2 can be obtained using the same strategy, or


derived by an easy reduction from statement (a). The known proofs of state-ment (a), which was actually the original motivation of introducing the weakcomposition framework, use quite advanced results from the number theory.The proof of statement (c) is a fairly complicated weak cross-composition,however it is self-contained and does not use any external results.

¡¡¡¡¡¡¡ .mine ======= ¿¿¿¿¿¿¿ .r194

Exercises

10.1 (�). In a few places (e.g., Steiner Tree parameterized by either k or |T |) wehave used the following argument: If a problem P admits two parameterizations k

1

andk2

, and k1

is always bounded polynomially in k2

, then a result that refutes existence ofa polynomial compression for the parameterization by k

2

also shows the same for theparameterization by k

1

. Prove formally this statement, using the notion of polynomialparameter transformation.

10.2. Prove that Theorem 10.2 holds even if the output string of an OR-distillation isallowed to have length at most p(maxt

i=1

|xi|) · t1�", for some polynomial p(·) and any" > 0. Would it be possible to use o(t) instead of t1�"?

10.3 (�). Derive Theorem 10.21 from Exercise 10.2.

10.4. In this meta-exercise you are asked to prove that the following parameterized prob-lems do not admit polynomial compressions unless NP ✓ coNP/ poly. In each case, we giveproblem name, the parameter in brackets, and the problem definition. For each problem,you may assume that it is NP-hard (without proof).

Some important definitions: We say that a graph G is d-degenerate for some positiveinteger d if each subgraph of G contains a vertex of degree at most d. For example, forestsare 1-degenerate and planar graphs are 5-degenerate. A bull is a 5-vertex graph H withV (H) = {a, b, c, d, e} and E(H) = {ab, bc, ac, bd, ce}. A proper colouring of a graph G withq colours is a function c : V (G) ! [q] such that c(u) 6= c(v) whenever uv 2 E(G).

1. (�) MaxLeaf Outbranching (k): Does there exist an outbranching with at least kleaves in a given directed graph G? An outbranching is a directed graph that (a) is atree if we supress the directions of the edges (b) is rooted at one vertex, and all edgesare directed away from the root.

2. (�) Max Leaf Subtree (k): Does there exist a subtree of a given graph G with atleast k leaves?

3. Connected Vertex Cover (k): Does there exist a set X of at most k vertices in thegiven graph G, such that G[X] is connected and G \ X is edgeless?

4. Connected Feedback Vertex Set (k): Does there exist a set X of at most k verticesin the given graph G, such that G[X] is connected and G \ X is a forest?

5. Connected Bull Hitting (k): Does there exist a set of vertices X in the given graphG such that G[X] is connected and G \ X does not contain a bull as an inducedsubgraph?

6. 2-deg Connected Feedback Vertex Set (k): The same as Connected FeedbackVertex Set, but the input graph is assumed to be 2-degenerate.

7. 2-deg Steiner Tree(k): The same as Steiner Tree, but the input graph is assumedto be 2-degenerate.

8. 2-deg Connected Dominating Set(k): Does there exist a set of vertices X in thegiven 2-degenerate graph G such that G[X] is connected and NG[X] = V (G)?


9. Set Packing (|U |): Does there exist k pairwise disjoint sets in a given family F ofsubsets of some universe U?

10. Set Cover (|F|): Does there exist ` sets in a given family F of subsets of someuniverse U that together cover the whole U?

11. Directed Edge Multiway Cut with 2 terminals(k): Does there exist a set X ofat most k edges of the given directed graph G with designated terminals s and t, suchthat in G \ X there does not exist a (directed) path from s to t nor from t to s?

12. Disjoint Factors (|� |): Do there exist pairwise disjoint subwords u1

, u2

, . . . , us ofthe input word w over alphabet � = {�

1

, �2

, . . . , �s} such that each ui is of length atleast two and begins and ends with �i?

13. Vertex Disjoint Paths (k): Do there exist vertex-disjoint paths P1

, P2

, . . . , Pk in theinput graph G with designated terminal pairs (s

1

, t1

), (s2

, t2

), . . . , (sk, tk), such thatPi connects si with ti for each i?

14. ( ) Chromatic Number/VC(|Z|): Does there exist a proper colouring of the inputgraph G with q colours? The input consists of the graph G, the integer q and a setZ ✓ V (G) being a vertex cover of G (i.e., G \ Z is edgeless).

15. ( ) Feedback Vertex Set/Cluster Distance(|Z|): Does there exist a set X ✓V (G) of size at most ` such that G \ X is a forest? The input consists of the graphG, the integer ` and a set Z ✓ V (G) such that G \ Z is a cluster graph (i.e., eachconnected component of G \ Z is a clique).

16. ( ) Edge Clique Cover (k): Does there exist k subgraphs K1

, K2

, . . . , Kk of the

input graph G such that each Ki is a clique and E(G) =Sk

i=1

E(Ki)?17. Subset Sum (k + log m): Does there exist a subset X of at most k numbers from

the given set S of positive integers, such thatP

x2X x equals exactly a number mprescribed in the input?

18. ( ) s-Way Cut (k): Does there exist a set X of at most k edges of the input graphG, such that G \ X has at least s connected components? Both numbers s and k aregiven as input.

19. ( ) Eulerian Deletion (k): Does there exist a set of at most k edges in the inputdirected graph G, such that G \ X is eulerian (i.e., weakly connected and each vertexhas equal in- and out-degree)?

10.5. The Odd Cycle Transversal problem asks for a set X of at most k vertices of theinput graph G such that G \ X is bipartite. Prove that, unless NP ✓ coNP/ poly, for any" > 0 Odd Cycle Transversal does not admit a kernel with O(k2�") edges.

10.6. Prove that there exists a function f : Z+

! Z+

with f(d) ! 1 as d ! 1 suchthat if for some d � 2 there exists a kernel of size O(kf(d)) for any of the following twoproblems, restricted to d-degenerate graphs, then NP ✓ coNP/ poly:

1. Connected Vertex Cover,2. Dominating Set.

Hints

10.2 Follow the same proof strategy, but modify the choice of t.

10.4

1 Try disjoint union.2 Try disjoint union.3 Reduce from Set Cover parameterized by the size of the universe.4, 5, 6 Reduce from Connected Vertex Cover.


7, 8 Recall that Graph Motif is NP-hard already on trees. Use this result to improvethe kernelization lower bound for Graph Motif and reduce from this problem.

9 Adjust the cross-composition for Set Cover parameterized by the size of the universe.10 Define a colorful version of the problem and prove that it is equivalent to the original

one. Focus on proving hardness for the colorful version. Design an instance selectorconsisting of 2 log t additional sets in log t new colors. The chosen sets of these colorsshould cover completely the universes of all the input instances apart from exactly one,which should be covered by ‘regular’ sets.

11 Compose the input instances ‘sequentially’. However, enrich the input instances be-fore performing the composition, in order to make sure that the solution to the com-posed instance will not be spread among several of the input instances, but will ratherbe concentrated in one instance.

12 Start the composition with instances over the same alphabet � , and add log t symbolsto � to emulate an instance selector.

13 Reduce from Disjoint Factors.14 Carefully prepare your input language for composition. For example, consider the

task of checking whether a planar graph is properly colourable with 3 colors, which isNP-hard. Note that it is definitely colourable with 4 colors. Design an instance selectorthat allows all input instaces to use 4 colours, except for one instance that may useonly 3.

15 Reduce from a colourful variant of the Set Packing problem.16 Use an AND-cross-composition rather than an OR-cross-composition. You need a

careful construction to ensure that all the edges of the resulting instance are covered.For this, use the following observation: If the input graph contains a simplicial vertex,then we can assume that any solution contains its closed neighbourhood as one of thecliques. Thus, by adding simplicial vertices we can create cliques of edges that will befor sure covered.

17 Make a cross-composition from the same problem, but watch out for the bound onthe number of equivalence classes in the polynomial equivalence relation — you cannotdirectly classify the instances according to their target value m. How to go around thisproblem? Then, design an instance selector to ensure that all integers in the solutioncome from the same input instance.

18 First, show that a weighted variant, where each edge has small integer weight, isequivalent. Then, cross-compose from Clique to the weighted variant. Your intendedsolution should pick one input instance, and cut out all vertices not contained in thesupposed clique as isolated vertices, and leave the rest of the graph as one large con-nected component.

19 Prove NP-hardness and cross-compose the following auxiliary problem: given a di-rected graph G with terminals s and t and some forbidden pairs F ✓ �E(G)

2

�, does there

exist a path from s to t that, for any e1

e2

2 F , does not contain both edges e1

and e2

.

10.5 Reduce from Vertex Cover.

10.6 Reduce from any of the problems considered in Theorem 10.27.

Bibliographic notes

Theorem 10.2 was proved by Fortnow and Santhanam [106]. The first framework for prov-ing kernelization lower bounds that builds upon the work of Fortnow and Santhanamwas proposed by Bodlaender, Downey, Fellows, and Hermelin [23]. This technique, calledOR-composition, is a slightly weaker form of the cross-composition framework that waspresented in this chapter. More precisely, the formalism presented in [23] does not use poly-nomial equivalence relations, assumes that the source and target languages of a composition


are the same, and does not allow the output parameter to depend poly-logarithmically onthe number of input instances. Later it turned out that the lacking features are helpfulin streamlining compositions for many problems, and many authors developed ad-hoc,problem-dependant methods for justifying them. The cross-composition framework, whichwas eventually proposed by Bodlaender, Jansen, and Kratsch [25], elegantly explains whythese features can be added in general. The fact that the whole approach should work whenthe OR function is replaced with AND was initially conjectured by Bodlaender et al. [23];the statement had been dubbed the AND-conjecture. The conjecture was eventually re-solved by Drucker [89], who proved Theorem 10.9. We note that Drucker only states thatexistence of an AND-distillation for an NP-hard problem implies that NP ✓ coNP/ poly,but the slightly stronger statement of Theorem 10.9 also follows from his results.

The lower bound for Set Splitting was first obtained by Cygan, Pilipczuk, Pilipczuk,and Wojtaszczyk [65] via a PPT from Set Cover parameterized by the size of the fam-ily, i.e., Exercise 10.4.10. The lower bound for Steiner Tree was first proved by Dom,Lokshtanov, and Saurabh [78], again via a PPT from Set Cover parameterized by thesize of the family. The proof using Graph Motif as a pivot problem was proposed byCygan, Pilipczuk, Pilipczuk, and Wojtaszczyk [64], and the main point was that the re-sulting graph is 2-degenerate. The example of Set Cover parameterized by the size ofthe universe has been taken from Dom, Lokshtanov, and Saurabh [78]; we note that theoriginal composition was slightly more complicated. Clique parameterized by vertex coverwas one of the first examples of application of the cross-composition framework, and wasgiven by Bodlaender, Jansen and Kratsch [25]. For Exercise 10.4, point 1 originates in [13],points 3, 9, 10, 17 originate in [78], points 7, 8 originate in [64], points 11, 16, 18 originatein [60], points 12, 13 originate in [26], point 14 originates in [128], point 15 originates in[25], and point 19 originates in [61].

The idea of weak compositions originates in the work of Dell and van Melkebeek [69],who proved statements (a) and (b) of Theorem 10.27, and derived Corollary 10.25 from it.The weak composition framework, as presented in this chapter, has been introduced later,independently by Dell and Marx [68] and by Hermelin and Wu [122]. In particular, Delland Marx [68] have proved statement (c) of Theorem 10.27 and reproved statement (b)in a simplified manner. The presented lower bound for kernelization of Vertex Cover isalso taken from [68].

Date post:	15-Feb-2020
Category:	Documents
Upload:	others
View:	3 times
Download:	0 times

Chapter 9 Lower bounds based on the Exponential-Time...

Documents