Because of its generality and uniformity, the model of Turing machines can be used for observations in several algorithm related questions. For example, with the help of it, one can express the complexity of tasks.

In general, we call a task difficult, if its solution requires operations, which are hard to understand, unusual or it exceeds our abilities. However, a computer has no such problems, if the solution is programmed properly. Thus, from the viewpoint of algorithms, we have to reconsider the concept of difficulty. If we expect an answer from a computer, then the only thing we can sense about the "problems" of it, if we have to wait too long. We will express the this property (and some other) by the use of Turing machines.

First we define the time, space and program complexity of deterministic and nondetreministic Turing machines. Using these concepts we are able to express the different resource needs of algorithms (Turing machines).

Since usually an algorithm is not for solving a particular task but a class of tasks, thus we have to be able to express the resource needs for the complete class of tasks.

The most important complexity concept is time complexity.

**Definition 7.1.**

Let be a deterministic Turing machine and let be a word. Furthermore, let be the computation of on the input . Assume, that there exists such that is a final configuration. The least such a value for is called the length of the computation. If such exists, then we say that the computation is infinite. The notation for the length of the computation of the Turing machine on the input word is: or .

The length of a computation is used as the expression of running time, without telling anything about the concept of time resource. Hence we can define the general time needs of a Turing machine.

**Definition 7.2.**

Let be a deterministic Turing machine. The time complexity of is the function , where

If it causes no confusion, we may omit the symbol of the Turing machine from the notation of time complexity.

The time complexity, defined above, expresses what is the length of computation for a given Turing machine on bounded size input words in the worst case. This is why it is sometimes called the worst case complexity.

One may define the average case complexity, too. It is more expressive from the view point of standard programming, but in general it is much more difficult to compute. It is necessary to know some kind of distribution of input data, which is usually not obvious.

**Remark 7.3.**

If a Turing machine has well defined time complexity for all , then it terminates on all input, i.e. the recognized language is recursive.

**Remark 7.4. **

Let be a deterministic Turing machine with time complexity . The value is the length of the longest computation on an input word not longer than , while the value is the length of the longest computation on an input word not longer than . Since the latter case includes all input words from the previous one, thus . It means that the function is monotone increasing.

By a similar approach one may define the space needs of an algorithm (Turing machine).

**Definition 7.5.**

Let be a deterministic Turing machine and let be a word. Furthemore, let be the computation of on the input . Assume, that and let . If there exists, the value is called the space needs of the computation. If no such value exists, the space needs is called infinite. The space needs of the computation of on the input is denoted by .

Using the concept of space needs one may define space complexity

**Definition 7.6.**

Let be a deterministic Turing machine. The space complexity of is the function , where

The notation of the Turing machine can be omitted here, too, if it causes no confusion.

Similarly as in the case of time complexity one may have the following remark.

**Remark 7.7.**

Let be a deterministic Turing machine and let beits space complexity. The value is the largest space needs on input word of length at most , while the value is the largest space needs on input word of length at most . Since the latter case includes all input words from the previous one, thus . This means that is monotone increasing.

Finally one can define the complexity of a Turing machine itself.

**Definition 7.8.**

Let be a deterministic Turing machine and let be its program. The program complexity of is the value .

**Remark 7.9.**

By Definition 7.8., the program complexity does not depend on the length of the input word. However, the implementation of an algorithm (which is a program) may depend. If the size of the input is above a limit, then the program may need another structure, to handle system memory, accessing the input, etc.

Similarly to the deterministic case one can define time and space complexity for nondeterministic Turing machines, too. However, since the general definitions are less expressive, we introduce them only for acceptor Turing machines.

**Definition 7.10.**

Let be a nondeterministic acceptor Turing machine and let be a word. Assume that there exists a computation of on the input , which terminates in an acceptin state. The length of the shortes accepting computation is called the length of the computaiton. If there are no computation terminating in an accepting state, then the length of the computation is infinite. Similarly as in the deterministic case, the length of the computation of on the input is denoted by .

For nondeterministic Turing machines, the length of the computation is defined only for input words, which are accepted by the Turing machine. Thus the definition of time complexity should be changed, too.

**Definition 7.11.**

Let be a nondeterministic Turing machine. The time complexity of is the function , where .

The space complexity of nondeterministic Turing machines is the following.

**Definition 7.12.**

Let be a nondeterministic acceptor Turing machine and let be a word. Assume that has a computation, which terminates in an accepting state on the input . Let be a possible computation of on the input , which terminates in ana ccepting state. Assume that and let . The space need of the computation is . The least space need of the possible computations on the input word is called the space need of the computation. If there are no accepting computation, then the space need is infinite. The space need of on the input is denoted by .

As in the case of time complexity, the space need is defined only for input words, which are accepted by the Turing machine. Thus the space complexity requires some modification, too.

**Definition 7.13.**

Let be a nondeterministic Turing machine. The space complexity of is a function , where

The following theorem is some additional property of recursive languages. It says, if a language is recursively enumerable and its time complexity is not too big, then the language is recursive. Reversing the statement, if a language is not recursive and there exists a Turing machine which accepts it, then its time complexity (function) is uncomputable big. It yields some really fast increasing function, since the Ackermann function is still computable.

**Theorem 7.14.**

Let be a language. Assume that ther exists a function , which can be computed by a Turing machine and let be a deterministic Turing machine, such that . If terminates on the members of after at most steps, then .

**Proof**

Let be the Turing machine, which computes , i.e. and let be the limited time Turing machine created from , as we have seen before. Using these Turing machines, compose the following:

1. According to the input , the new Turing machine writes a sequence of 's of length to tape .

2. Start on the input word . If during the computation the part corresponding to terminates, then its decision is the actual decision. If the limiting part terminates first, then the answer is "no".

Clearly the Turing machine terminates on every input word and it accepts an input word if and only if it is accepted by . This is because if accepts it, then the length of computation is not more than . By definition, it means . ✓