Linear FPT Reductions and Computational Lower Bounds

Transcription

1 Linear FPT Reductions and Computational Lower Bounds Jianer Chen, Xiuzhen Huang, Iyad A. Kanj, and Ge Xia Department of Computer Science, Texas A&M University, College Station, TX School of CTI, DePaul University, 243 S. Wabash Avenue, Chicago, IL Abstract We introduce the concept of linear fpt-reductions and develop new techniques for deriving strong computational lower bounds for a class of well-known NP-hard problems. This class includes WEIGHTED SATISFIABILITY, DOMINATING SET, HITTING SET, SET COVER, CLIQUE, and INDEPENDENT SET. For example, although a trivial enumeration can easily test in time O(n k ) if a given graph of n vertices has a clique of size k, we prove that unless an unlikely collapse occurs in parameterized complexity theory, the problem is not solvable in time f(k)n o(k) for any function f. Under the same assumption, for any function h(n) = O(n ɛ ), where 0 < ɛ < 1, we prove that no algorithm of running time n o(h(n)) can test if a graph of n vertices has a clique of size h(n). Similar strong lower bounds on the computational complexity are also derived for other NP-hard problems in the above class. Our techniques can be further extended to derive computational lower bounds on polynomial time approximation schemes for NP-hard problems. For example, we prove that the NP-hard DISTINGUISHING SUBSTRING SELECTION problem, for which a polynomial time approximation scheme has been recently developed, has no polynomial time approximation schemes of running time f(1/ɛ)n o(1/ɛ) for any function f unless an unlikely collapse occurs in parameterized complexity theory. I. INTRODUCTION Parameterized computation is a recently proposed approach dealing with intractable computational problems. By taking the advantages of the small or moderate values of a parameter k, fixed-parameter tractable algorithms, whose running time takes the form f(k)n c where f is a recursive function 2 and c is a constant, have been used to solve a variety of difficult optimization problems in practice. For example, the parameterized algorithm of running time O(1.286 k + kn) [7] for VERTEX COVER has been quite practical in its applications in the research of multiple sequence alignments [6]. The rich positive toolkit of novel techniques for designing efficient and practical parameterized algorithms is accompanied in the theory by a corresponding negative toolkit that supports a theory of parameter intractability. The concept of W [1]-hardness has been introduced, and a large number of W [1]-hard parameterized problems have been identified [13]. Now it has become commonly accepted that no W [1]-hard problem can be solved in time f(k)n c for any recursive function f and any constant c (i.e., W [1] FPT). Examples include a recent result by Papadimitriou and Yannakakis [22], 1 J. Chen, X. Huang, and G. Xia were supported in part by the NSF grants CCR and CCR , and I. A. Kanj was supported in part by DePaul University Competitive Research Grant. 2 In this paper, we always assume that complexity functions are nice with both domain and range being non-negative integers and the values of the functions and their inverses can be easily computed. showing that the DATABASE QUERY EVALUATION problem is W [1]-hard. This provides strong evidence that the problem cannot be solved by an algorithm whose running time is of the form f(k)n c, thus excluding the possibility of a practical algorithm for the problem even if the parameter k (the size of the query) is small as in most practical cases. Thus, the W [1]-hardness of a parameterized problem implies that any algorithm of running time O(n h ) solving the problem must have h a function of the parameter k. However, this does not completely exclude the possibility that the problem may become feasible for small values of the parameter k. For instance, if the problem is solvable by an algorithm running in time O(n log log k ), then such an algorithm is still feasible for moderately small values of k. 3 The above problem was recently tackled in [8], where it was shown that by setting k = n/ log n, any n o(k) time algorithms for a class of W [1]-hard parameterized problems, such as CLIQUE, would induce unlikely collapses in parameterized complexity theory. Thus, algorithms of uniform running time n o(k) for these problems are unlikely because of the parameter value k = n/ log n. This result, however, does not exclude the possibility of algorithms of running time n o(k) for this class of problems for other values of the parameter k. Note that the complexity of CLIQUE and other problems with parameter values other than n/ log n has been an interesting topic in research. We mention Papadimitriou and Yannakakis s paper [21] that introduces the classes LOGNP and LOGSNP to study the complexity of a class of problems in which the parameter values are, either implicitly or explicitly, bounded by O(log n). Constructing a clique of size log n in a graph of n vertices is one of the main problems studied in [21]. Feige and Kilian [14] studied the complexity of finding a clique of size log n, and showed that if this problem can be solved in polynomial time then nondeterministic computation can be simulated by deterministic computation in subexponential time. They also showed that if a clique of size log c n can be constructed in time O(n h ), where c is a constant and h = log c ɛ n for some ɛ > 0, then nondeterministic circuits can be simulated by randomized or non-uniform deterministic circuits of subexponential size. In this paper, based on the framework of parameterized complexity theory, we develop new techniques and derive much stronger computational lower bounds for a class of well- 3 An immediate question that might come to mind is whether such a W [1]- hard problem exists. The answer is affirmative: by re-defining the parameter, it is not difficult to construct W [1]-hard problems that are solvable in time O(n log log k ).

