A Hierarchy of Polynomial Kernels

Abstract

In parameterized algorithmics the process of kernelization is defined as a polynomial time algorithm that transforms the instance of a given problem to an equivalent instance of a size that is limited by a function of the parameter. As, afterwards, this smaller instance can then be solved to find an answer to the original question, kernelization is often presented as a form of preprocessing. A natural generalization of kernelization is the process that allows for a number of smaller instances to be produced to provide an answer to the original problem, possibly also using negation. This generalization is called Turing kernelization. Immediately, questions of equivalence occur or, when is one form possible and not the other. These have been long standing open problems in parameterized complexity. In the present paper, we answer many of these. In particular we show that Turing kernelizations differ not only from regular kernelization, but also from intermediate forms as truth-table kernelizations. We achieve absolute results by diagonalizations and also results on natural problems depending on widely accepted complexity theoretic assumptions. In particular, we improve on known lower bounds for the kernel size of compositional problems using these assumptions.

Appendix (Deferred Proofs)

Theorem 2

There is a parameterized problem that has a polynomial truth-table kernelization but no psize kernelization.

Proof

Given any decidable set V, we can define

parameterized so that for all $x \in {\{\texttt {0}, \texttt {1}\}}^*$, $\kappa (\texttt {0}x) = {|x|}$ and $\kappa (\texttt {1}x) = \log {|x|}$. Clearly, $(X(V), \kappa )$ has a polynomial truth-table kernelization regardless of V: on input $\texttt {0}x$ it queries the oracle for the input, and on input $\texttt {1}x$, with $\log {|x|} \in \mathbb {N}$, it queries the oracle with each string $\texttt {0}y$, for all $y \in {\{\texttt {0}, \texttt {1}\}}^{\log {|x|}}$, and accepts if one of the queries has a positive answer (otherwise it rejects). This procedure runs in polynomial time and makes at most n oracle queries on any input of length $n+1$.

We construct V by diagonalizing against psize kernelization algorithms. To do this, we consider a computable list of TMs such that every machine appears infinitely often. At stage i of the construction we choose n, a power of 2, so that membership in V has not been decided at a previous stage for any strings of length at least $\log n$. We then run the i-th machine on input $\texttt {1}\texttt {0}^n$ for $n^i$ steps. All new oracle queries are answered with ‘no’, all other queries are answered so as to be consistent with previous answers. If the machine at stage i terminates without having queried the oracle for all strings of the form $\texttt {0}y$ with $y \in {\{\texttt {0}, \texttt {1}\}}^{\log n}$, we add an unqueried string of this length to V if and only if the machine rejects.

If P is a psize kernelization, then the number of oracle queries it makes on an input $\texttt {1}x$ is upper-bounded by $q(\log {|x|})$, for some fixed polynomial q. This is clearly $o({|x|})$, so for some sufficiently large i and n, P will terminate without having queried all n strings which can determine the correct answer. Thus, our diagonalization procedure will ensure that it terminates with the incorrect answer. On the other hand, the above-mentioned polynomial truth-table kernelization will always query all necessary strings in order to output the correct answer.     $\square$

Theorem 4

There is a parameterized problem that has a polynomial Turing kernelization but no polynomial truth-table kernelization.

Proof

For any decidable set V we can define the function: $s^V: {\{\texttt {0}, \texttt {1}\}}^*\rightarrow {\{\texttt {0}, \texttt {1}\}}^*$ by

