CONCLUSIONES Y RECOMENDACIONES

Complexity theoryis the field of theoretical computer science that tries to classify algorithmic problems according to their computational needs. It formalizes the idea of abstract machines that execute algorithms, and defines reasonable technicalities to specify the intrinsic computational requirements of an abstract machine that solves an algorithmic problem. These needs are phrased in terms of the asymptotic usage of memory space or the asymptotic number of steps that are required to solve the problem.

Bothlogic and complexity theory deal with algorithmic problems. A typical question in logic is whether a given problem isdecidable, i.e. whether there is an algorithm that solves the problem. Although the decidability question plays a role in complexity theory as well, the major concern of complexity theory is to answer the question howfasta decidable problem can be solved. We only consider decidable problems here.

Analgorithmic problemis the formal description of the relation between some input data describing the problem instances and some output data describing a

solutionto the given instance. For example, “sorting a list of natural numbers” could be seen as an algorithmic problem in which the set of problem instances is the set of lists of natural numbers and the corresponding solution of a given list of natural numbers would be the respective ordered version. The description of an algorithmic problem is purely theoretical and does neither favor nor specify a concrete algorithm thatsolvesthe problem.

2.1. COMPLEXITY THEORY 15

One of the most important tasks of complexity theory is to assign different algorithmic problems that share common computational properties to so-called

complexity classes. A complexity class usually specifies acomputational model, a

computational paradigm, and someresource bounds.

Thecomputational modeldescribes the abstract machine on which algorithms, based on a finite set of fundamental operations, can be executed by having access to some kind of memory. There are several reasonable computational models that can be applied when studying algorithmic problems from a theoretical point of view. The most commonly used model is, probably, the class ofTuring machines(TM), named after its inventor Alan Turing. A Turing machine is a theoretical automaton that fulfills state transitions ranging over a finite number of states with the additional ability to have read and write access to a constant number of potentially unbounded tapes.

Thecomputational paradigmexplains how the execution of an algorithm is to be performed. We consider the following two paradigms:

• deterministic paradigm: the current computational state has at most one successive state, and

• non-deterministic paradigm: the current computational state can have more than one successive state.

Applying an algorithm (i.e. a Turing machine) to an input instance, results in arun, which is the complete trace of atomic steps that the abstract machine performed on the input instance to generate an output instance. Note that a deterministic algorithm has exactly one run on a given input instance, whereas a non-deterministic algorithm can have more than one run on a given input instance.

Along with the output instance, the Turing machine has to specify whether the run isaccepting orrejecting. This is particularly important when applying a non- deterministic Turing machine to an input instance, because here it is possible that some runs are accepting and others are not. The output instance is only considered to be valid, if the corresponding run is accepting. Note that many problems are phrased asdecision problemsin which we do not expect any output instances.

16 CHAPTER 2. PRELIMINARIES

Complexity theory considers the asymptoticresource consumptionthat is nec- essary to solve algorithmic problems. The most interesting resources aretimeand

space. We only consider time in this thesis. Given a run r of a TM T, we let timeT(r)denote the length of r. It is here that Landau symbols are particularly useful. Instead of presenting detailed resource-bounding functionsf along with an algorithm that solves the respective problem, we usually apply theO(∗)-notation to specify asymptotic resource-bounds.

The analysis of some resource complexity is ultimately based on relating the

sizeof an input instance to the resource consumption of an associated run. When considering concrete algorithmic problems like sorting cards or solving thetraveling salesman problem, one usually leaves the details of the encoding of the problem implicit. This is reasonable most of the time, however, one needs to be careful in some occasions. Natural numbers, for instance, can be encoded asunary numbers, i.e. the encoding size of a number directly coincides with the number itself, or they can be encoded asbinary numbers, i.e. the encoding size of a number islogarithmic

in the number itself. Obviously, these two encodings result in quite different sizes of input instances. Hence, whenever implicit encodings raise such ambiguities, one has to be more specific about the respective encoding details.

Complexity theory investigates two kinds of questions. First, given a concrete algorithm that solves a concrete algorithmic problem, what are upper and lower bounds on the algorithmic complexity of the algorithm? Such bounds are usually expressed in terms of Landau symbols. The typical strategy to give a lower bound proof is to exhibit a family of input instances of increasing size that results in runs that can be bounded by the desired lower bound function. Upper bound proofs usually rely on some combinatorial analysis.

Second, given a concrete algorithmic problem, what are upper and lower bounds on the complexity of the algorithmic problem? Upper bounds are usually given by the construction of a concrete algorithm along with an upper bound on it. Lower bounds on an algorithmic problem again rely on combinatorial analysis most of the time.

2.1. COMPLEXITY THEORY 17

Complexity Classes

Complexity theory is mainly concerned with the collection of algorithmic problems with common resource bounds, forming a complexity class. We assume some familiarity with the relationships between the important complexity classesNPandP, and briefly recap their informal definitions in the following:

• P: the class of all decision problems that can be solved by a polynomial-time bounded deterministic Turing machine,

• NP: the class of all decision problems that can be solved by a polynomial-time bounded non-deterministic Turing machine, that accepts an input iff it has an accepting run on it,