2 known NP-hard problems. We start by proving computational lower bounds for a class of SATISFIABILITY problems, and then extend the lower bound results to other well-known NP-hard problems by introducing the concept of linear fptreductions. In particular, we prove that (A) unless W [1] = FPT, the NP-hard parameterized problems WEIGHTED CNF SAT, DOMINATING SET, HITTING SET, and SET COVER cannot be solved in time f(k)n o(k) p(m) for any function f and any polynomial p, where n is the size of the search space from which the k elements are selected and m is the input instance length; and (B) unless all search problems in the syntactic class SNP introduced by Papadimitriou and Yannakakis [20] are solvable in subexponential time, the NP-hard parameterized problems WEIGHTED CNF q-sat for any constant q 3, CLIQUE, INDEPENDENT SET, and many others cannot be solved in time f(k)m o(k) for any function f, where m is the input instance length. Note that each of the problems in class (A) (resp. class (B)) can be solved by a trivial algorithm of running time cn k m (resp. cm k+1 ), where c is an absolute constant, which simply enumerates all possible subsets of k elements in the search space. Much research has tended to seek new approaches to improve this trivial upper bound. One of the common approaches is to apply a more careful branch-and-bound search process trying to optimize the manipulation of local structures before each branch [1], [2], [7], [9], [18]. Continuously improved algorithms for these problems have been developed based on improved local structure manipulations (for example, see [25], [17], [23], [4] on the progress for the INDEPENDENT SET problem). It has even been proposed to automate the manipulation of local structures [19], [24] in order to further improve the computational time. Our results, however, provide strong evidence that the power of this approach is quite limited in principle. The lower bounds f(k)n Ω(k) p(m) and f(k)m Ω(k) for any function f and any polynomial p mentioned above indicate that no local structure manipulation running in polynomial time or in time depending only on the value k will obviate the need for exhaustive enumerations. Moreover, we prove that unless unlikely collapses occur in parameterized complexity theory, the problems in group (A) cannot be solved in time n o(k) p(m) for any polynomial p, and the problems in group (B) cannot be solved in time m o(k), even when the parameter k is restricted to be of the order of any particular function k = Θ(µ(n)), where µ(n) = O(n ɛ ) and 0 < ɛ < 1. This is a very significant improvement over the results given in [8]: the results in [8] establish lower bounds because of a particular value of the parameter k, while the results in the current paper under the same assumption claim the lower bounds for every value of the parameter k. The linear fpt-reduction has also enabled us to derive lower bounds on the computational complexity of polynomial time approximation schemes (PTAS) for certain NPhard problems. We pick the DISTINGUISHING SUBSTRING SELECTION problem (DSSP) as an example, for which a PTAS has been developed recently [10], [11]. Gramm, Guo, and Niedermeier [15] showed that the parameterized version of the DSSP problem is W [1]-hard, thus excluding the possibility that the DSSP problem has a PTAS whose running time takes the form f(1/ɛ)n c, where f is an arbitrary function and c is a constant. Using the technique of linear fpt-reductions, we are able to prove a much stronger result. We first show that the DOMINATING SET problem can be linearly fpt-reduced to the DSSP problem, which thus proves that the parameterized DSSP problem is W [2]-hard (improving the result in [15]). We then show how this lower bound on parameterized complexity can be transformed into a lower bound on the computational complexity for any PTAS for the problem. More specifically, we prove that unless all search problems in SNP are solvable in subexponential time, the DSSP problem has no PTAS of running time f(1/ɛ)n o(1/ɛ) for any recursive function f. This essentially excludes the possibility that the DSSP problem has a practically efficient PTAS even for moderate values of the error bound ɛ. To the authors knowledge, this is the first time a specific lower bound has been derived on the running time of a PTAS for an NP-hard problem. We give a brief review on parameterized complexity theory. A parameterized problem Q is a subset of Ω N, where Ω is a fixed alphabet and N is the set of all non-negative integers. Therefore, each instance of the parameterized problem Q is a pair (x, k), where the non-negative integer k is called the parameter. We say that the parameterized problem Q is fixedparameter tractable [13] if there is an algorithm that decides if an input (x, k) is a yes-instance of Q in time f(k) x c, where c is a fixed constant and f(k) is a recursive function. Denote by FPT the class of all fixed-parameter tractable problems. The inherent computational difficulty for solving some problems practically has led to the common belief that many parameterized problems are not fixed-parameter tractable. A hierarchy of fixed-parameter intractability, the W -hierarchy, has been introduced. At the 0-th level of the hierarchy lies the class FPT. The hardness and completeness have been defined for each level W [i] of the W -hierarchy for i > 0 [13]. It is commonly believed that W [1] F P T. Thus, W [1]-hardness has served as the hypothesis for fixed-parameter intractability. For two functions f(n) and g(n), by f(n) = o(g(n)), we mean that there is a non-decreasing and unbounded function λ(n) such that f(n) g(n)/λ(n). We say that a function f(n) is subexponential if f(n) = 2 o(n). II. LOWER BOUNDS FOR WEIGHTED SATISFIABILITY A Π t -circuit C with n input variables is a (t + 1)-levelled circuit in which the 0-th level consists of the input gates (each is labelled either by a positive literal x i or by a negative literal x i, 1 i n), the t-th level consists of a unique output gate which is an AND gate, and all AND and OR gates in C are organized into alternating levels with edges only going from a level to the next level. The size of a Π t -circuit C is the number of gates in C. A circuit is monotone (resp. antimonotone) if all its input gates are labelled by positive literals (resp. negative literals). We say that a truth assignment τ to the input variables of a circuit C satisfies a gate g in C if τ makes the gate g 2

