Frameworks for Solving Turing Kernel Lower Bound Problem and Finding Natural Candidate Problems in NP-intermediate

# Frameworks for Solving Turing Kernel Lower Bound Problem and Finding Natural Candidate Problems in NP-intermediate

Weidong Luo
Central South University (My Alma Mater), Changsha, P.R. China. E-mail addresses: luoweidong@csu.edu.cn or weidong.luo@yahoo.com
###### Abstract

Kernelization is a significant topic in parameterized complexity. Turing kernelization is a general form of kernelization. In the aspect of kernelization, an impressive hardness theory has been established [Bodlaender etc. (ICALP 2008, JCSS2009), Fortnow and Santhanam (STOC 2008, JCSS 2011), Dell and van Melkebeek (STOC 2010, J. ACM 2014), Drucker (FOCS 2012, SIAM J. Comput. 2015)] based on the assumption that polynomial hierarchy will not collapse, and this hardness theory can obtain lower bounds of kernel size. Unfortunately, this framework is not fit for Turing kernelization. Moreover, so far, there is no tool which can be applied to obtain Turing kernel lower bound for any FPT problem modulo any reasonable complexity hypothesis. Thus, constructing a framework for lower bounds of Turing kernels of FPT problems has received much attention from the parameterized complexity community, and this has been proposed as an open problem in different occasions [Fernau etc. (STACS 2009), Misra etc. (Discrete Optimization 2011), Kratsch (Bulletin of the EATCS 2014), Cygan etc. (Dagstuhl Seminars on kernels 2014)].

Ladner [J. ACM 1975] proved that if P NP, then there exist infinitely many NP-intermediate problems. However, the NP-intermediate problem constructed by Ladner is artificial. Thus, finding natural NP-intermediate problems under the assumption of P NP interests theorists, and it has been a longstanding open problem in computational complexity community.

This paper builds a new bridge between parameterized complexity and classic computational complexity. By using this new connection, some frameworks can be constructed. Based on the assumption that the polynomial hierarchy and the exponential hierarchy will not collapse, these frameworks have three main applications. Firstly, these frameworks can be used to obtain Turing kernel lower bounds of some important FPT problems, thus solving the first open problem. Secondly, these frameworks can also be used to obtain better kernel lower bounds for these problems. Thirdly, these frameworks can be used to figure out a large number of natural problems in NP-intermediate, thus making some contributions to the second open problem.

## 1 Introduction

Parameterized complexity extends classical complexity theory by considering not only the input length but also one or more additional parameters like solution size or structural measures like treewidth. A parameterized problem is a language , where is an alphabet with two or more symbols, and the second component is called the parameter of the problem. Kernelization is a well-known and important topic in parameterized complexity [19, 28, 37]. It is a theoretical formalization of efficient preprocessing to deal with hard languages. The polynomial time preprocessing, which is a kernelization, is used to shrink the size of instance and output an equivalent instance, and the output of the preprocessing is called kernel. Another significant topic in parameterized complexity is fixed-parameter tractable. A parameterized language is fixed-parameter tractable if there exists an algorithm to decide whether in time , where is an arbitrary function depending only on , and the corresponding complexity class is called FPT. There is an important connection between kernelizaiton and FPT, that is, a problem has kernel if and only if the problem is in FPT.

Unless otherwise stated, we will use following definition in this paper. Functions , , are nondecreasing. and are classes of functions.

###### Definition 1.1

(Kernelization) A kernelization for a parameterized language is a polynomial-time Turing machine that given any instance returns an instance such that if and only if and with . We also call the kernelization as -sized kernelization.

We say has an -sized kernelization if has an -sized kernelization for some . For example, if is polynomially (linearly) bounded in , then is a polynomial (linearly) kernelization and we say the language has a polynomial (linearly) kernel.

Kernelization requires that the input and output instances belong to the same language. Without this requirement, the concept of kernelization transforms into the concept of compression.

###### Definition 1.2

(Compression) A compression for a parameterized language is a polynomial-time Turing machine that given any instance returns an instance such that if and only if ( is a language) and with . We also call the compression as -sized compression.

The way we define -sized kernelization can be also used to define -sized compression. Compression is a general type of kernelization. In some languages, we can probably shrink the instances into smaller size with compression rather than kernelization. For example, Wahlström [74] proved that -cycle problem has a -sized compression, but a polynomial kernel has not been found so far.

