Kernelization: New Upper and Lower Bound Techniques
Total Page:16
File Type:pdf, Size:1020Kb
Kernelization: New Upper and Lower Bound Techniques Hans L. Bodlaender Department of Information and Computing Sciences, Utrecht University, P.O. Box 80.089, 3508 TB Utrecht, the Netherlands [email protected] Abstract. In this survey, we look at kernelization: algorithms that transform in polynomial time an input to a problem to an equivalent input, whose size is bounded by a function of a parameter. Several re- sults of recent research on kernelization are mentioned. This survey looks at some recent results where a general technique shows the existence of kernelization algorithms for large classes of problems, in particular for planar graphs and generalizations of planar graphs, and recent lower bound techniques that give evidence that certain types of kernelization algorithms do not exist. Keywords: fixed parameter tractability, kernel, kernelization, prepro- cessing, data reduction, combinatorial problems, algorithms. 1 Introduction In many cases, combinatorial problems that arise in practical situations are NP-hard. As we teach our students in algorithms class, there are a number of approaches: we can give up optimality and design approximation algorithms or heuristics; we can look at special cases or make assumptions about the input that one or more variables are small; or we can design algorithms that sometimes take exponential time, but are as fast as possible. In the latter case, a common approach is to start the algorithm with preprocessing. So, consider some hard (say, NP-hard) combinatorial problem. We start our algorithm with a preprocessing or data reduction phase, in which we transform the input I to an equivalent input I that is (hopefully) smaller (but never larger). Then, we solve the smaller input I optimally, with some (exponential time) algorithm. E.g., in practical settings, we can use an ILP-solver, branch and bound or branch and reduce algorithm, or a satisfiability-solver. After we obtained an optimal solution S for S, we transform this solution back to an optimal solution for I. In this overview paper, we want to focus on the following question for given com- binatorial problems: suppose the preprocessing phase takes polynomial time; what can we say about the size of the reduced instance, as a function of some parameter of the input? This question is nowadays phrased as: does the problem we consider have a kernel, and if so, how large is the kernel? So, kernelization gives us quanti- tative insights in what can be achieved by polynomial time preprocessing. In this J. Chen and F.V. Fomin (Eds.): IWPEC 2009, LNCS 5917, pp. 17–37, 2009. c Springer-Verlag Berlin Heidelberg 2009 18 H.L. Bodlaender paper, we aim to first give a general introduction to the field of kernelization, and then survey a number of very recent general techniques from the field. As a simple example, let us look at the Vertex Cover problem. Here, we are given a graph G =(V,E)andsomeintegerk, and ask if there is a set W ⊆ V of at most k vertices, such that for each edge {v, w}∈E at least one endpoint belongs to W (v ∈ W or w ∈ W ). We can use the following ’kernelization’ algorithm, due to Buss, see [26]: while there is at least one vertex v ∈ V with degree at least k +1,removev and its incident edges, and set k to k − 1. This gives equivalent instances: v must belong to an optimal solution, because if we do not take v,wemusttakeallneighborsofv, which are more than k vertices. Also, remove all vertices of degree 0, without changing k. If at some point, k<0, we can decide no: there clearly is no solution. Now, if we have more than k2 edges, we decide no. Each remaining vertex has degree at most k,sowithk vertices, we cannot cover more than k2 edges. If we did not return no,weend with an equivalent instance with at most k2 edges (and less than k2 vertices). The simple algorithm given above is not the best (in terms of ’kernel sizes’) kernelization algorithm for Vertex Cover: a clever algorithm by Nemhauser and Trotter [72] gives reduced instances with 2k vertices. The algorithm above, however, does give a nice example of a methodology that is used in many ker- nelization algorithms: we have a set of ’safe reduction rules’, i.e., rules that give a smaller, equivalent instance, and we have a mathematical analysis on the size of yes-instances when no rule applies. When our input is larger than this size, we return no; otherwise, we have a small reduced instance. For the analysis of kernels, we can fortunately make use of a large toolbox from the field of fixed parameter algorithms, which was pioneered by Downey and Fellows. For background in this field, we refer to [44,52,73]. We use a number of definitions from this field in a form that is useful for this exposition. A parameterized problem is a subset of Σ∗ × N for some fixed alphabet Σ. I.e., we look at decision problems where some specific part of the input, called the parameter, is an integer. The theory of fixed parameter complexity is used to distinguish between the running time for parameterized problem, where we pay attention how this time depends on the parameter and on the input size. Three important types of behavior can be seen: –NP-complete: the problem is NP-complete for some fixed values of k. E.g., Graph Coloring is NP-complete, even when the number of colors is 3. – XP: for every fixed k, there is a polynomial time algorithm, but the exponent of the running time grows with k, i.e., the running time is Θ(nf(k))forsome function f with limk→∞ f(k)=∞. – FPT: there is an algorithm, that solves the problem in time O(f(k)nc)for some function f on inputs of size n with parameter k,withc a constant. FPT is defined as the class of all parameterized problems that have such a kernel. FPT is short for fixed parameter tractable. A kernelization algorithm for a parameterized problem P is an algorithm A,that transforms inputs (I,k)ofP to inputs (I,k)ofP , such that Kernelization: New Upper and Lower Bound Techniques 19 1. the algorithm uses time polynomial in |I| + k; 2. the algorithm transforms inputs to equivalent inputs: (I,k) ∈ P ⇔ A(I,k) ∈ P ; 3. k ≤ k; 4. |I|≤f(k) for some function f: the value of the new parameter and the size of the new input are bounded by a function of the value of the old parameter. We say that P has a kernel of size f. Throughout this paper, we focus on the question for given problems P :doesithaveakernel,andifso,ofwhatsize.Of course, we prefer kernels of small size, and asks ourselves for problems: do they have polynomial kernels. A variant of the definition, giving a slightly different notion of kernelization, has the condition k ≤ f(k) instead of k ≤ k. The topic of kernelization has become a very active of research. An excellent survey on the field was made by Guo and Niedermeier in 2007 [59]. In the past two years, more work has been done, and this paper aims at focussing at some recent developments, where general methods were obtained. A little technical remark. In several cases, we can decide the problem directly. Applying the notion of kernelization would require that we instead transform the problem to an equivalent instance. This can be easily resolved as follows: we take a yes-instance and a no-instance, both of small (constant bounded) size, and instead of deciding, we transform the input to the yes- or no-instance of constant bounded size. This little trick also shows that when a problem (seen as decision problem, we take the parameter in unary) belongs to P ,thenithasa kernel of O(1) size. Also, when a problem has an O(1) kernel, say of size at most c, it belongs to P : we first make a kernel, and then check if this belongs to the set Pc of yes-instances with size at most c. This latter set does not depend on the input, and thus can be hardwired in our algorithm. Thus, when the problem is NP-hard, then it does not have an O(1) kernel, unless P = NP. The theory of fixed parameter complexity gives us an excellent tool to see if a problem has a kernel (i.e., without considering its size.) First, consider the following result, which is nowadays folklore. The main idea of the result is due to Cai et al. [28], while its first statement is due to Neal Koblitz [47] and appeared in [45] in 1997. In a few cases in the literature, the result or its proof are slightly incorrectly stated, see the discussion below. The following proof is given by Flum and Grohe [52] (for the variant of strongly uniformly FPT), see also [73]. Theorem 1. Let P be a parameterized problem. Then P belongs to the class FPT, if and only if P is decidable and P has a kernel. Proof. If P is decidable and has a kernel, then we can use the following algorithm for P . If we have an input (I,k)ofsizen, then we can build in p(n + k)timefor some polynomial p an equivalent instance (I,k), with max(|I|,k) ≤ f(k)for some function f, by using the kernelization algorithm. Then, decide on (I,k) by any algorithm for P ; thus, for some function g, this costs in total O(p(n + k)+g(f(k))) time.