3 have value 1, and that τ satisfies the circuit C if τ satisfies the output gate of C. The weight of an assignment τ is the number of variables assigned value 1 by τ. The SATISFIABILITY problem on Π t -circuits, abbreviated SAT[t], is to determine whether a given Π t -circuit C has a satisfying assignment. The parameterized problem WEIGHTED SATISFIABILITY on Π t -circuits, abbreviated WCS[t], is to determine for a given pair (C, k), where C is a Π t -circuit and k is an integer, whether C has a satisfying assignment of weight k. The WEIGHTED MONOTONE SATISFIABILITY (resp. WEIGHTED ANTIMONOTONE SATISFIABILITY) problem on Π t -circuits, abbreviated MONOTONE WCS[t] (resp. ANTI- MONOTONE WCS[t]) is defined similarly to WCS[t] except that the circuit C is required to be monotone (resp. antimonotone). It is known that for each even integer t > 1, MONOTONE WCS[t] is W [t]-complete, and that for each odd integer t > 1, ANTIMONOTONE WCS[t] is W [t]-complete. To make our discussion simpler, we will denote by M-WCS[t] the problem MONOTONE WCS[t] if t is even and the problem ANTIMONOTONE WCS[t] if t is odd. The proof of the following lemma is given in the Appendix, here n and m denote the number of variables and the circuit size of a Π t -circuit, respectively. Lemma 2.1: For any integer t > 1 and any three-variable non-decreasing function φ(k, n, m), if the problem M-WCS[t] is solvable in time φ(k, n, m), then for any integer function r(n) n, the problem SAT[t] can be solved in time φ(k, n, m ) + O(m ), where k = n/r(n), n 2 r(n) k, and m 2m + 2 2r(n)+1 k. From Lemma 2.1, we get the following important result. Theorem 2.2: Let t > 1 be an integer. For any function f and any polynomial p, if M-WCS[t] is solvable in time f(k)n o(k) p(m), then SAT[t] can be solved in time 2 o(n) p (m) for a polynomial p. Proof: By Lemma 2.1, there is a non-decreasing and unbounded function λ such that the problem SAT[t] can be solved in time f(k)(n ) k/λ(k) p(m ), where k = n/r(n), n 2 r(n) k, m 2m + 2 2r(n)+1 k, and r(n) n is an arbitrary integer function. Without loss of generality, we can assume that the function f is non-decreasing, unbounded, and that f(k) 2 k. Define f 1 by f 1 (h) = max{q f(q) h}. Since the function f is non-decreasing and unbounded, the function f 1 is also non-decreasing and unbounded, and satisfies f(f 1 (h)) h. From f(k) 2 k, we have f 1 (h) log h. Now we let the function r(n) be r(n) = 3n/f 1 (n). Then k = n/r(n) f 1 (n) log n, and f(k) f(f 1 (n)) n. Moreover, k = n/r(n) n/r(n) n/(3n/f 1 (n)) = f 1 (n)/3 therefore λ(k) λ(f 1 (n)/3) is a non-decreasing and unbounded function of n. Thus, (n ) k/λ(k) (k2 r(n) ) k/λ(k) k k 2 kr(n)/λ(k) k k 2 3kn/(λ(k)f 1 (n)) k k 2 3n/λ(k) = 2 o(n) Finally, since f 1 is non-decreasing and unbounded, p(m ) p(2m + 2k2 2r(n) ) p(4m) + p(4k2 2r(n) ) p(4m) + p(4 log n 2 6n/f 1 (n) ) = 2 o(n) p(4m) Therefore, the f(k)(n ) k/λ(k) p(m )-time algorithm A for the problem SAT[t] is actually an algorithm of running time 2 o(n) p (m), where p (m) = p(4m) is a polynomial of m, i.e., the problem SAT[t] can be solved in time 2 o(n) p (m). This completes the proof of the theorem. The proof of Lemma 2.1 has actually shown the difficulty of constructing a satisfying assignment of a particular weight for the M-WCS[t] problem. Corollary 2.3: Let t > 1 be an integer. For any nondecreasing and unbounded function µ(n) = O(n ɛ ), where 0 < ɛ < 1, if M-WCS[t] is solvable in time n o(k) p(m) for a polynomial p and for the parameter values k = Θ(µ(n)), then SAT[t] is solvable in time 2 o(n) p (m), where p (m) is a polynomial of m. Proof: (Sketch) In the proof of Lemma 2.1, from an instance C of SAT[t] with n input variables and size m, we constructed an instance (C, k) for M-WCS[t], where k = n/r(n) and C has n k2 n/k input variables and size m 2m+2 2r(n)+1 k, such that C is a yes-instance of SAT[t] if and only if (C, k) is a yes-instance of M-WCS[t]. By carefully selecting the function r(n), we can make k = Θ(µ(n )). Thus, the assumed algorithm on (C, k) for this particular value of k runs in time (n ) o(k) p(m ), and can be used to test if C is a yes-instance of SAT[t]. Since µ(n) = O(n ɛ ), it can be verified that for this particular function r(n), such that k = n/r(n), n k2 n/k, and m 2m + 2 2r(n)+1 k, the function (n ) o(k) p(m ) is of order 2 o(n) p (m) for some polynomial p. Now we show that a subexponential time algorithm for SAT[t] would collapse the W -hierarchy. Theorem 2.4: For any t > 1, if SAT[t] is solvable in time 2 o(n) p(m) for a polynomial p, then W [t 1] = FPT. Proof: The theorem for the case t = 2 was proved in [5]. Here we present a proof for the general case t 3 using different techniques. In particular, our techniques do not apply to the case t = 2. Let C be a Π t 1 -circuit of n input variables x 0,..., x n 1 and size m such that C is monotone if t is odd and C is antimonotone if t is even. Without loss of generality, we assume that log n is an integer (otherwise, we add dummy input variables to the input variables of C). Let k n be a non-negative integer. We first show how to construct a Π t - circuit C of k log n input variables from the circuit C and the integer k such that C has a satisfying assignment of weight k if and only if C is satisfiable. The input variables in C are divided into k blocks B 1,..., B k, where each block B i consists of r = log n input variables z i,1,..., z i,r. For a nonnegative integer j n 1, we denote by bin r (j) the lengthr binary representation of the integer j, which can also be interpreted as an assignment to a block B i in the circuit C. We distinguish two cases based on the parity of t. 3