As more and more techniques for kernelization were found. People realized that it was hard for some problems, such as -path problem, which asks whether a graph has a simple path of length , to obtain small kernels, such as polynomial kernel, by using existing techniques. Thus, to figure out why these problems are so hard to get small kernels, researchers proposed an impressive hardness theory to prove lower bounds for kernel size. In their paper [6], Bodlaender etc. firstly raised two classes of problems. Then, they proved that the problems in one class (including -path) have no polynomial kernels, unless or(SAT) can compress, and that the problems in another class have no polynomial kernels, unless and(SAT) can compress. Fortnow and Santhanam [35] proved that or(SAT) can not be compressed, unless co-NP NP/poly and the polynomial hierarchy collapse. However, and(SAT) had remained an open problem for five years until it was settled by Drucker [29], based on the assumption that there is no nonuniform, statistical zero-knowledge proofs for NP languages, which is a weaker one compared with co-NP NP/poly. Another insightful work of kernel lower bounds is attributed to Dell and van Melkebeek [26]. They gave a framework for proving kernel lower bounds for problems that do admit some polynomial kernelization. For example, they showed that d-SAT has no kernel unless co-NP NP/poly and polynomial hierarchy collapse. Dell and Marx [25], Hermelin and Wu [42] and Bodlaender etc. [7] also made contributions to the hardness theory. Since then, a large amount of researches have been conducted to solve various concrete problems by employing these frameworks [8, 17, 20, 21, 27, 38, 42, 44, 46, 47, 52, 54, 55, 56]. In fact, all of the kernelization lower bound frameworks mentioned above are also fit for compression lower bound. Compression (kernelization) lower bound also means that the smallest size of the output instance can be obtained by compression (kernelization).

However, there are some relaxed notions of kernelization (including Turing kernelization) whose lower bound are not ruled out by any existing techniques, and these relaxed notions had been proposed [30, 37] before the kernelization lower bound framework was raised.

The relaxed notions allow the kernelization algorithm to output many small independent instances. For example, Fernau etc. [34] found the first problem, namely leaf out-tree(), which has no polynomial kernel unless co-NP NP/poly. However, they constructed a polynomial time algorithm for the problem whose input is an instance of leaf out-tree(), whose output is independent kernels of -sized, and where the input is a yes instance if and only if at least one output instance is yes instance ( is the vertices number of the input instance and is the parameter). Because the status of the input instance is equivalent to the disjunction of the status of the output kernels, this polynomial time algorithm is called disjunctive kernelization, which is a type of relaxed notion of kernelization, and the output of this polynomial time algorithm is called disjunctive kernel. With the help of the disjunctive kernelization, we can design an algorithm for the original problem by solving each kernel in turn, and this algorithm only needs to deal with at most independent -sized kernels. Therefore, this kind of relaxed kernel is still useful in practice.

According to the definition of disjunctive kernelization, it is easy to understand other relaxed notions of kernelizations, including conjunctive kernelization, truth-table kernelization and Turing kernelization. The most and least powerful of these three relaxed notions are Turing kernelization and conjunctive kernelization, respectively. In this paper, we mainly discuss the most general relaxed notion of kernelization, i.e. the Turing kernelization. The framework which is fit for Turing kernel lower bounds can also be suitable for other types of kernel lower bounds. We recall the definition of Turing kernelization given by [34] below.

###### Definition 1.3

(-oracle for parameterized language) An -oracle for a parameterized language is an oracle that takes as input with , ( is some integer) and decides whether in constant time.

###### Definition 1.4

(Turing Kernelization) A parameterized language is said to have an -sized Turing kernelization if there is a Turing machine which given an input together with an -oracle for decides whether in time polynomial in .

We say has an -sized Turing kernelization if has an -sized Turing kernelization for some . Like the way define compression, we define Turing compression in the same way by allowing the oracle queries to be any other languages. We will define these variants below.

###### Definition 1.5

(-oracle for classic language) An -oracle for a classic language is an oracle that takes as input with ( is some integer) and decides whether in constant time.

###### Definition 1.6

(Turing Compression) A parameterized language is said to have an -sized Turing compression if there is a Turing machine which given an input together with an -oracle for a classic language decides whether in time polynomial in .

We define -sized Turing compression according to the way we define -sized Turing kernelization.

Turing kernelization is more powerful than other relaxed notions of kernelizations. It could even adaptively create reduced instances. So far, people have found some problems that have polynomial Turing kernels, but do not have polynomial kernels [2, 7, 34, 45, 70, 73]. Finding framework for lower bounds of Turing kernels has become an important open problem in parameterized complexity community, and it has been proposed as an open problem in different occasions [18, 34, 53, 62]. In particular, during Dagstuhl Seminars on Kernels in 2014, Cygan etc. [62] gave a list of open problems and ranked them according to their importance and possible hardness, and this problem is one of the most important and difficult problems in the list. Unfortunately, Unlike lower bounds of kernels, until now, there is no technique that can deal with lower bounds of Turing kernels (even for truth-table kernels and disjunctive kernels) for any FPT problem modulo any reasonable complexity hypothesis. The positive aspect is that the polynomial conjunctive kernels can be refuted by modifying the framework of the lower bounds of many-one kernels [52]. There are also some other works related to this problem. Hermelin etc. [41] introduced a new complexity hierarchy for parameterized problems named WK/MK-hierarchy. The lowest hardness class in the hierarchy is WK[1]. They found some problems are complete for WK[1], and conjectured that no WK[1]-complete problem admits a polynomial Turing kernelization, because if there exists a polynomial Turing kernelization for a WK[1]-complete problem, then all problems in WK[1] will have polynomial Turing kernelizations. The situations of the WK[k]-complete problems are alike for all . Jansen and Marx [48] studied the -Subgraph Test and -Packing problems where is a class of graphs, and pointed out which classes make the two problems tractable in one of the following senses: polynomial-time solvable, admitting a polynomial many-one kernel or admitting a polynomial Turing kernel.

