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 $\mathsf{DTIME}(f(n))$ is a strict subset of $\mathsf{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 $n^2$ 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 $\mathsf{TIME}(g(n))$ is strictly larger than some time class $\mathsf{TIME}(f(n))$. We do this by constructing a machine which cannot be in $\mathsf{TIME}(f(n))$, by diagonalization. We then show that the machine is in $\mathsf{TIME}(g(n))$, using a simulator machine.

Proof
We include here a proof that $\mathsf{DTIME}(f(n))$ is a strict subset of $\mathsf{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 $H_f$ 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 $H_f$ is in this time complexity class, and we will attempt to reach a contradiction.

If $H_f$ 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 $H_f$ 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$’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 $H_f$, 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 $H_f$, 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.