4 Case 1. t is odd. Then C is a monotone Π t 1 -circuit and all level-1 gates in C are OR gates. For each positive literal x j in C and for each block B i, we make an AND gate g i,j in C such that if the h-th bit in bin r (j) is 1 (resp. 0) then z i,h (resp. z i,h ) is an input to g i,j. The outputs of g i,j in C are identical to the outputs of x j in C. Note that for each assignment bin r (j) to block B i, exactly one of these new AND gates, i.e., the gate g i,j, is satisfied and outputs 1. Thus, the assignment bin r (j) of block B i in C simulates the assignment x j = 1 in C. The circuit C is obtained from the circuit C by removing all input gates in C and adding the kn new AND gates g i,j, 1 i k, 0 j n 1, and the literals in blocks B 1,..., B k. Moreover, we add an enforcement circuitry to C to make sure that the assignments to different blocks in C simulate assignments to different variables in C. To achieve this, we construct a depth-2 subcircuit C i,i for each pair of blocks B i and B i such that C i,i outputs 0 if and only if blocks B i and B i are assigned the same value. The output of C i,i is an input to the output AND gate of the circuit C. Since t 3, the enforcement circuitry does not increase the depth of the circuit C. Thus, the circuit C is a Π t -circuit with kr input variables. It is easy to verify that the circuit C has a satisfying assignment of weight k if and only if the circuit C is satisfiable: suppose C is satisfied by a weight-k assignment τ, which assigns value 1 to k variables x j1,..., x jk, and value 0 to all other variables. Then by assigning the value bin r (j i ) to block B i for 1 i k, we get an assignment τ for the circuit C such that all AND gates g i,ji in C are satisfied. Since the outputs of the AND gates g i,ji are identical to the outputs of the positive literals x ji, we conclude that all level-2 OR gates in C corresponding to those level-1 OR gates in C satisfied by the assignment τ are satisfied by the assignment τ. Since the assignment τ satisfies the circuit C and all blocks B i are assigned different values, the assignment τ satisfies the circuit C and the circuit C is satisfiable. Conversely, suppose the circuit C is satisfied by an assignment τ, then the restriction τ i of τ to block B i satisfies exactly one AND gate g i,j i, where bin r (j i ) = τ i. Because of the enforcement circuitry, these k gates g i,ji correspond to k different positive literals x ji. Thus, if we set x ji = 1 for all 1 i k, and set value 0 to all other variables, we get an assignment τ of weight exactly k that satisfies the circuit C. Case 2. t is even. Then C is an antimonotone Π t 1 -circuit and all level-1 gates in C are AND gates. For each input variable x j, 0 j n 1, and for each block B i, we make an OR gate g i,j such that if the h-th bit in bin r (j) is 0 (resp. 1) then z i,h (resp. z i,h ) is an input to g i,j. The outputs of g i,j in C are identical to the outputs of x j in C. Note that for each assignment bin r (j) of block B i, exactly one of these new OR gates, i.e., the gate g i,j, is not satisfied and outputs 0. Thus, the assignment bin r (j) of block B i in C simulates the assignment x j = 0 (or equivalently x j = 1) in C. As in Case 1, we also add an enforcement circuitry to C to make sure that no two blocks in C are assigned the same value. The circuit C is a Π t -circuit with kr input variables. To verify that the circuit C has a satisfying assignment of weight k if and only if the circuit C is satisfiable, suppose C is satisfied by a weight-k assignment τ, which assigns value 1 to k variables x j1,..., x jk, and value 0 to all other variables. Then by assigning the value bin r (j i ) to block B i for 1 i k, we get an assignment τ to the circuit C such that for each i, only the OR gate g i,ji is not satisfied and outputs 0. Thus, for each level-1 AND gate g 1 satisfied by the assignment τ in C, since no negative literals x j1,..., x jk are inputs to g 1 in C, no gates g 1,j1,..., g k,jk are inputs to g 1 in C. Thus, the assignment τ satisfies the gate g 1. Since g 1 is an arbitrary level-1 AND gate satisfied by τ in C, we conclude that the assignment τ satisfies all level-2 AND gates that correspond to the level-1 AND gates satisfied by the assignment τ in C. Since τ satisfies the circuit C and all blocks B i are assigned different values, τ satisfies the circuit C and C is satisfiable. Conversely, suppose the circuit C is satisfied by an assignment τ, then the restriction τ i of τ to block B i satisfies all OR gates g i,j except the gate g i,ji, where bin r (j i ) = τ i. Because of the enforcement circuitry in C, assignments τ i and τ i to two different blocks in C are different. Thus, the assignments to the k blocks induce k different input variables x ji. If we set x ji = 1 for all 1 i k and set value 0 for all other input variables in C, we get an assignment τ of weight exactly k that satisfies the circuit C. In summary, we have verified that for any t 3, for a given Π t 1 -circuit C of n input variables and size m, and for a given k n, where C is monotone if t is odd and antimonotone if t is even, we can construct a Π t -circuit C such that C has a satisfying assignment of weight k if and only if C is satisfiable. The circuit C has n = kr = k log n input variables and size m bounded by m+kn+3k 2 log 2 n 3m 3, where the term kn is the number of the gates g i,j, 1 i k, 0 j n 1 in the construction of the circuit C, and 3k 2 log 2 n is an upper bound on the size of the enforcement circuitry. The circuit C can be constructed from (C, k) in time O(n + m ). By the hypothesis of the theorem, there is an algorithm A that determines whether the circuit C is satisfiable in time 2 o(n ) p(m ) for a polynomial p. Thus, there is a nondecreasing and unbounded function λ such that the running time of the algorithm A is bounded by 2 n /λ(n ) p(m ). This, plus the construction of the circuit C from (C, k), gives an algorithm A of running time 2 n /λ(n ) p(m ) that determines whether the Π t 1 -circuit C has a satisfying assignment of weight k. Note that 2 n /λ(n ) = 2 k log n/λ(k log n) 2 k log n/λ(log n). This gives the following algorithm A to determine if the circuit C has a weight-k satisfying assignment: For the given pair (C, k), where C is a Π t 1 -circuit of n variables and size m, if k > λ(log n), then enumerate all assignments to C and check if there is a satisfying assignment of weight k to C; if k λ(log n), then call the algorithm A to decide if there is a satisfying assignment of weight k to C. We analyze the algorithm A. First note that m 3m 3, thus, p(m ) is bounded by a polynomial p (m) of m. Define 4

5 λ 1 (r) = min{q λ(q) r}. Since λ is non-decreasing and unbounded, λ 1 is also a non-decreasing and unbounded function. Let f(k) = 2 2λ 1 (k). We claim that the running time of the algorithm A is bounded by f(k)np (m). In effect, if k > λ(log n), we have λ 1 (k) log n, and f(k) 2 n. Therefore, in this case, the running time of the algorithm A is bounded by 2 n p (m) f(k)p (m). On the other hand, if k λ(log n), then the algorithm A calls the algorithm A to solve the problem, which runs in time 2 k log n/λ(log n) 2 log n = n. This concludes our theorem: in case t 3 is odd, the algorithm A can determine whether a monotone Π t 1 -circuit C has a satisfying assignment of weight k in time f(k)np (m) thus the W [t 1]-complete problem MONOTONE WCS[t 1] is fixedparameter tractable and W [t 1] = FPT; while in case t 3 is even, the algorithm A can determine whether an antimonotone Π t 1 -circuit C has a satisfying assignment of weight k in time f(k)np (m) thus the W [t 1]-complete problem ANTIMONOTONE WCS[t 1] is fixed-parameter tractable and W [t 1] = FPT. In both cases, we get W [t 1] = FPT. This completes the proof of the theorem. From Theorem 2.2 and Theorem 2.4, we get Theorem 2.5: For any integer t > 1, if M-WCS[t] is solvable in time f(k)n o(k) p(m) for a recursive function f and a polynomial p, then W [t 1] = FPT. From Corollary 2.3 and Theorem 2.4, we get Theorem 2.6: Let t > 1 be an integer. For any nondecreasing and unbounded function µ(n) = O(n ɛ ), where 0 < ɛ < 1, if M-WCS[t] is solvable in time n o(k) p(m) for a polynomial p and for the parameter values k = Θ(µ(n)), then W [t 1] = FPT. III. LOWER BOUNDS VIA STRONG LINEAR FPT-REDUCTIONS In the above discussion of the problems M-WCS[t], we observed that besides the parameter k and the circuit size m, the number n of input variables has played an important role in the computational complexity of the problems. Unless unlikely collapses occur in parameterized complexity theory, the problems M-WCS[t] have a tight computational bound f(k)n Θ(k) p(m), where p is any polynomial and f is any recursive function. These bounds are exponential, but in the number n of variables in the circuits, instead of in the circuit size m. Note that the circuit size m can be of the order 2 n. Each instance (C, k) of a circuit satisfiability problem such as M-WCS[t] can be regarded as a search problem, in which we need to select k elements from a search space consisting of a set of n input variables, and assign them value 1 so that the circuit is satisfied. Many well-known NP-hard problems have similar formulations. We list some of them next: WEIGHTED CNF SAT: given a CNF formula F, and an integer k, decide if there is an assignment of weight k that satisfies all clauses in F. Here the search space is the set of Boolean variables in F. SET COVER: given a collection F of subsets in a universal set U, and an integer k, decide whether there is a subcollection of k subsets in F whose union is equal to U. Here the search space is F. HITTING SET: given a collection F of subsets in a universal set U, and an integer k, decide if there is a subset S of k elements in U such that S intersects every subset in F. Here the search space is U. RED/BLUE DOMINATING SET: given a graph G whose vertices are colored either red or blue, and an integer k, decide whether there is a subset B of k blue vertices such that every vertex not in B is adjacent to at least one vertex in B. Here the search space is the set of blue vertices. Many graph problems seek a subset of vertices that meet certain given conditions. For these graph problems, the natural search space is the set of all vertices. For certain problems, the polynomial time preprocessing on the input instance can significantly reduce the size of the search space. For example, for finding a vertex cover of k vertices in a graph G of n vertices, a polynomial time preprocessing can reduce the search space size to 2k [7]. In the following, we present a simple algorithm for reducing the search space size for the DOMINATING SET problem (given a graph G and an integer k, decide whether there is a subset D of k vertices such that every vertex not in D is adjacent to at least one vertex in D). Suppose we are looking for a dominating set of k vertices in a graph G of n vertices. Consider any independent set I of k + 1 vertices in G. We say I has the same neighbor set A if every vertex in I has A as its neighbor set. Obviously, if G has a dominating set of k vertices and I has the same neighbor set A, then at least one of the vertices in A must be included in the dominating set. Thus, the set A can be identified as part of the search space U. This suggests the following preprocessing on an instance (G, k) of the DOMINATING SET problem: DS-Core 1. i = 0; color all vertices in G WHITE; 2. while there is an independent set I i of k + 1 WHITE vertices with the same neighbor set A i color all vertices in A i BLACK; color each vertex not in A i but adjacent to a vertex in A i RED; i = i + 1; 3. if i < k, let U be the set of all vertices in G; stop. 4. if i = k, let U = k 1 i=0 A i, stop. 5. if i > k, stop (G has no dominating set of k vertices). It is easy to verify the following facts for the above algorithm: (1) all independent sets I i are disjoint; (2) no two vertices in two different independent sets I i and I j, i < j, would share a common neighbor (otherwise, the construction of I i would have colored a vertex in I j RED, which in turn would have not been included in I j ). Therefore, each vertex set A i must contain at least one vertex in any dominating set of k vertices in the graph G, if such a dominating set exists. Thus, if there are more than k such sets A i, we can directly conclude the nonexistence of such a dominating set; while if there are exactly k such subsets A i, we can simply concentrate on the 5