It is well-known that P and NP-complete are both subsets of NP. A natural question is whether there are languages between P and NP-complete.

###### Definition 1.7

(NP-intermediate) Under the assumption of NP P, languages that are in class NP but are neither in the class P nor NP-complete are called NP-intermediate.

If we can find any problem in NP-intermediate without any assumption, then NP P. According to Ladner’s Theorem [57], if NP P, then there exist infinitely many NP-intermediate problems. However, the problem constructed by Ladner is artificial, and finding natural NP-intermediate problems under the assumption NP P is a longstanding open problem in computational complexity community.

Graph isomorphism and integer factorization are famous natural candidate NP-intermediate problems. Schöning [71] proved that if graph isomorphism is in NP-complete, then polynomial hierarchy will collapse to the second level. Babai [5] announced a quasipolynomial time algorithm for graph isomorphism, which is a big breakthrough on this problem and also a convincing evidence showing that graph isomorphism is not in NP-complete. Integer factorization is known to be in both NP and co-NP, so the problem in NP or coNP would imply NP coNP. However, as far as we know, it has no impact on complexity assumption if these two problems are in P.

This example is come from the Stack Exchange. Under the assumption of NEXP EXP. One the one hand, NEXP EXP means NP P, and there is no sparse set in NP-complete based on Mahaney’s theorem [59]. On the other hand, a proper padded version of NEXP-complete problem is in NP, but not in P, as that will contradict NEXP EXP. Moreover, the problem is a sparse set. Thus, the proper padded version of NEXP-complete problem must be in NP-intermediate. Although this result is based on a widely believed assumption, the padded versions of problems are not so natural. In addition, the NEXP-complete problems are not proverbial.

There are some natural problems which have been proved in NP-intermediate based on ETH. For example, tournament dominating set problem [61], V-C dimension [28], densest -subgraph with perfect completeness [9, 31]. Although this type of candidate NP-intermediate problems are very natural, ETH is a very strong assumption.

Our results. In this paper, we build a new bridge between parameterized complexity and structural complexity of computational complexity, and then use this bridge to construct some new frameworks. There are two main ideas in the frameworks. The first, if a parameterized problem is still (NP-)hard when restricting the parameter to a “small” function (such as, logarithmic, polylogarithmic etc.) depending on the instance length, then this problem probably has no small (Turing) compression. The second, if a parameterized problem has a small compression, then we can obtain the constraint version of the parameterized problem by restricting the parameter to a “small” function depending on the instance length, then the constraint version problem probably cannot be a (NP-)hard one.

These frameworks have three main applications based on the assumptions that the polynomial hierarchy and the exponential hierarchy will not collapse.

(1) These frameworks can obtain the Turing compression (kernel) lower bounds of some important FPT problems by taking advantage of the fruitful research results in classic complexity theory. For example, the frameworks prove that edge clique cover has no polynomial Turing compression unless the exponential hierarchy collapses to the second level, and has no linear Turing compression unless the polynomial hierarchy collapses to the second level. Thus, this paper solves an important open problem (which mentioned in abstract) in parameterized complexity.

(2) These frameworks can also get better compression (kernel) lower bounds for these FPT problems. For example, the frameworks also prove that edge clique cover has no compression unless the polynomial hierarchy collapses to the third level (matching the result in [22]), and has no linear compression unless NP = P. Thus, the frameworks are also new ones to deal with many-one compression lower bounds.

(3) These frameworks can find a large number of natural NP-intermediate problems by taking advantage of the fruitful research results in parameterized complexity. For example, the problem of deciding whether vertices can be deleted from a -vertices graph in order to turn it into a forest is in NP-intermediate, unless exponential hierarchy collapses to the third level. In particular, if this problem is in NP-complete then polynomial hierarchy collapses to the third level, and if this problem is in P then NP DTIME. Thus, the paper makes some contributions to the longstanding open problem (which mentioned in abstract) in classic computational complexity.

Organization. Section 2 gives preliminaries including other definitions that are needed in this paper. Section 3 demonstrates the frameworks for solving (Turing) compression lower bound problem and finding natural candidate problems in NP-intermediate. Section 4 applies these frameworks to concrete problems. Section 5 is conclusion and final remarks.

## 2 Preliminaries

At first, we define the non-elementary tower function. Let function be the non-elementary tower function, and , . The inverse of would be the function, and , ). equals to the least integer such that . We also use the O or o notations in the non-elementary tower function, for example, , etc.

### 2.1 Notions in Parameterized Complexity