• coNP: the class of all decision problems that can be solved by a polynomial- time bounded non-deterministic Turing machine, that accepts an input, iff it has no rejecting run on it,

• UP: the class of all decision problems that can be solved by a polynomial-time bounded non-deterministic Turing machine, that accepts an input iff it has an accepting run on it, and that has no more than one accepting run on every input instance, and

• coUP: the class of all decision problems that can be solved by a polynomial- time bounded non-deterministic Turing machine, that accepts an input, iff it has no rejecting run on it, and that has no more than one rejecting run on every input instance.

Deterministic polynomial-time bounded algorithms are generally considered as being efficient. However, it is debatable whether an algorithm that runs in time

Ω(n100_{)is really efficient in practice.}

An alternative definition of NP-problems is known as the “guess and check” characterization: a problem is inNP iff given an input instancex and a potential solutiony, it is easy (that is, in deterministic polynomial time) to verify whether the solution is actually correct.

18 CHAPTER 2. PRELIMINARIES

It is a major open problem whetherNP = P. The predominant opinion of the scientific community is thatP₍NP. In fact, many theorems of nowadays complexity theory are based on theassumptionthatNP6=P. Assuming this common hypothesis, it can be shown that there are problems in NP that are neither NP-complete nor contained inP[Lad75]. However, there are no knownnaturalNP-problems that can be shown to reside betweenNP-complete andPproblems, assuming thatNP6=P.

The main problems of this thesis – deciding the winner of certain infinitary payoff games (excluding Markov decision processes) – are some of the very rare natural combinatorial problems that are known to be inNP, coNP,UP and coUP, but that are not yet known to be inP. Due to the fact that these problems are contained in the formerly mentioned complexity classes, it is generally considered to be quite unlikely that they are complete for any of those. In fact, most scientists believe that these problems are actually contained inP. However, this question is still open.

Arithmetic Model

A very important computational model is the arithmetic model which allows to perform basic arithmetic operations like addition or multiplication in unit time, regardless of the size of the operands. This relates quite naturally to computers of our real life, since arithmetic operations are performed in essentially unit time by our CPUs.

We say that an algorithm runs instrongly polynomial timeiff the time complexity is polynomially bounded by thenumber of integers of the input instance. Such algorithms can be easily converted into “normal” polynomial-time algorithms by replacing the unit time arithmetic operations by polynomial-time implementations.

An algorithm runs inweakly polynomial time on the other hand, iff it runs in polynomial time, but not in strongly polynomial time. Therefore, the runtime of the algorithm really depends on the integers rather than only on the number of integers.

In the field of combinatorial optimization, like linear programming and infinitary payoff game theory, strongly polynomial-time algorithms are generally desirable, as they only depend on thecombinatorial structureof the problem rather than on complex arithmetic phenomena.

2.1. COMPLEXITY THEORY 19

The Search ClassPLS

Some algorithmic problems can be phrased assearch problems, in which the algo- rithm starts with some initial solution to the given input instance, proceeds to some neighboring solution, until an optimal solution has been found. In general, this is a locally optimal solution. Papadimitriou, Yannakakis and Johnson [JPY88,PY88] were the first to define a rigorous complexity class that captures these kinds of problems.

Again, the complexity class of local search problems is defined w.r.t. input instances as words over a finite alphabet, so that we can easily measure the size of a given input instance. We leave the alphabets and lengths of words implicit here and just assume that we can assign a size to an input instance in a reasonable way.

More formally, a polynomial local search problem (PLS problem) is a tuple

(D, S, F, N, c), where

• Dis the set ofinstances,

• Sis the set ofsolutions,

• F :D→2S _{is a function that assigns every instance a non-empty, finite set of} solutions,

• N :D×S →2S _{is a function that assigns every instancexand every solution}

s∈F(x)aneighborhoodN(x, s)⊆F(x), and

• c:D×S →_Ris a function that assigns every instancexand every solution

s∈F(x)somecostc(x, s)

such that there are deterministic polynomial-time (in the size of the instance) algo- rithms for the following tasks, given an instancex∈D:

• the selection of an initials∈F(x),

• the computation ofc(x, s)fors∈F(x),

• the decision, whether there is somes0 _{∈ N(x, s)withc(x, s}0_{) > c(x, s)for} s∈F(x), and the computation of such ans0 _{in case it exists.}

20 CHAPTER 2. PRELIMINARIES

The goal is to compute, given an instancex, a solutions ∈ F(x)withlocally maximal cost, i.e. there is nos0 _{∈ N(x, s)withc(x, s}0_{) > c(x, s). The standard}

method for computing such a solution can be realized by Algorithm2.

Algorithm 2Polynomial Local Search 1: s←some element ofF(x)

2: whilethere is somes0 _{∈N(x, s)}

withc(x, s0_{)> c(x, s)do}

3: s←s0, wheres0 _{∈N(x, s)withc(x, s}0_{)> c(x, s)}

4: end while 5: returns

An appealing feature of polynomial local search problems is that they can be approximated to any factor in polynomial time (polynomial in the instance size and the approximation factor) [OPS04].