6 set k 1 i=0 A i to see if it contains a dominating set of k vertices for the entire graph G. In case there are less than k such subsets A i, the preprocessing simply does not help and we reset the search space U to be the entire vertex set of G. Finally, note that in the adjacency matrix representation of the graph G, an independent set I i of k + 1 WHITE vertices with the same neighbor set corresponds to k+1 identical rows in the adjacency matrix, which can be easily identified in polynomial time. Thus, the algorithm DS-Core runs in polynomial time. In this section, we will concentrate on parameterized problems that seek a subset in a search space satisfying certain properties. Each instance of such a parameterized problem is associated with a triple (k, n, m), where k is the parameter, n is the size of the search space, and m is the size of the instance. We will call such an instance a (k, n, m)-instance. Definition A parameterized problem Q is linearly fptreducible in the strong sense (shortly fpt s l -reducible) to a parameterized problem Q if there exist a recursive function f, a polynomial p, and an algorithm A of running time f(k)n o(k) p(m), such that on each (k, n, m)-instance x of Q, the algorithm A produces a (k, n, m )-instance x of Q, where k = O(k), n p(n), m p(m), and x is a yes-instance of Q if and only if x is a yes-instance of Q. The following theorem follows directly from the definition. Theorem 3.1: Suppose that a parameterized problem Q is fpt s l -reducible to a parameterized problem Q. If Q is solvable in time f(k)n o(k) p(m) for a recursive function f and a polynomial p, then Q is solvable in time f (k)n o(k) p (m) for a recursive function f and a polynomial p. Using the fpt s l -reduction, we can immediately derive computational lower bounds for a large group of NP-hard parameterized problems, as follows. Theorem 3.2: Unless W [1] = FPT, none of the following parameterized problems can be solved in time f(k)n o(k) p(m) for any recursive function f and any polynomial p: WEIGHTED CNF SAT, SET COVER, HITTING SET, RED/BLUE DOMINATING SET, and DOMINATING SET (for DOMINATING SET, we assume the search space is identified by the algorithm DS-Core). Proof: We highlight the fpt s l -reductions from the problem MONOTONE WCS[2] to these problems, which are all we need to prove the theorem. Most of these reductions are simple and standard, thus, we will only indicate the relations without providing details: (1) the MONOTONE WCS[2] problem is fpt s l -reducible to the problem WEIGHTED CNF SAT; (2) the MONOTONE WCS[2] problem is fpt s l -reducible to the problem HITTING SET; (3) the HITTING SET problem is fpt s l -reducible to the problem SET COVER; and (4) the MONOTONE WCS[2] problem is fpt s l -reducible to the problem RED/BLUE DOMI- NATING SET. For DOMINATING SET, we use the reduction given in [13] from the WEIGHTED CNF SAT problem, described as follows. From a CNF formula F of n variables and m clauses, a graph G F of m F = O(n 3 + m) edges is constructed such that F has a satisfying assignment of weight k if and only if G F has a dominating set of 2k vertices. A more careful examination of the reduction reveals that in the graph G F, there are 2k disjoint independent sets I i, i = 1,..., 2k, where each I i has 2k + 1 vertices and has the same neighbor set A i consisting of O(n 2 ) vertices, such that all neighbor sets A i are also disjoint. Moreover, besides these independent sets, no two vertices in G F share the same neighbor set. Therefore, if we apply the algorithm DS-Core to G F, the constructed search space U F will be exactly the union of these 2k neighbor sets A 1,..., A 2k. Thus, for the graph G F, the size n F of the search space U F is O(kn 2 ). This, obviously, is a fpt s l -reduction from the WEIGHTED CNF SAT problem to the DOMINATING SET problem. With these fpt s l -reductions, the theorem follows directly from Theorem 2.5 and Theorem 3.1. Each of the problems in Theorem 3.2 can be solved by a trivial algorithm of running time cn k m, where c is an absolute constant, which simply enumerates all possible subsets of k elements in the search space. Much research has tended to seek new approaches to improve this trivial upper bound. One of the common approaches is to apply a more careful branchand-bound search process trying to optimize the manipulation of local structures before each branch [1], [2], [7], [9], [18]. Continuously improved algorithms for these problems have been developed based on improved local structure manipulations. It has even been proposed to automate the manipulation of local structures [19], [24] in order to further improve the computational time needed to solve the problems. Theorem 3.2, however, provides strong evidence that the power of this approach is quite limited in principle. The lower bound f(k)n Ω(k) p(m) for any function f and any polynomial p in Theorem 3.2 indicates that no local structure manipulation running in polynomial time or in time depending only on the target value k will obviate the need for exhaustive enumerations. Weaker lower bounds of n Ω(k) p(m), where p is a polynomial, have been established previously for the parameterized problems in Theorem 3.2 [8], by proving that for the case k = n/ log n, an algorithm of running time n o(k) p(m) for the problems in Theorem 3.2 would imply W [1] = FPT. However, the results in [8] do not exclude the possibility that for small parameter values of k, an algorithm of running time n o(k) p(m) may exist. Note that studying the complexity of NP-hard problems for small parameter values has been an interesting topic in research [14], [21]. Moreover, after all, most research in parameterized complexity theory assumes that the parameter values are small. Using Theorem 3.2, we can strengthen the lower bounds in [8] and prove that the lower bounds in [8] hold even when the parameter values are bounded by an arbitrarily small function. Theorem 3.3: Let µ(n) be a non-decreasing and unbounded function. Even if we restrict the parameter values by k µ(n), none of the problems in Theorem 3.2 can be solved in time n o(k) p(m) for any polynomial p, unless W [1] = FPT. Proof: Let Q be any one of the parameterized problems in Theorem 3.2. Suppose that when k µ(n), the problem 6

