Deterministic Time Hierarchy Theorem

Statement
The theorem states that: If $$f(n)$$ is a time-constructible function, then there exists a decision problem which cannot be solved in worst-case deterministic time $$f(n)$$ but can be solved in worst-case deterministic time $$f(n)^2$$. In other words, the complexity class $$\mbox{DTIME}(f(n))$$ is a strict subset of DTIME$$(f(n)^2)$$. Note that $$f(n)$$ is at least n, since smaller functions are never time-constructible.

Even more generally, it can be shown that if $$f(n)$$ is time-constructible, then $$\operatorname{DTIME}\left(o\left(\frac{f(n)}{\log f(n)}\right)\right)$$ is properly contained in $$\operatorname{DTIME}(f(n))$$. For example, there are problems solvable in time n2 but not time n, since n is in $$o\left(\frac{n^2}{\log {n^2}}\right)$$.

Proof overview
We need to prove that some time class TIME(g(n)) is strictly larger than some time class TIME(f(n)). We do this by constructing a machine which cannot be in TIME(f(n)), by diagonalization. We then show that the machine is in TIME(g(n)), using a simulator machine.

Proof
We include here a proof that DTIME(f(n)) is a strict subset of DTIME(f(2n + 1)3) as it is simpler. See the bottom of this section for information on how to extend the proof to f(n)2.

To prove this, we first define a language as follows:


 * $$ H_f = \left\{ ([M], x)\ |\ M \ \mbox{accepts}\ x \ \mbox{in}\ f(|x|) \ \mbox{steps} \right\}. $$

Here, M is a deterministic Turing machine, and x is its input (the initial contents of its tape). [M] denotes an input that encodes the Turing machine M. Let m be the size of the tuple ([M], x).

We know that we can decide membership of Hf by way of a deterministic Turing machine that first calculates f(|x|), then writes out a row of 0s of that length, and then uses this row of 0s as a "clock" or "counter" to simulate M for at most that many steps. At each step, the simulating machine needs to look through the definition of M to decide what the next action would be. It is safe to say that this takes at most f(m)3 operations, so


 * $$ H_f \in \mathsf{TIME}(f(m)^3). $$

The rest of the proof will show that


 * $$ H_f \notin \mathsf{TIME}(f( \left\lfloor m/2 \right\rfloor )) $$

so that if we substitute 2n + 1 for m, we get the desired result. Let us assume that Hf is in this time complexity class, and we will attempt to reach a contradiction.

If Hf is in this time complexity class, it means we can construct some machine K which, given some machine description [M] and input x, decides whether the tuple ([M], x) is in Hf within $$ \mathsf{TIME}(f( \left\lfloor m/2 \right\rfloor )) $$.

Therefore we can use this K to construct another machine, N, which takes a machine description [M] and runs K on the tuple ([M], [M]), and then accepts only if K rejects, and rejects if K accepts. If now n is the length of the input to N, then m (the length of the input to K) is twice n plus some delimiter symbol, so m = 2n + 1. N&#39;s running time is thus $$ \mathsf{TIME}(f( \left\lfloor m/2 \right\rfloor )) = \mathsf{TIME}(f( \left\lfloor (2n+1)/2 \right\rfloor )) = \mathsf{TIME}(f(n)). $$

Now if we feed [N] as input into N itself (which makes n the length of [N]) and ask the question whether N accepts its own description as input, we get:
 * If N accepts [N] (which we know it does in at most f(n) operations), this means that K rejects ([N], [N]), so ([N], [N]) is not in Hf, and thus N does not accept [N] in f(n) steps. Contradiction!
 * If N rejects [N] (which we know it does in at most f(n) operations), this means that K accepts ([N], [N]), so ([N], [N]) is in Hf, and thus N does accept [N] in f(n) steps. Contradiction!

We thus conclude that the machine K does not exist, and so
 * $$ H_f \notin \mathsf{TIME}(f( \left\lfloor m/2 \right\rfloor )).$$

Extension
The reader may have realised that the proof is simpler because we have chosen a simple Turing machine simulation for which we can be certain that
 * $$ H_f \in \mathsf{TIME}(f(m)^3). $$

It has been shown that a more efficient model of simulation exists which establishes that
 * $$ H_f \in \mathsf{TIME}(f(m) \log f(m)) $$

but since this model of simulation is rather involved, it is not included here.