Parameterized complexity explained

In computer science, parameterized complexity is a branch of computational complexity theory that focuses on classifying computational problems according to their inherent difficulty with respect to multiple parameters of the input or output. The complexity of a problem is then measured as a function of those parameters. This allows the classification of NP-hard problems on a finer scale than in the classical setting, where the complexity of a problem is only measured as a function of the number of bits in the input. This appears to have been first demonstrated in . The first systematic work on parameterized complexity was done by .

Under the assumption that P ≠ NP, there exist many natural problems that require superpolynomial running time when complexity is measured in terms of the input size only but that are computable in a time that is polynomial in the input size and exponential or worse in a parameter . Hence, if is fixed at a small value and the growth of the function over is relatively small then such problems can still be considered "tractable" despite their traditional classification as "intractable".

The existence of efficient, exact, and deterministic solving algorithms for NP-complete, or otherwise NP-hard, problems is considered unlikely, if input parameters are not fixed; all known solving algorithms for these problems require time that is exponential (so in particular superpolynomial) in the total size of the input. However, some problems can be solved by algorithms that are exponential only in the size of a fixed parameter while polynomial in the size of the input. Such an algorithm is called a fixed-parameter tractable (FPT) algorithm, because the problem can be solved efficiently (i.e., in polynomial time) for constant values of the fixed parameter.

Problems in which some parameter is fixed are called parameterized problems. A parameterized problem that allows for such an FPT algorithm is said to be a fixed-parameter tractable problem and belongs to the class, and the early name of the theory of parameterized complexity was fixed-parameter tractability.

Many problems have the following form: given an object and a nonnegative integer, does have some property that depends on ? For instance, for the vertex cover problem, the parameter can be the number of vertices in the cover. In many applications, for example when modelling error correction, one can assume the parameter to be "small" compared to the total input size. Then it is challenging to find an algorithm that is exponential only in, and not in the input size.

In this way, parameterized complexity can be seen as two-dimensional complexity theory. This concept is formalized as follows:

A parameterized problem is a language

L\subseteq\Sigma* x \N

, where

\Sigma

is a finite alphabet. The second component is called the parameter of the problem.

A parameterized problem is fixed-parameter tractable if the question "

(x,k)\inL

?" can be decided in running time

f(k) ⋅ |x|O(1)

, where is an arbitrary function depending only on . The corresponding complexity class is called FPT.

For example, there is an algorithm that solves the vertex cover problem in

O(kn+1.274k)

time, where is the number of vertices and is the size of the vertex cover. This means that vertex cover is fixed-parameter tractable with the size of the solution as the parameter.

Complexity classes

FPT

FPT contains the fixed parameter tractable problems, which are those that can be solved in time

f(k) ⋅ {|x|}O(1)

for some computable function . Typically, this function is thought of as single exponential, such as

2O(k)

, but the definition admits functions that grow even faster. This is essential for a large part of the early history of this class. The crucial part of the definition is to exclude functions of the form

f(n,k)

, such as

kn

.

The class FPL (fixed parameter linear) is the class of problems solvable in time

f(k) ⋅ |x|

for some computable function . FPL is thus a subclass of FPT. An example is the Boolean satisfiability problem, parameterised by the number of variables. A given formula of size with variables can be checked by brute force in time

O(2km)

. A vertex cover of size in a graph of order can be found in time

O(2kn)

, so the vertex cover problem is also in FPL.

An example of a problem that is thought not to be in FPT is graph coloring parameterised by the number of colors. It is known that 3-coloring is NP-hard, and an algorithm for graph -coloring in time

f(k)nO(1)

for

k=3

would run in polynomial time in the size of the input. Thus, if graph coloring parameterised by the number of colors were in FPT, then P = NP.

There are a number of alternative definitions of FPT. For example, the running-time requirement can be replaced by

f(k)+|x|O(1)

. Also, a parameterised problem is in FPT if it has a so-called kernel. Kernelization is a preprocessing technique that reduces the original instance to its "hard kernel", a possibly much smaller instance that is equivalent to the original instance but has a size that is bounded by a function in the parameter.

FPT is closed under a parameterised notion of reductions called fpt-reductions. Such reductions transform an instance

(x,k)

of some problem into an equivalent instance

(x',k')

of another problem (with

k'\leqg(k)

) and can be computed in time

f(k) ⋅ p(|x|)

where

p

is a polynomial.

Obviously, FPT contains all polynomial-time computable problems. Moreover, it contains all optimisation problems in NP that allow an efficient polynomial-time approximation scheme (EPTAS).

W hierarchy

The W hierarchy is a collection of computational complexity classes. A parameterized problem is in the class W[''i''], if every instance

(x,k)

can be transformed (in fpt-time) to a combinatorial circuit that has weft at most i, such that

(x,k)\inL

if and only if there is a satisfying assignment to the inputs that assigns 1 to exactly k inputs. The weft is the largest number of logical units with fan-in greater than two on any path from an input to the output. The total number of logical units on the paths (known as depth) must be limited by a constant that holds for all instances of the problem.

Note that

FPT=W[0]

and

W[i]\subseteqW[j]

for all

i\lej

. The classes in the W hierarchy are also closed under fpt-reduction.