7 Q is solvable by an algorithm A of running time n o(k) p(m), where p is a polynomial. Define the function µ 1 as µ 1 (r) = max{q µ(q) r}. Since µ is non-decreasing and unbounded, µ 1 is also a nondecreasing and unbounded function. Define f(k) = 2 µ 1 (k). Consider the following algorithm A solving Q: For a given (k, n, m)-instance x of the problem Q, if k µ(n), then solve the problem using exhaustive enumeration in time O(2 n p (m)), where p is a polynomial; and if k < µ(n), call the algorithm A to solve the problem. We claim that the algorithm A solves the problem Q in its general case in time f(k)n o(k) (p (m) + p(m)). In fact, in case k µ(n), we have µ 1 (k) n therefore f(k) 2 n. Thus, the running time of the algorithm A is bounded by O(2 n p (m)) = O(f(k)p (m)) = f(k)n o(k) p (m). On the other hand, in case k < µ(n), by the hypothesis of the theorem, the algorithm A runs in time n o(k) p(m) f(k)n o(k) p(m). Thus, the running time of the algorithm A is always bounded by f(k)n o(k) (p (m) + p(m)), which, according to Theorem 3.2, would imply W [1] = FPT. Based on Corollary 2.3 and the fpt s l -reductions in Theorem 3.2, we also derive Theorem 3.4: Unless W [t 1] = FPT, for any nondecreasing and unbounded function µ(n) = O(n ɛ ), where 0 < ɛ < 1, none of the problems in Theorem 3.2 can be solved in time n o(k) p(m) even if we restrict the parameter values k to be Θ(µ(n)). IV. LOWER BOUNDS VIA LINEAR FPT-REDUCTIONS All problems in Theorem 3.2 are W [2]-complete in parameterized complexity theory. This makes it possible to fpt s l - reduce the W [2]-complete problem MONOTONE WCS[2] to these problems. However, similar approaches are not applicable in deriving lower bounds for W [1]-complete problems. Note that many well-known NP-hard problems are W [1]- complete, including WEIGHTED CNF q-sat for any constant q 2, CLIQUE, and INDEPENDENT SET. In this section, we present new techniques to derive computational lower bounds for some W [1]-complete problems, including the above three. The parameterized problem WEIGHTED MONOTONE CNF 2- SAT (resp. WEIGHTED ANTIMONOTONE CNF 2-SAT) is: given an integer k and a CNF formula F, in which all literals are positive (resp. negative) and each clause contains at most 2 literals, determine whether there is a satisfying assignment of weight k to F. In the following, we will denote by n the number of input variables in an instance of WEIGHTED MONOTONE CNF 2-SAT or WEIGHTED ANTIMONOTONE CNF 2-SAT, which is polynomially related to the size m of the instance. The proof of the following lemma is given in the Appendix. Lemma 4.1: If the problem WEIGHTED ANTIMONOTONE CNF 2-SAT is solvable in time f(k)n o(k) for some recursive function f, then the problem WEIGHTED MONOTONE CNF 2- SAT can be solved in time 2 o(n). The class SNP introduced by Papadimitriou and Yannakakis [20] contains many well-known NP-hard problems including CNF q-sat for any integer q 3, q-colorability, q-set COVER, VERTEX COVER, CLIQUE, and INDEPENDENT SET [16]. It is commonly believed that it is unlikely that all problems in SNP are solvable in subexponential time 4. Impagliazzo and Paturi [16] studied the class SNP and identified a group of SNP-complete problems under the SERF-reduction, in the sense that if any of these SNP-complete problems is solvable in subexponential time, then all problems in SNP are solvable in subexponential time. Theorem 4.2: If WEIGHTED ANTIMONOTONE CNF 2-SAT is solvable in time f(k)n o(k) for a function f, then all problems in SNP are solvable in subexponential time. Proof: Recall that a vertex cover of a graph G is a set C of vertices such that every edge in G has at least one end in C. Given a graph G of n vertices, we can construct an instance F G of n variables for MONOTONE CNF 2-SAT as follows: each vertex v i of G makes a positive literal v i in F G, and each edge [v i, v j ] in G makes a clause (v i, v j ) in F G. It is easy to see that the graph G has a vertex cover of k vertices if and only if F G has a satisfying assignment of weight k. From the hypothesis of the theorem, and by Lemma 4.1, WEIGHTED MONOTONE CNF 2-SAT can be solved in time 2 o(n). Therefore, VERTEX COVER can be solved in time 2 o(n). Since VERTEX COVER is SNP-complete under the SERF-reduction [16], this in consequence implies that all problems in SNP are solvable in subexponential time. A nice property WEIGHTED ANTIMONOTONE CNF 2-SAT has is that the size of its search space (i.e., the number of input variables) is polynomially related to the instance size. Thus, we can partially relax the definition of the fpt s l -reduction. In the following definition, we assume k is the parameter and m is the instance size. The theorem following the definition directly follows from the definition. Definition A parameterized problem Q is linearly fptreducible (shortly fpt l -reducible) to a parameterized problem Q if there exist a recursive function f, a polynomial p, and an algorithm A of running time f(k)m o(k), such that on each instance x of Q, the algorithm A produces an instance x of Q, where k = O(k), m p(m), and x is a yes-instance of Q if and only if x is a yes-instance of Q. Theorem 4.3: Suppose a parameterized problem Q is fpt l - reducible to a parameterized problem Q. If Q is solvable in time f(k)m o(k) for a recursive function f, then Q is solvable in time f (k)m o(k) for a recursive function f. Using the fpt l -reduction, we derive computational lower bounds for CLIQUE and other problems, as follows. Theorem 4.4: Unless all problems in SNP are solvable in subexponential time, the following parameterized problems cannot be solved in time f(k)m o(k) for any recursive function 4 A recent result showed the equivalence between the statement that all SNP problems are solvable in subexponential time, and the collapse of a parameterized class called Mini[1] to FPT [12]. 7