The running time of compression and Turing compression is a polynomial function on input size. We will extend the time complexity from a polynomial function to some function , in order to get the definitions of -compression and -Turing compression.

###### Definition 2.1

(-Compression) A -compression for a parameterized language is a -time Turing machine ( is the size of the input), which given any instance returns an instance such that if and only if ( is a language) and with . We also say that parameterized language has an -sized -compression.

We say has an -sized -compression if has an -sized -compression for some , has an -sized -compression if has an -sized -compression for some , has an -sized -compression if has an -sized -compression for some and .

The parameter is smaller than the instance length in almost all important problems in parameterized complexity. Thus, without loss of generality we assume that . The same as -compression, we will give a definition of -Turing compression.

###### Definition 2.2

(-Turing Compression) is said to have an -sized -Turing compression if there is a Turing machine which given an input together with an -oracle for a classic language decides whether in time , where .

We define -sized -Turing compression, -sized -Turing compression and -sized -Turing compression similar to those in definition 2.1.

For a parameterized language, the parameter can be any number. If we restrict the parameter to some special function of the instance length, then the parameterized language will turn into a new language. We named this kind of languages constraint parameterized languages.

###### Definition 2.3

Constraint Parameterized Language is a parameterized language. For all instance of , if we restrict the parameter to , then we get a constraint parameterized language , and . We say that is the -constraint parameterized language of .

We say is an -constraint parameterized language of if is an -constraint parameterized language of for some . The instances (including yes instance and no instance) of have the property that the parameter . We will not consider the instances whose formats do not satisfy this property (Turing machine is very easy to recognize the incorrect format instances). Thus, we have , where and are the complement languages of and , respectively.

In this paper, we only consider that is a constraint number of , so we have for large enough .

###### Definition 2.4

f-Hard Parameterized Language is a parameterized language. If language is an -constraint parameterized language of as well as is NP-hard, then we call -hard parameterized language.

We define -hard parameterized language similar to the definition of the -constraint parameterized language. can be various kinds of function classes, such as logarithmic, polylogarithmic, fractional power etc.

### 2.2 Notions in Classic Computational Complexity

NEXP (EXP) is the set of decision problems that can be solved by a non-deterministic (deterministic) Turing machine using time . The exponential hierarchy (sometimes called EXPH) is a hierarchy of complexity classes, which is an exponential time analogue of the well-known polynomial hierarchy (sometimes called PH).

###### Definition 2.5

(Exponential Hierarchy) Exponential hierarchy is the union of the language classes , where (languages computable in nondeterministic time for some constant c with a oracle), and again , .

It is commonly believed that PH and EXPH will not collapse.

###### Definition 2.6

(-Sparse Set) Set is -sparse if for all but finitely many . We say is -sparse if is -sparse for some .

People usually call polynomial-sparse set sparse set. In some papers, people also consider that set is -sparse if for all . However, these two kinds of definitions have no difference when set is (quasi)polynomial-sparse or subexponential-sparse.

###### Definition 2.7

(C/F) An advice function is a function . Let be a complexity class and be a class of advice functions. The class is the collection of all sets such that for some language and some , .

###### Definition 2.8

(Circuit Families) A -size circuit family is a sequence of Boolean circuit, where has inputs and a single output, and its size for every .

P/poly is a famous language class in computational complexity. And it is well-known that the following three language classes are equal. The first is P/poly, the second the class of languages which have polynomial size circuits, and the third the class of languages which are polynomial time Turing reducible to some sparse set.

### 2.3 Concrete Parameterized Problems

Next, we will give the definitions of the parameterized problems which will be employed in this paper. All these problems are in FPT.

###### Definition 2.9

(Edge Clique Cover) The input is an undirected graph G and a nonnegative integer k, k is the parameter, the problem asks if there exist a set of k subgraphs of G, such that each subgraph is a clique and each edge of G is contained in at least one of these subgraphs.

Edge clique cover is a NP-complete problem [67]. It is also in PFT [36]. In their paper [21] Cygan etc. proved that it has no polynomial compression unless co-NP NP/poly and PH . Then in the paper [22] Cygan etc. improved the lower bound to under the same assumption.

Treewidth and pathwidth of a graph are two well-known parameters of structures that measure their similarity to a tree and a path, respectively. They are commonly used as parameters in the parameterized complexity. We use and to denote the treewidth and the pathwidth of graph , respectively. Bounded pathwidth is a more restrictive concept compared with bounded treewith. For any graph , .

Given graph together with sets , one for every vertex , then is -colorable if there exists a coloring , which is proper and for every vertex we have . is called -choosable if for any list assignment with for all vertex in , is -colorable.

###### Definition 2.10

(-Choosability) is a graph and the parameter is the treewidth of , constant . Deciding whether is -choosable.

For each , -choosability is -complete problem [40]. And the problem is in FPT when parameterized by treewidth [32].

###### Definition 2.11