$$\begin{aligned} s^V(q) = {\left\{ \begin{array}{ll} \texttt {0}q &{} \text {if}\, q \notin V, \\ \texttt {1}q &{} \text {if}\, q \in V. \end{array}\right. } \end{aligned}$$

Also for a decidable set V, we define the following parameterized problem:

where the parameterization is defined so that for all $x \in {\{\texttt {0}, \texttt {1}\}}^*$, $\kappa (\texttt {0}x) = {|x|}$ and $\kappa (\texttt {1}x) = \log {|x|}$. The problem X(V) has a polynomial Turing kernelization regardless of the set V: On inputs of the form $\texttt {0}x$, the machine queries the oracle with its input (whose size is linear in the parameter value), and outputs the answer. On inputs of the form $\texttt {1}x$ the machine makes the following $(\log {|x|})^2$ queries: $\texttt {0}^{\log {|x|}+1}$, $\texttt {0}b_1 \texttt {0}^{\log {|x|}}$, $\texttt {0}b_2 b_1 \texttt {0}^{\log {|x|}},\ldots ,\texttt {0}b_{(\log {|x|})^2}\ldots b_1 \texttt {0}^{\log {|x|}}$, where $b_i$ is the outcome of the i-th query, for each $i \le (\log {|x|})^2$. The output is the answer of the last oracle query. Since each of the queries in the second case is of size at most quadratic in $\kappa (1x) = \log {|x|}$, this procedure is a polynomial Turing kernelization.

We now construct the set V so that no polynomial truth-table kernelization can solve X(V). Consider a variant of oracle TMs where the oracle can be queried for an arbitrary number of queries at once. Let $P_1, P_2, \ldots$ be a computable list of all such TMs in which each machine appears infinitely often.

At each stage $i \in \mathbb {N}$, we set n to be the smallest positive integer so that no oracle queries to X(V) at any previous stage of the simulation depend on instances of V of size at least n, and so that $n > i$ and $2^n > n^i$. At stage i of the construction, we run $P_i$ on input $\texttt {1}\texttt {0}^{2^n}$ for $(2^n)^i$ steps (note that this is a polynomial of degree i in $2^n+1$, the size of the input). In case the machine queries the oracle, let S be the set of strings it queries. If S includes strings of length at least $2^n$, we move on to the next stage. In particular, when no query of length $2^n + 1$ is made, $P_i$ is not making a query with prefix 1 that is equivalent to the input. By the time bound, we have ${|S|} \le 2^{ni}<2^{n^2}$, so there must be a string $y = b_{n^2}\ldots b_{2}b_{1}\texttt {0}^{n}$, $b_j \in {\{\texttt {0}, \texttt {1}\}}$, such that $\texttt {0}y$ is not in S. The queries in S are answered as follows: all queries also made at previous stages are answered so as to be consistent with previous answers; all queries of the form $\texttt {0}b_j\ldots b_2b_1\texttt {0}^n$, with $j \le n^2 - 1$, are answered with $b_{j+1}$; all other queries are answered with 0 (‘no’). For all $j \le n^2 - 1$ such that $b_{j+1} = \texttt {1}$, we place $b_j\ldots b_2b_1\texttt {0}^n$ into V. After thus answering the queries in S, we resume the simulation of $P_i$ for the remainder of its allotted $2^{ni}$ steps and treat every subsequent invocation of the query instruction as a crash. Finally, we place y into V if and only if $P_i$ terminated within the time bound and rejected, making $\texttt {1}\texttt {0}^{2^n}$ a ‘yes’-instance if and only the $P_i$ rejects it.

Assume now that there is a polynomial truth-table kernelization for X(V). Such a procedure will eventually be targeted in the above construction. Indeed, a problem has a truth-table kernelization precisely when it is decided by a machine that runs in polynomial time and can make all its queries at once. Let i be such that $P_i$ is a polynomial truth-table kernelization for X(V), running in time $p({|x|})$ on any input of the form $\texttt {1}x$, and non-adaptively making oracle queries of size at most $q(\log {|x|})$, where p and q are fixed polynomials. As this machine occurs infinitely often in the list $P_1, P_2, \ldots$, we may assume that i and its corresponding n are large enough for $P_i$ to terminate on input $\texttt {1}\texttt {0}^{2^n}$, because we have $p(2^n+1) < 2^{ni}$. Moreover, we may assume that i and n are large enough for $q(n)< n^i < 2^n$ to hold. As $P_i$ will not be able to query all strings of the form $\texttt {0}y\texttt {0}^{n}$ with ${|y|} = n^2$, it will, by our construction of V, incorrectly decide some instance of X(V).     $\square$