Classical Complexity Theory

We introduce some basic concepts of classical complexity theory. For a more detailed treatment we refer to textbooks on the topic (e.g., Arora & Barak, 2009).

In complexity theory, computational problems are often studied in the form of decision problems. Decision problems represent yes-no questions that are asked about a given input.

Definition 4.1.1 (Decision problem). LetΣbe a finite alphabet. Adecision problemL (overΣ) is a subset ofΣ∗, where Σ∗ is the set of all strings over the alphabet Σ, i.e., Σ∗=S_{

Σm;m∈_N}. We call x∈Σ∗ a yes-instance of L if and only if x∈L.

With the size |x| of an instancex ∈ Σ∗ we denote the size of the string x, i.e., the number of symbol occurrences in x. We represent a decision problem L in the following form. To simplify notation, we do not mention the underlying alphabet explicitly.

ProblemName (L) Instance: x∈Σ∗

Question: Is x∈L?

Another important notion in complexity theory is the concept of asymptotic running time, which measures how fast the running time of an algorithm increases with the input size. In order to capture this formally, the following notion of Big-Oh is used.

Definition 4.1.2 (Big-Oh). Let f :N→N be a function. Then,

O(f) ={g:N→N;∃c, no∈N∀n > no:g(n)≤c·f(n)}.

As is common, we will write f(n) isO(g(n)) instead off(n)∈O(g(n)).

The concept of efficiently solvable problems is captured by the complexity class P, which is defined as follows.

Definition 4.1.3 (The class P). Let Σbe a finite alphabet.

1. An algorithm Awith inputx∈Σ∗ runs in polynomial timeif there exists a polynomialp such that for all x ∈ Σ∗, the running time of A on x is at most p(|x|). We call algorithms with this property polynomial-time algorithms.

2. P denotes the class of all decision problems that can be decided by a polynomial-time algorithm.

In order to give evidence that certain problems are intractable, i.e., are not in P, complexity theory offers a theoretical tool that is based on the following complexity class, NP.

Definition 4.1.4 (The class NP). Let Σ be a finite alphabet and L ⊆ Σ∗ a decision problem. Then Lis in complexity class NP if there exists a polynomialp and a polynomial-time computable functionf : Σ∗→N (called the verifier for L) such that for all x∈Σ∗,

x∈L ⇐⇒ ∃u∈Σp(|x|) s.t. f(x, u) = 1.

If x∈L andu∈Σp(|x|) satisfy f(x, u) = 1, then we call u a certificate for x.

Another crucial part of this intractability tool is the notion of polynomial-time reductions. Definition 4.1.5 (Polynomial-time reduction). Let L ⊆ Σ∗ and L0 ⊆ (Σ0)∗ be two decision problems. A polynomial-time reductionfrom Lto L0 is a mappingR : Σ∗ →(Σ0)∗ from instances of L to instances of L0 such that for all x∈Σ∗:

2. R is computable in polynomial time.

We can now describe the final notions that we need for the theoretical tool to show intractability: the notions of hardness and completeness for a certain complexity class.

Definition 4.1.6 (Completeness and Hardness). Let L be a decision problem and K a com- plexity class. Then,

1. L is K-hard if each problem L0 in K is polynomial-time reducible to L, and 2. L is K-completeif L is K-hard and in K.

It follows from the definitions that P ⊆ NP. It is widely believed that P 6= NP (see, e.g., Fortnow, 2009, Gasarch, 2012). This conjecture implies that NP-hard problems are not polynomial- time decidable. Therefore, showing that a problem is NP-hard gives evidence that this problem is intractable.

The following two complexity classes can be used in a similar way to show intractability: a problem that is hard for any of these classes is not polynomial-time solvable, unless P = NP. Definition 4.1.7 (The class co-NP). Let Σ be a finite alphabet andL⊆Σ∗ a decision problem. ThenLis in complexity classco-NPif there exists a polynomialpand a polynomial-time computable functionf : Σ∗→_N (called the verifier for L) such that for all x∈Σ∗,

x∈L ⇐⇒ ∀u∈Σp(|x|) it holds that f(x, u) = 1.

If x∈L andu∈Σp(|x|) satisfy f(x, u) = 1, then we call u a certificate for x.

Definition 4.1.8 (The class PSPACE). Let s : N → N be a function. We say that a Turing machine M runs in space s if for every x ∈ Σ∗ every run of M with input x only consists of configurations of size at most s(|x|) (see the appendix for a definition of Turing machines). The class PSPACE consists of all problems Q for which there exists a polynomial p : N → N and a Turing machine M such that (1) M runs in space p and (2)M decides Q.

Intuitively, the class PSPACE consists of all problems that can be solved by an algorithm that uses a polynomial amount of memory.

As mentioned before, the class P is a subset of NP. Similarly, P is also a subset of co-NP. Whether P is a strict subset of co-NP (or NP) is not known, but it is widely believed that this is the case. It is also widely believed that NP and co-NP do not coincide, but this is also not known. Finally, all classes P, NP and co-NP are contained in the class PSPACE. Again, whether these inclusions are strict is not known. For an overview of these complexity classes, see Figure 4.1.

P

NP co-NP

PSPACE

Figure 4.1: Overview of the complexity classes P, NP, co-NP, and PSPACE.