DTIME

In computational complexity theory, DTIME (or TIME) is the computational resource of computation time for a deterministic Turing machine. It represents the amount of time (or number of computation steps) that a "normal" physical computer would take to solve a certain computational problem using a certain algorithm. It is one of the most well-studied complexity resources, because it corresponds so closely to an important real-world resource (the amount of time it takes a computer to solve a problem).

The resource DTIME is used to define complexity classes, sets of all of the decision problems which can be solved using a certain amount of computation time. If a problem of input size n can be solved in ⁠ $O(f(n))$ ⁠, we have a complexity class ⁠ ${\mathsf {DTIME}}(f(n))$ ⁠ (or ⁠ ${\mathsf {TIME}}(f(n))$ ⁠). There is no restriction on the amount of memory space used, but there may be restrictions on some other complexity resources (like alternation).

Complexity classes in DTIME

Many important complexity classes are defined in terms of DTIME, containing all of the problems that can be solved in a certain amount of deterministic time. Any proper complexity function can be used to define a complexity class, but only certain classes are useful to study. In general, we desire our complexity classes to be robust against changes in the computational model, and to be closed under composition of subroutines.

DTIME satisfies the time hierarchy theorem, meaning that asymptotically larger amounts of time always create strictly larger sets of problems.

The well-known complexity class P comprises all of the problems which can be solved in a polynomial amount of DTIME. It can be defined formally as:

{\mathsf {P}}=\bigcup _{k\in \mathbb {N} }{\mathsf {DTIME}}(n^{k})

P is the smallest robust class which includes linear-time problems ${\mathsf {DTIME}}\left(n\right)$ (AMS 2004, Lecture 2.2, pg. 20). P is one of the largest complexity classes considered "computationally feasible".

A much larger class using deterministic time is EXPTIME, which contains all of the problems solvable using a deterministic machine in exponential time. Formally, we have

{\mathsf {EXPTIME}}=\bigcup _{k\in \mathbb {N} }{\mathsf {DTIME}}\left(2^{n^{k}}\right).

Larger complexity classes can be defined similarly. Because of the time hierarchy theorem, these classes form a strict hierarchy; we know that ${\mathsf {P}}\subsetneq {\mathsf {EXPTIME}}$ , and on up.

Machine model

For robust classes, such as P, the exact machine model used to define DTIME can vary without affecting the power of the resource. The Computational Complexity literature often defines DTIME based on multitape Turing machines, particularly when discussing very small time classes. A multitape deterministic Turing machine can never provide more than a quadratic time speedup over a singletape machine.^[1]

Due to the Linear speedup theorem for Turing machines, multiplicative constants in the time bound do not affect the extent of DTIME classes; a constant multiplicative speedup can always be obtained by increasing the number of states in the finite state control and the size of the tape alphabet. In the statement of Papadimitriou,^[2] for a language $L$ ,

Let

L\in {\mathsf {DTIME}}(f(n))

. Then, for any

\epsilon >0

,

L\in {\mathsf {DTIME}}(f'(n))

, where

f'(n)=\epsilon f(n)+n+2

.

Generalizations

Using a model other than a deterministic Turing machine, there are various generalizations and restrictions of DTIME. For example, if we use a nondeterministic Turing machine, we have the resource NTIME. The relationship between the expressive powers of DTIME and other computational resources are very poorly understood. One of the few known results^[3] is

{\mathsf {DTIME}}(O(n))\neq {\mathsf {NTIME}}(O(n))

for multitape machines. This was extended to

{\mathsf {DTIME}}(O(n{\sqrt {\log ^{*}n}}))\neq {\mathsf {NTIME}}(O(n{\sqrt {\log ^{*}n}}))

by Santhanam.^[4]

If we use an alternating Turing machine, we have the resource ATIME.

References

^ Papadimitriou 1994, Thrm. 2.1
^ 1994, Thrm. 2.2
^ Paul Wolfgang, Nick Pippenger, Endre Szemerédi, William Trotter. On determinism versus non-determinism and related problems. 24th Annual Symposium on Foundations of Computer Science, 1983. doi:10.1109/SFCS.1983.39
^ Rahul Santhanam, On separators, segregators and time versus space, 16th Annual IEEE Conference on Computational Complexity, 2001.

American Mathematical Society (2004). Rudich, Steven and Avi Wigderson (ed.). Computational Complexity Theory. American Mathematical Society and Institute for Advanced Study. ISBN 0-8218-2872-X.
Papadimitriou, Christos H. (1994). Computational Complexity. Reading, Massachusetts: Addison-Wesley. ISBN 0-201-53082-1.

[1] Papadimitriou 1994, Thrm. 2.1

[2] 1994, Thrm. 2.2

[3] Paul Wolfgang, Nick Pippenger, Endre Szemerédi, William Trotter. On determinism versus non-determinism and related problems. 24th Annual Symposium on Foundations of Computer Science, 1983. doi:10.1109/SFCS.1983.39

[4] Rahul Santhanam, On separators, segregators and time versus space, 16th Annual IEEE Conference on Computational Complexity, 2001.

[1]

[2]

[3]

[4]

Complexity classes
Considered feasible	DLOGTIME AC⁰ ACC⁰ TC⁰ L SL RL FL NL NL-complete NC SC CC P P-complete ZPP RP BPP BQP APX FP
Suspected infeasible	UP NP NP-complete NP-hard co-NP co-NP-complete TFNP FNP AM QMA PH ⊕P PP #P #P-complete IP PSPACE PSPACE-complete
Considered infeasible	EXPTIME NEXPTIME EXPSPACE 2-EXPTIME ELEMENTARY PR R RE ALL
Class hierarchies	Polynomial hierarchy Exponential hierarchy Grzegorczyk hierarchy Arithmetical hierarchy Boolean hierarchy
Families of classes	DTIME NTIME DSPACE NSPACE Probabilistically checkable proof Interactive proof system
List of complexity classes

Fahrer / Team für die Suche eingeben: