# Kernels in parameterized complexity

Can anyone explain me what (problem-)kernels are and what's the use of them? My slides say:

The kernel of a parameterized problem $L$ is a transformation $(x,k) \mapsto (x',k')$ such that:

• $(x,k) \in L \Leftrightarrow (x',k') \in L$
• $|x'| \leq f(k)$ for some function $f$
• $k' \leq g(k)$ for some function $g$
• transformation must be computed in polynomial time.

My questions are:

• How is this connected with a problem being fixed parameter tractable?
• What makes kernels useful?
• Where does this definition come from.

The example on my slides is for vertex cover, but I don't really get it, cause the slides are kind of short.

• This seems to be about some family of algorithms, but I cannot guess which. Could you give some context. Mar 18, 2015 at 23:47
• This is a rather standard (if not basic) concept in complexity theory. These are things your teacher should have told you, but there is also plenty of material on the web, not to mention books. Where have you looked? Have you even executed a simple search? (cc @babou)
– Raphael
Mar 19, 2015 at 6:59
• @Raphael How is it that a question about NP gets 80 upvotes and you think kernelization complexity is too standard (if not basic) for this site? If the teacher should have told this, we may assume the teacher to also explain P, NP, NP-Complete, and NP-Hard? Mar 21, 2015 at 12:53

Intuitively, a kernelization algorithm is an algorithm which in polynomial time preprocesses a given instance and outputs an instance whose size is bounded in the parameter. The goal of kernelization is (at least) two-fold. We get provable performance guarantees, i.e., we can prove upper bounds on the output instance, which has applications both in the design of algorithms, and also as a complexity measure.

More formally a kernelization algorithm (often referred to as the kernel), is an algorithm for a problem which on an input $(G,k)$ outputs an equivalent instance $(G',k')$ with $\max\{|G'|,k'\} \leq f(k)$ for some function $f$. Furthermore, the algorithm needs to run in polynomial time.

The following result shows that the power of kernels is, so to speak, equivalent to the power of fixed parameter tractability (PDF)

Theorem (Folklore). A problem is fixed parameter tractable if and only if it admits a kernel and is decidable.

Although the notion of kernel coincides with fixed parameter tractability, there is a stronger version of kernelization where we demand the function $f$ above to be a polynomial.

If you want to see the original definitions, I advice you to pick up Downey and Fellows' book on parameterized complexity, or start from Niedermeier's Habilitation thesis mentioned above. There is also a Wikipedia article on Kernelization.

• Thank you so much, that makes things more clear! So basically the goal of kernelization is to get a smaller instance of the problem, which is bounded only to k, so you can solve the problem on the smaller instance in O(f(k)) and get the combined running time (=calculating the kernel + solving the new instance) of something like O(f(k) + p(n)) which is good for small k? Mar 19, 2015 at 0:05
• The note "(Folklore)" suggests that we don't have a formal proof. I seem to remember one, though. How should we interpret what you write?
– Raphael
Mar 19, 2015 at 7:01
• @Raphael, the earliest attribution (I believe) is Rolf Niedermeier's Habilitationsschrift (2002), which was published as a monograph in 2006, but even at that point he states with no reference: "Finally, let us mention in passing that in parameterized complexity theory it has become a commonplace that “every fixed-parameter tractable problem is kernelizable.”". Hence the more traditional attribution to Folklore. Mar 19, 2015 at 8:08
• That's kind of funny, Rolf Niedermeier is the prof who is going to test me soon. Mar 19, 2015 at 10:27
• @LukeMathieson Lemma 4.8 (p. 31) of Parameterized complexity: A framework for systematically confronting computational intractability, Downey, Fellows and Stege, 1997 is: "A parameterized problem $L$ is in FPT if and only if it is kernelizable". (PDF) Mar 20, 2015 at 4:34