8 f: WEIGHTED CNF q-sat for any integer q 2, CLIQUE, and INDEPENDENT SET. Proof: The fpt l -reductions from WEIGHTED ANTIMONO- TONE CNF 2-SAT to these problems are standard. Based on the fpt l -reduction, we can also derive stronger lower bounds for the problems in Theorem 3.2, only in terms of parameter k and instance size m. However, the assumption is also stronger 5. Theorem 4.5: Unless all problems in SNP are solvable in subexponential time, the following problems cannot be solved in time f(k)m o(k) for any recursive function f: WEIGHTED CNF SAT, DOMINATING SET, SET COVER, HITTING SET, and RED/BLUE DOMINATING SET. Proof: The fpt l -reductions from WEIGHTED ANTIMONO- TONE CNF 2-SAT to WEIGHTED CNF SAT is straightforward. The fpt l -reduction from WEIGHTED CNF SAT to DOMINATING SET has been described in the proof of Theorem 3.2 (which actually is an fpt s l -reduction). Now DOMINATING SET is fpt l- reducible to MONOTONE WCS[2] in an obvious way. Then the fpt l -reductions from MONOTONE WCS[2] to the other problems are the same as the fpt s l -reductions described in Theorem 3.2. Entirely similar to Theorem 3.3 and Theorem 3.4, we can prove that tight lower bounds hold for the problems in Theorem 4.4 and Theorem 4.5 even for very specific parameter values. Theorem 4.6: Let µ(n) be a non-decreasing and unbounded function. Even if we restrict the parameter values by k µ(n), none of the problems in Theorem 4.4 and Theorem 4.5 can be solved in time m o(k), unless all problems in SNP are solvable in subexponential time. Theorem 4.7: Unless all problems in SNP are solvable in subexponential time, for any non-decreasing and unbounded function µ(n) = O(n ɛ ), where 0 < ɛ < 1, none of the problems in Theorem 4.4 and Theorem 4.5 can be solved in time m o(k) even if we restrict the parameter values k to be Θ(µ(n)). V. LOWER BOUNDS ON APPROXIMATION SCHEMES In this section, we show another application of the fpt l - reduction in deriving lower bounds on the computational complexity of polynomial time approximation schemes for NPhard problems. Developing polynomial time approximation schemes has been one of the most popular approaches for tackling NP-hard problems [3]. A polynomial time approximation scheme (PTAS) for a problem Q is an approximation algorithm for Q that for any given constant ɛ > 0, runs in polynomial time and produces a solution with the relative error bounded by ɛ (we refer the readers to [3] for more detailed definitions). We pick the DISTINGUISHING SUBSTRING SELECTION problem as an example to illustrate our techniques. Consider all strings in a fixed alphabet. Denote by s the length of the 5 It can be shown that if W [1] = FPT then all problems in SNP are solvable in subexponential time. string s. The distance D(s 1, s 2 ) between two strings s 1 and s 2 is defined as follows. If s 1 = s 2, then D(s 1, s 2 ) is the Hamming distance between s 1 and s 2, and if s 1 s 2, then D(s 1, s 2 ) is the minimum of D(s 1, s 2) over all substrings s 2 of length s 1 in s 2. DISTINGUISHING SUBSTRING SELECTION (DSSP): given a tuple (n, S b, S g, d b, d g ), where n, d b, and d g are integers, d b d g, S b = {b 1,..., b nb } is the set of (bad) strings, b i n, and S g = {g 1,..., g ng } is the set of (good) strings, g j = n, find a string s of length n such that D(s, b i ) d b for all 1 i n b, and D(s, g j ) d g for all 1 j n g. The DSSP problem is NP-hard [10] and has important applications in biology such as in drug generic design [11]. Recently, Deng et al. [10], [11] developed a PTAS A D of running time O(m(n b + n g ) O(1/ɛ6) ) for the DSSP problem, where m is the size of the instance x. Obviously, this PTAS in its current form is not practical, even for very large relative error bound such as ɛ = 70%. Moreover, Gramm, Guo, and Niedermeier [15] showed that the parameterized version of the DSSP problem is W [1]-hard, thus excluding the possibility that the DSSP problem has a PTAS whose running time takes the form f(1/ɛ)m c, where c is a constant independent of 1/ɛ. However, this still does not exclude the possibility that the problem DSSP has a PTAS of running time of the form O((n b + n g ) µ(1/ɛ) p(m)), where p(m) is a polynomial of the instance size m and µ(1/ɛ) is a small function of 1/ɛ (in fact, this is what researchers hope for after developing the first PTAS for an NP-hard optimization problem). Using the technique of fpt l -reductions, we develop in this section a much stronger computational lower bound for the DSSP problem. We first consider the parameterized version of the DSSP problem. Each instance of the parameterized DSSP problem is a pair (x, r), where x = (n, S b, S g, d b, d g ) is an instance of the original DSSP, and r = d b + d g. Lemma 5.1: The parameterized DOMINATING SET problem is fpt l -reducible to the parameterized DSSP problem. Proof: For a given instance (G, k) of the parameterized DOMINATING SET problem, we show how to construct an instance (x G, r) for the parameterized DSSP problem. Suppose that the graph G has n vertices v 1,..., v n. Denote by vec(v i ) the binary string of length n in which all bits are 0 except the i-th bit is 1. The instance x G = (n, S b, S g, d b, d g ) for DSSP is constructed as follows: n = n + 5, S g consists of a single string g 0 = 0 n+5, d b = k 1, and d g = k + 3 (thus the parameter r = 2k + 2). The bad string set S b = {b 1,..., b n } consists of n strings, where b i corresponds to the vertex v i in G. Suppose the neighbors of the vertex v i in G are v i1,..., v ir, then the string b i takes the form vec(v i ) vec(v i ) vec(v i1 ) vec(v i1 ) vec(v ir ) vec(v ir ) where the dots stand for string concatenations. It is easy to see that the size of x G is bounded by a polynomial of the size of the graph G. 8