(-Choosability Deletion) is a graph and the parameter is the treewidth of , constant . The problem asks for the minimum number of vertices that need to be deleted to make -choosability.

For each , -choosability deletion is -complete problem [60]. And the problem is in FPT when parameterized by treewidth [60].

For QBF problem, We will introduce its definition from [68]. Quantified Boolean formula (QBF) extends propositional logic by introducing quantifiers over the Boolean domain {0,1}. We write formulas in QBF in prenex normal form , where the s are quantifiers, the s are propositions, and is a propositional formula, which we call the matrix. By bounding the number of alternations, QBF can be stratified into classes and , where is the number of alternations, and a formula is in if its outermost quantifier is and contains alternations and in if its outermost quantifier is and contains alternations. It is well-known that and are the most famous -complete problem and -complete problem, respectively. The treewidth of a QBF formula is defined as the width of the interaction graph of its CNF matrix. The interaction graph is defined with the set of propositions as vertices, and the co-occurrence (in the same clause) relation between propositions as edges.

###### Definition 2.12

() Given a formula, constant , and the parameter is the treewidth of the formula. Deciding whether the formula is satisfiable.

Chen [15] proved that parameterized by treewidth is in FPT.

###### Definition 2.13

(Bounded Treewidth ) Given a QBF formula with bounded treewidth, and the parameter is the quantifier alternations number. Deciding whether the formula is satisfiable.

Atserias and Oliva [4] proved that bounded treewidth is PSPACE-complete. Chen [15] proved that bounded treewidth parameterized by the quantifier alternations number is in FPT.

## 3 The Frameworks

At first we will deduce some lemmas related to the frameworks. Lemma 3.1 points out that compression and Turing compression are general forms of kernelization and Turing kernelization, respectively. Lemma 3.2 and 3.3 present connections between the size of (Turing) kernel of some FPT problem and the density of objective set which can be (Turing) reduced from the FPT problem.

###### Lemma 3.1

L is a parameterized language.
(1) If L has an -sized -kernelization, then has an -sized -compression.
(2) If L has an -sized -Turing kernelization, then has an -sized -Turing compression.

Proof. According to the definitions, it is easy to understand that compression is a general type of kernelization. In order to simulate an -sized -kernelization of , we just need to restrict the output of -sized -compression to the string of .

For any instance of language . Suppose -sized -Turing kernelization for is a Turing machine with -oracle for a parameterized language . Then, whenever generates a string , asks the -oracle for parameterized language whether in it, and the length of is bounded by . Thus, Turing machine with -oracle for classic language (unparameterized version) is also an -sized -Turing compression for .

###### Lemma 3.2

is an instance of . is an f-constraint parameterized language of L. Suppose for , C is a larger constant. If L has a -sized -Turing compression, then is Turing reducible to a set of density in time where .

Proof. Suppose are Turing machines, and are classic languages. If the input C, then it is easy to prove the theorem, for the constant number is hid in the big O notation. In the following proof, we only need to deal with the long length inputs.

That has a -sized -Turing compression means that there exist a Turing machine together with a -oracle for which can decide whether in time . Whenever generates a string, will ask the -oracle for whether the string is in it, and the length of the string is bounded by 2. For convenience, the Turing machine together with the -oracle for can be abbreviated to .

Now we consider the language . is an -constraint parameterized language of , so we have and , where and are complement languages of and , respectively. In this way, language can be solved by the machine . More precisely, it means that the Turing machine together with a -oracle for can decide whether in time . Whenever generates a string, will ask the -oracle for whether the string is in it, and the length of the string is bounded by 2. Next, we will construct the set in two steps.

Step1: Running the machine on an input of length . Assume that set (string is short for ) is the collection of the strings, which have the following properties. Firstly, generates the string, then asks the -oracle for whether the string is in it, and the oracle returns yes. We define set =. Then we have , so the number of elements in set is equal to (binary code).

Step2: Since for lager , creating a class of new sets , (where ). is a string created by padding character “1” on the end of the string , where “1” is a symbol not occurring in the language. It is easy to know that the number of elements in set is equal to . In addition, and are no decreasing functions, so =. Let the set . Finally, we have created a set and .

We regard the language as a classic language, which means that the input length is equal to the instance length plus the parameter. We will design a Turing machine with the oracle to solve . For any input string (), let simulate , except for the steps before access the oracle. Whenever generates a string , and then asks the -oracle for whether the string is in it, will also produce the string . In addition, will pad character “1” on the end of the string to obtain a -bit string , and then asks the oracle whether in it. Based on the structure of , asks the -oracle for for string and the oracle returns yes if and only if asks the oracle for string and the oracle returns yes. Thus can be simulated by with the oracle . Next, we will analyse the time cost of . Since the time cost of is , and the only difference between and are the steps before asking the oracle. Each time before asks the oracle , it needs to pad at most bit “1”. Assume that refers to how many times needs to access the oracle , then the time complexity for is . Thus, we prove that can also be solved by with the oracle . The time complexity of is , and .