A complete problem for W[''i''] is Weighted i-Normalized Satisfiability:[1] given a Boolean formula written as an AND of ORs of ANDs of ... of possibly negated variables, with

i+1

layers of ANDs or ORs (and i alternations between AND and OR), can it be satisfied by setting exactly k variables to 1?

Many natural computational problems occupy the lower levels, W[1] and W[2].

W[1]

Examples of W[1]-complete problems include

W[2]

Examples of W[2]-complete problems include

W[''t'']

W[t]

can be defined using the family of Weighted Weft--Depth- SAT problems for

d\geqt

:

W[t,d]

is the class of parameterized problems that fpt-reduce to this problem, and

W[t]=cupd\geqW[t,d]

.

Here, Weighted Weft--Depth- SAT is the following problem:

It can be shown that for

t\geq2

the problem Weighted -Normalize SAT is complete for

W[t]

under fpt-reductions.[2] Here, Weighted -Normalize SAT is the following problem:

W[''P'']

W[''P''] is the class of problems that can be decided by a nondeterministic

h(k) ⋅ {|x|}O(1)

-time Turing machine that makes at most

O(f(k) ⋅ logn)

nondeterministic choices in the computation on

(x,k)

(a k-restricted Turing machine).

It is known that FPT is contained in W[P], and the inclusion is believed to be strict. However, resolving this issue would imply a solution to the P versus NP problem.

Other connections to unparameterised computational complexity are that FPT equals W[''P''] if and only if circuit satisfiability can be decided in time

\exp(o(n))mO(1)

, or if and only if there is a computable, nondecreasing, unbounded function f such that all languages recognised by a nondeterministic polynomial-time Turing machine using nondeterministic choices are in P.

W[''P''] can be loosely thought of as the class of problems where we have a set of items, and we want to find a subset

T\subsetS

of size such that a certain property holds. We can encode a choice as a list of integers, stored in binary. Since the highest any of these numbers can be is,

\lceillog2n\rceil

bits are needed for each number. Therefore

k ⋅ \lceillog2n\rceil

total bits are needed to encode a choice. Therefore we can select a subset

T\subsetS

with

O(k ⋅ logn)

nondeterministic choices.

XP

XP is the class of parameterized problems that can be solved in time

nf(k)

for some computable function . These problems are called slicewise polynomial, in the sense that each "slice" of fixed k has a polynomial algorithm, although possibly with a different exponent for each k. Compare this with FPT, which merely allows a different constant prefactor for each value of k. XP contains FPT, and it is known that this containment is strict by diagonalization.

para-NP

para-NP is the class of parameterized problems that can be solved by a nondeterministic algorithm in time

f(k) ⋅ |x|O(1)

for some computable function . It is known that

sf{FPT}=sf{para-NP}

if and only if

sf{P}=sf{NP}

.

A problem is para-NP-hard if it is

sf{NP}

-hard already for a constant value of the parameter. That is, there is a "slice" of fixed that is

sf{NP}

-hard. A parameterized problem that is

sf{para-NP}

-hard cannot belong to the class

sf{XP}

, unless

sf{P}=sf{NP}

. A classic example of a

sf{para-NP}

-hard parameterized problem is graph coloring, parameterized by the number of colors, which is already

sf{NP}

-hard for

k=3

(see Graph coloring#Computational complexity).

A hierarchy

The A hierarchy is a collection of computational complexity classes similar to the W hierarchy. However, while the W hierarchy is a hierarchy contained in NP, the A hierarchy more closely mimics the polynomial-time hierarchy from classical complexity. It is known that A[1] = W[1] holds.

See also

Notes

  1. Downey . Rod G. . Fellows . Michael R. . Fixed-Parameter Tractability and Completeness I: Basic Results . SIAM Journal on Computing . August 1995 . 24 . 4 . 873–921 . 10.1137/S0097539792228228 . en . 0097-5397.
  2. Buss . Jonathan F . Islam . Tarique . Simplifying the weft hierarchy . . 2006 . 351 . 3 . 303–313 . 10.1016/j.tcs.2005.10.002. free .

References

. Downey . Rod G. . Rod Downey. Fellows . Michael R. . Michael Fellows. Parameterized Complexity. Springer. 1999. 978-0-387-94883-6 .

. Flum . Jörg . Jörg Flum. Grohe . Martin . Martin Grohe. Parameterized Complexity Theory . 2006 . Springer. 978-3-540-29952-3 .

. Rolf Niedermeier . Invitation to Fixed-Parameter Algorithms . Oxford University Press . 2006 . 978-0-19-856607-6 . dead . https://web.archive.org/web/20080924051521/http://www.oup.com/uk/catalogue/?ci=9780198566076 . 2008-09-24.

. Martin Grohe. Descriptive and Parameterized Complexity. Computer Science Logic. Springer Berlin Heidelberg. Lecture Notes in Computer Science. 1683. 1999. 14–31. 978-3-540-66536-6. 10.1007/3-540-48168-0_3 . 10.1.1.25.9250 .

External links

This article is licensed under the GNU Free Documentation License. It uses material from the Wikipedia article "Parameterized complexity".

Except where otherwise indicated, Everything.Explained.Today is © Copyright 2009-2024, A B Cryer, All Rights Reserved. Cookie policy.