9 We prove that (G, k) is a yes-instance for DOMINATING SET if and only if (x G, r) is a yes-instance for DSSP. Suppose the graph G has a dominating set H of k vertices. Let vec(h) be the binary string of length n whose h-th bit is 1 if and only if v h H. Now consider the string s = vec(h) Clearly D(s, g 0 ) = k + 3. For each bad string b i, since H is a dominating set, either v i H or a vertex v j H is a neighbor of v i. If v i H then the substring b i = vec(v i) in b i satisfies D(s, b i ) = k 1, and if a vertex v j H is a neighbor of v i, then the substring b i = vec(v j) in b i satisfies D(s, b i ) = k 1. This verifies that D(s, b i) = k 1 for all 1 i n, thus, (x G, r) is a yes-instance of DSSP. Conversely, suppose (x G, r) has a solution s, which is a binary string of length n+5. Since g 0 = 0 n+5 and D(s, g 0 ) k +3, s has at least k +3 non-0 bits. On the other hand, it is easy to see that each substring of length n+5 in any bad string b i contains at most 4 non-0 bits. Since D(s, b i ) k 1 for each bad string b i, the string s should not contain more than k + 3 non-0 bits. Thus, the string s has exactly k + 3 non-0 bits. Now consider any substring b i of length n + 5 in a bad string b i such that D(s, b i ) k 1. The substring b i must contain 222 : otherwise b i has at most three non- 0 bits so D(s, b i ) k 1 would not be possible. If the substring 222 in b i does not match three 2 s in s, then s has at least k non-0 bits in other places while b i has only one non-0 bit in other place, so D(s, b i ) k 1 would not be possible. Thus, the string s must contain the substring 222, which matches the substring 222 in b i. Finally, observe that we can always assume that the string s ends with otherwise we simply cyclically shift the string s to move the substring to the end. Note if D(s, b i ) k 1 and b i is a substring in a segment vec(v j ) vec(v j ) in the bad string b i, then after shifting s, we must have D(s, b i ) k 1, where b i = vec(v j) Therefore, if s is a solution to the instance (x G, r), then so is the string after the cyclic shifting. Thus, the string s can be assumed to have the form s 02220, where s is a string of length n, with exactly k non-0 bits. Suppose that the j 1 -th, j 2 -th,..., and j k -th bits of s are non- 0. We claim that the vertex set H s = {v j1,..., v jk } makes a dominating set of k vertices for the graph G. In fact, for any bad string b i, let b i be a substring of length n + 5 in b i such that D(s, b i ) k 1. According to the above discussion, b i must be of the form vec(v j ) 02220, where either v j = v i or v j is a neighbor of v i. The only non-0 bit in vec(v j ) is the j-th bit, and j must be among {j 1,..., j k } otherwise D(vec(v j ), s ) is at least k + 1. Therefore, if v i = v j then v i H s, and if v j is a neighbor of v i, then v i is adjacent to the vertex v j in H s. This proves that H s is a dominating set of k vertices in G, and that (G, k) is a yes-instance for DOMINATING SET. From Lemma 5.1, we derive immediately Corollary 5.2: The DSSP problem is W [2]-hard. Corollary 5.2 improves a result in [15] that the parameterized DSSP problem is W [1]-hard. The following corollary follows directly from Lemma 5.1, Theorem 4.3, and Theorem 4.5. Corollary 5.3: Unless all problems in SNP are solvable in subexponential time, the parameterized DSSP problem cannot be solved in time f(k)m o(k) for any recursive function f. Finally, we show how to use Corollary 5.3 to derive a computational lower bound on any PTAS for the DSSP problem. According to [10], [11], an algorithm A 0 is a PTAS for the DSSP problem if for a given instance x = (n, S b, S g, d b, d g ) of DSSP and for a fixed constant ɛ > 0, the algorithm A 0 runs in polynomial time, and in case x is a yes-instance, returns a string s of length n such that for each bad string b i S b, D(s, b i ) d b (1 + ɛ), and for each good string g j S g, D(s, g j ) d g (1 ɛ). Theorem 5.4: Unless all problems in SNP are solvable in subexponential time, the DSSP problem has no PTAS of running time f(1/ɛ)m o(1/ɛ) for any recursive function f. Proof: Suppose to the contrary that the DSSP problem has a PTAS A 0 of running time f(1/ɛ)m o(1/ɛ) for some recursive function f. Now for an instance (x, k) of the parameterized DSSP problem, where x = (n, S b, S g, d b, d g ), call the PTAS algorithm A 0 on x and ɛ = 1/(2k) = 1/(2d b + 2d g ). First observe that if a string s satisfies the conditions D(s, b i ) d b (1 + ɛ) for all bad strings b i (1) D(s, g j ) d g (1 ɛ) for all good strings g j (2) for ɛ = 1/(2d b + 2d g ), then D(s, b i ) d b (1 + ɛ) = d b (1 + 1/(2d b + 2d g )) = d b + d b /(2d b + 2d g ) Since both D(s, b i ) and d b are integers, and d b /(2d b +2d g ) < 1, we get D(s, b i ) d b. Similarly, we get D(s, g j ) d g. Thus, if the algorithm A 0 returns a string s satisfying the conditions (1) and (2), then (x, k) is a yes-instance for DSSP. On the other hand, if (x, k) is a yes-instance, then by our assumption, A 0 must return a string s satisfying the conditions (1) and (2). Thus, (x, k) is a yes-instance if and only if the algorithm A 0 returns a string s satisfying the conditions (1) and (2). By the assumption, the running time of the algorithm A 0 is bounded by f(1/ɛ)m o(1/ɛ) = f(2k)m o(k). This shows that the parameterized DSSP problem can be solved in time f(2k)m o(k). Now the theorem follows from Corollary 5.3. Compared to the result in [15], Theorem 5.4 is much stronger. The result in [15] proved that if the DSSP problem has a PTAS of running time f(1/ɛ)m µ(1/ɛ), then µ cannot be a constant function, while Theorem 5.4 shows that µ cannot even be any sublinear function of 1/ɛ. This essentially excludes the possibility that the DSSP problem has a practically efficient PTAS even for moderate values of the error bound ɛ. To the authors knowledge, this is the first time a specific lower bound has been derived on the running time of a PTAS for an NPhard problem. Theorem 5.4 also demonstrates the usefulness of the linear fpt-reduction. In most cases, computational lower bounds and inapproximability of optimization problems are derived based on approximation ratio-preserving reductions [3], by which if 9