Combined with the input C, we can prove that if L has a -sized -Turing compression, then is Turing reducible to a set of density in time .

###### Lemma 3.3

is a parameterized language, and is an instance of . is an -constraint parameterized language of L. Suppose for C, C is a larger constant. If has a -sized -compression, then is many-one reducible to a set of density in time where .

Proof. Similar to lemma 3.2. In fact, the time complexity of the reduction can be bounded by with careful analysis.

### 3.1 Frameworks for Turing compression (kernelization) lower bound

###### Lemma 3.4

(see [49])If every set in NP has polynomial-size family of circuits, then PH .

This lemma is the well-known Karp-Lipton theorem [49]. Their original proof collapsed PH to , and Michael Sipser improved it to in the same paper. After that, there has been a lot of works on the general theme inspired by the Karp-Lipton theorem [3, 10, 50], especially, the Mahaney theorem [59], which will also be used in this paper. One of the improvement on the collapse of PH was proved by Segupta, who pointed out that NP has polynomial-size family of circuits collapses the PH to . Moreover, it became a stronger version of Karp-Lipton theorem after Cai [13] proved that . We choose to state the results for classes in as these classes are well-know.

Another variant of the Karp-Lipton theorem was provided by Buhrman and Homer [12]. They proved that if NP has quasipolynomial-size circuits, then exponential hierarchy collapses to the second level. In their paper [69] Pavan et. al. improved the collapse to .

###### Lemma 3.5

(see [12]) If any NP-complete problem is reducible to a set of density in time , for some , then EXPH .

Actually, In their paper [12] Buhrman and Homer did not regard this result as a lemma or theorem. It is included in the proof of theorem 1 of [12].

###### Lemma 3.6

Suppose is an -hard parameterized language and has a -sized quasipolynomial-Turing compression. If there exists a constant , such that for all but finitely many , then EXPH .

Proof. Assume that is an instance of , and NP-hard language is an -constraint parameterized language of . has a g-sized quasipolynomial-Turing compression, so has a -sized -Turing compression for some quasipolynomial function . is Turing reducible to a set of density in time where , according to lemma 3.2. Obviously, both and are quasipolynomial functions. According to lemma 3.5, EXPH .

This lemma gives us a tool to get Turing compression (kernel) lower bounds under the assumption of EXPH . In order to obtain the compression (kernel) lower bounds of FPT languages, we only need to design polynomial-time reduction algorithms for these languages to illustrate that these languages are -hard parameterized languages. Thus, this tool transforms the lower bound type problem to algorithm design type problem.

Of all the sizes of lower bounds, people pay great attention to the polynomial size. So we will give the polynomial-sized Turing kernel lower bound lemma, which is a special case of lemma 3.6.

###### Lemma 3.7

Suppose is a polylogarithmic-hard parameterized language. If has a polynomial-sized quasipolynomial-Turing compression, then EXPH .

Proof. Refer to the lemma 3.6. In this lemma, is a quasipolynomial function and is a polynomial function. Thus, there exists a constant , for all but finitely many .

We can also use other hypotheses to support the lower bounds of Turing kernels, such as that polynomial hierarchy will not collapse. The following lemma will give a tool for proving Turing kernel lower bounds under the assumption of PH .

###### Lemma 3.8

Suppose is an -hard parameterized language and has a -sized Turing compression. If there exists a constant , such that for all but finitely many , then PH .

Proof. Similar to the proof of lemma 3.6. Expect for that the density of set is and the time complexity of the Turing reduction is in this lemma. Thus, NP is polynomial time Turing reducible to a sparse set, and PH according to the lemma 3.4.

### 3.2 Frameworks for many-one compression (kernelization) lower bound

A set has subexponential density if for any constant , for all but finitely many .

###### Lemma 3.9

(see [59]) If NP is polynomial time many-one reducible to a sparse set, then NP = P.

This is Mahaney’s theorem. There has been a lot of works on the variant of this theorem. One direction is to relax the reduction. One of the prominent results in this direction was proved by Ogiwara and Watanabe [66]. They proved that if NP is bounded truth-table reducible to a sparse set, then NP = P. Enlarging the sparse set is another direction in which Lemma 3.10 is one of the considerable results.

###### Lemma 3.10

(see [11]) If NP is polynomial time many-one reducible to a subexponential density set, then PH .

Buhrman and Hitchcock [11] proved that if NP has subexponential density under polynomial-time many-one reduction, then coNP NP/poly. Yap [75] proved that if coNP NP/poly, then polynomial hierarchy collapses to the third level, and Cai etc. [14] improved the collapse to . In fact, the many-one reduction in lemma 3.10 can be generated to conjunctive reduction and query-bounded Turing reduction [11]. Moreover, the following theorems concerning many-one compression (kernel) lower bounds based on the assumption of PH can also be easily extended to conjunctive compression (kernel) lower bounds and query-bounded Turing compression (kernel) lower bounds [53].

###### Lemma 3.11

Suppose is an -hard parameterized language and has a -sized compression. If for any constant , for all but finitely many , then PH .

Proof. Assume that is an instance of , and NP hard language is an -constraint parameterized language of . has a g-sized compression, so has a -sized -compression for some polynomial function . is many-one reducible to a set of density in time where , according to lemma 3.3. Obviously, is a polynomial function, and for all but finitely many . Thus, is polynomial-time many-one reducible to a set of subexponential density. According to lemma 3.10, PH .

###### Lemma 3.12

Suppose is an -hard parameterized language and has a -sized compression. If there exists a constant , such that for all but finitely many , then NP = P.

Proof. Similar to lemma 3.8. It is easy to conclude that NP is polynomial time many-one reducible to a sparse set. Then NP = P according to lemma 3.9.

### 3.3 Framework for finding natural candidate NP-intermediate problems

###### Lemma 3.13

is a strictly monotone increasing function. is an instance of parameterized language . is an -constraint parameterized language of and . If is an -hard parameterized language, where constant , and has a polynomial compression, then we have
(1) If is in NP-complete, then PH .
(2) If is in P, then , where is the length of the input of the language in NP.

Proof. (1) If is NP-complete, then is an -hard parameterized language, and has a -sized compression for some polynomial function . We have for any constant . Thus, PH according to lemma 3.11.

(2) Suppose NP-hard language is an -constraint parameterized language of . Then is an -constraint parameterized language of for some function . We will consider an instance in two steps.

Step1: Pad some special characters on the end of string to transform the string into , and satisfy . Thus, string (in fact, string and string are the same), and the number of the padded characters is less than . The time complexity of the first step is .

Step2: Consider the language . P means that we can decide it in polynomial time, so the time complexity to solve is .

Finally, summing up the time complexity of the two steps, we can get that can be decided in time . It is easy to see that is a superpolynomial function, so we have . is NP-hard, so there exists a polynomial-time algorithm that, given a -sized instance of any language in NP, constructs an equivalent -sized instance of with . Thus, any language with input size in NP can be solved in time .

## 4 Applications

This section falls into three parts. The first part and the second part will give Turing compression lower bounds and compression lower bounds of some FPT problems, respectively. The third part will illustrate some natural candidate problems in NP-intermediate.

At first, we need to prove some properties of the FPT problems. These problems include satisfiability for formulas parameterized by treewidth, satisfiability for bounded treewidth formulas parameterized by quantifier alternations number , edge clique cover, -choosability parameterized by treewidth and -choosability deletion parameterized by treewidth.

###### Lemma 4.1

The problems mentioned above have following properties. Assume that is an instance of each problem.
(1) Edge clique cover parameterized by clique number is an -hard parameterized problem.
(2) For each constant , -choosability parameterized by treewidth is an -hard parameterized problem.
(3) For each constant , -choosability deletion parameterized by treewidth is an -hard parameterized problem.
(4) For each odd constant number , parameterized by treewidth is an -hard parameterized problem.
(5) There exists a constant such that on inputs of treewidth at most parameterized by quantifier alternations number is a -hard parameterized problem.

Proof. Bounded pathwidth is a more restrictive concept than bounded treewith, so the following results are still right if replacing pathwidth with treewidth.

(1) Cygan, Pilipczuk, and Pilipczuk [22] proved that there exists a polynomial-time algorithm that, given a 3-SAT formula with variables and clauses, constructs an equivalent edge clique cover instance with and . Thus, edge clique cover parameterized by clique number is an -hard parameterized problem.

(2) In the proof of the algorithmic lower bound of -choosability problem [60], one of the underlying results is that -choosability on inputs of pathwidth bounded by is NP-hard. More precisely, Holyer [43] proved that edge 3-coloring problem is NP-complete. Marx and Mitsou [60] constructed a polynomial time reduction from edge 3-coloring to (2,3)-choosability problem. Moreover, they proved that if the input instance of the reduction has vertices then the pathwidth of the output instance is bounded by . Gutner and Tarsi [40] constructed a polynomial time reduction from (2,3)-choosability to -choosability. In addition, they proved that the pathwidth of the output instance of the reduction is linear bounded by the pathwidth of the input instance , that is, . Thus, -choosability problem parameterized by pathwidth is an -hard parameterized problem.

(3) The same as the -choosability, in the paper of Marx and Mitsou [60], one of the underlying results is that -choosability deletion on inputs of pathwidth bounded by is NP-complete. More precisely, Kratochvíl [51] proved that bipartite list 3-coloring problem is NP-hard. Marx and Mitsou [60] presented a reduction from bipartite list 3-coloring to -choosability deletion. Moreover, they proved that if the input instance has vertices, then the pathwidth of the output instance is bounded by . Thus, -choosability deletion parameterized by pathwidth is an -hard parameterized problem.

(4) We can prove that problem of treewidth at most is still NP-hard according to Theorem 3.5 and Theorem 4.5 in [68]. Theorem 3.5 in [68] showed that there exists a polynomial time algorithm that, given an instance of tiling-check problem in NP-complete, constructs a QPTL finite model checking instance . In addition, the reduction satisfies

(i) if and only if have a solution.

(ii) The word model has size polynomial in .

(iii) The formulas are in and are small enough so that there exists a constant where is in .

(ii) and (iii) mean that there exists a constant where . Thus, the reduction implies that QPTL finite model checking problem is NP-hard when the formulas are in and for some constant .

Theorem 4.5 in [68] proved that there exists a polynomial (precisely, ) time algorithm that, given a formula in (for odd ) and a finite word model , constructs a formula in of size and pathwidth , such that if and only if .

Since for some constant , we have . So is NP-hard when the pathwidth is bounded by . Finally, we prove that for each odd constant number , parameterized by treewidth is an -hard parameterized problem.

(5) In [4], corollary 1 proved that there exists a constant such that, for every , on inputs of pathwidth at most and quantifier alternations is NP-hard, where is the number of variables in the formula. It is clear that , so bounded treewidth is NP-hard when the quantifier alternations number is .

### 4.1 Turing compression (kernelization) lower bounds for concrete problems

In this part, we will apply the frameworks of Turing compression lower bounds to solving concrete problems which have been mentioned above.

###### Theorem 4.2

Unless EXPH = ,
(1) There is no polynomial-sized quasipolynomial-Turing compression for edge clique cover.
(2) For every constant , there is no polynomial-sized quasipolynomial-Turing compression for -choosability parameterized by treewidth.
(3) For every constant , there is no -sized quasipolynomial-Turing compression for -choosability deletion parameterized by treewidth.
(4) For parameterized by treewidth, there are no -sized quasipolynomial-Turing compression for it when i = 3, and no -sized quasipolynomial-Turing compression for it when i (constant c ).
(5) There is no -sized quasipolynomial-Turing compression for bounded treewidth parameterized by quantifier alternations .

Proof. Lemma 4.1 proved that edge clique cover and -choosability (constant ) parameterized by treewidth are both polylogarithmic-hard parameterized problems. Thus, the two problems both have no polynomial-sized quasipolynomial-Turing compression unless EXPH = according to lemma 3.7.

Lemma 4.1 proved that -choosability deletion parameterized by treewidth is an -hard parameterized problem for each fixed . There exits a function such that -choosability deletion is an -hard parameterized problem. If there exists a -sized quasipolynomial-Turing compression for -choosability deletion for some function , then for some constant , and . Thus, EXPH = based on lemma 3.6.

Lemma 4.1 proved that is an -hard parameterized problem for each odd number . In particular, is an -hard parameterized problem. The same as the proof of -choosability deletion, parameterized by treewidth has no -sized quasipolynomial-Turing compression. For the case of , there exists a function , such that is an -hard parameterized problem. If there exists a -sized quasipolynomial-Turing compression for for some function , then we have for some constant c, and it is easy to prove that for some constant c. In fact, for any , . Thus, EXPH = according to lemma 3.6.

Lemma 4.1 proved that bounded treewidth parameterized by quantifier alternations number is an -hard parameterized problem and . If the problem has a -sized quasipolynomial-Turing compression for some function , then for some constant c. Thus, EXPH = based on lemma 3.6.

###### Theorem 4.3

Unless PH = ,
(1) There is no linear-sized Turing compression for edge clique cover.
(2) For every constant , there is no linear-sized Turing compression for -choosability parameterized by treewidth.
(3) For every constant , there is no -sized Turing compression for -choosability deletion parameterized by treewidth.
(4) For each odd constant number , there is no -sized Turing compression for parameterized by treewidth.
(5) There is no -sized Turing compression for bounded treewidth parameterized by quantifier alternations .

Proof. Refer to the theorem 4.2. The proofs of the two theorems are very similar, except for that this proof will be based on lemma 3.8 instead of lemma 3.6 in the proof of theorem 4.2.

### 4.2 Better many-one compression (kernelization) lower bounds for concrete problems

This part will give compression lower bounds for these problems which have been mentioned above. In their paper [22], Cygan etc. have also proved proposition (1) in theorem 4.4, and we can obtain the same result by employing our framework. In their paper [36] Gramm etc. pointed out that there is a -sized kernel for this problem, so the kernel lower bound of edge clique cover is essentially tight.

###### Theorem 4.4

Unless PH = ,
(1) (also see [22]) There is no -sized compression for edge clique cover.
(2) For every constant , there is no -sized compression for -choosability parameterized by treewidth.
(3) For every constant , there is no -sized compression for -choosability deletion parameterized by treewidth.
(4) For each odd constant number , there is no -sized compression for parameterized by treewidth.
(5) There is no -sized compression for bounded treewidth parameterized by quantifier alternations .

Proof. Lemma 4.1 proved that edge clique cover and -choosability parameterized by treewidth are -hard parameterized languages for some function . If these problems have -sized compression for some function , then