# Teorema de la jerarquía temporal

En la teoría de complejidad computacional, los teoremas de jerarquía temporal son declaraciones importantes sobre cómputo de tiempo acotado en máquinas de Turing. Informalmente, estos teoremas dicen que con más tiempo, una máquina de Turing puede resolver más problemas. Por ejemplo, hay problemas que pueden ser solucionados en tiempo O(n$^2$) pero no en O(n).
El teorema de la jerarquía temporal para máquinas de Turing deterministas fue probado por Richard Stearns y Juris Hartmanis. Como consecuencia, para cada clase de complejidad acotada temporalmente, hay otra clase de complejidad estrictamente mayor, tal que la jerarquía de acotación temporal para clases de complejidad converja por completo. Más concretamente, el teorema de jerarquía temporal para máquinas de Turing deterministas dice que para toda función computable $f(n)$, :$\operatorname {DTIME} \left(o\left({\frac {f(n)}{\log f(n)}}\right)\right)\subsetneq \operatorname {DTIME} (f(n))$.
El teorema de jerarquía temporal para máquinas de Turing no deterministas fue probado por Stephen Cook. El teorema de la jerarquía temporal para máquinas de Turing no deterministas dice que si g(n) es una función computable, y f(n+1) = o(g(n)), entonces
    $\operatorname {NTIME} (f(n))\subsetneq \operatorname {NTIME} (g(n))$.
Los teoremas análogos para espacio son los teoremas de jerarquía espacial. Para el caso de clases de complejidad probabilística acotada en el tiempo no hay teoremas similares, salvo que la clase tenga también aviso.

## Introducción

Ambos teoremas usan la noción de una función computable. Una función $f:\mathbb {N} \rightarrow \mathbb {N}$ es computable si existe una máquina de Turing determinista tal que por cada $n\in \mathbb {N}$, si la máquina empieza con una entrada de n unos, se parará precisamente tras $f(n)$ pasos. Todo polinomio con coeficientes de integración no negativos es computable, así como las funciones exponenciales tales como $2^{n}$.

## Idea de la prueba

Necesitamos probar que alguna clase temporal TIME(g(n)) es estrictamente mayor que otra clase temporal TIME(f(n)). Hacemos esto construyendo una máquina tal que no se pueda dar en TIME(f(n)) mediante diagonalización. Entonces mostramos que la máquina pertenece a TIME(g(n)), mediante modelado numérico.

## Teorema de la jerarquía temporal determinista
### Declaración

El teorema declara que: Sea $f(n)$ una función computable, entonces existe un problema de decisión el cual no puede ser resuelto en el mejor caso de tiempo determinista $f(n)$ pero que puede ser resuelto el peor caso de tiempo determinista $f(n)^{2}$. En otras palabras, la clase de complejidad DTIME$(f(n))$ es un subconjunto estricto de DTIME$(f(n)^{2})$. Obsérvese que $f(n)$ es al menos n, pues funciones más pequeñas no serían computables.
Se puede generalizar que si $f(n)$ es computable, entonces
    $\operatorname {DTIME} \left(o\left({\frac {f(n)}{\log f(n)}}\right)\right)\subsetneq \operatorname {DTIME} (f(n))$.
Por ejemplo, hay problemas con solución en tiempo n$^2$ pero no en tiempo n, pues n está en
    $o\left({\frac {n^{2}}{\log {n^{2}}}}\right)$.

### Prueba

Incluimos aquí una prueba de que DTIME(f(n)) es un subconjunto estricto de DTIME(f(2n + 1)$^3$) puesto que es más sencillo. Véase el final de esta sección para encontrar información sobre cómo extender la prueba a f(n)$^2$.
Para probarlo, primero definimos el siguiente lenguaje:
    $H_{f}=\left\{([M],x)\ |\ M\ {\mbox{acepta}}\ x\ {\mbox{en}}\ f(|x|)\ {\mbox{pasos}}\right\}.$
Siendo M una máquina de Turing determinista, y x su entrada (el contenido inicial de su cinta). [M] denota una entrada que codifica la máquina de Turing M. Sea m del tamaño de la tupla ([M], x).
Sabemos que podemos determinar la pertenencia de H$_f$ mediante una máquina de Turing determinista que primero calcula f(|x|), y luego escribe una fila de ceros de esa longitud, y que luego usa esa fila de ceros como "reloj" o "contador" para simular M con ese límite de pasos. En cada paso, la máquina simulada necesita mirar a través de la definición de M para decidir cuál será la siguiente acción a tomar. Es seguro decir que eso conlleva como mucho f(m)$^3$ operaciones, por lo que
    $H_{f}\in {\mathsf {TIME}}(f(m)^{3}).$
El resto de la prueba mostrará que
    $H_{f}\notin {\mathsf {TIME}}(f(\left\lfloor m/2\right\rfloor ))$
por lo que si sustituimos 2n + 1 for m, tendremos el resultado deseado. Asumamos que H$_f$ es en esa clase de complejidad temporal, e intentemos llegar a una contradicción.
Si H$_f$ está en esta clase de complejidad temporal, significa que podemos construir alguna máquina K la cual, dada una descripción de máquina [M] y una entrada x, decide si la tupla ([M], x) está en H$_f$ dentro de ${\mathsf {TIME}}(f(\left\lfloor m/2\right\rfloor ))$.
Por consiguiente podremos usar esa K para construir otra máquina, N, la cual tome una descripción de máquina [M], ejecute K en la tupla ([M], [M]), y acepte solo si K rechaza, y rechace si K acepta. Si ahora n es la longitud de la entrada para N, entonces m (la longitud de la entrada para K) es el doble de n más algún símbolo delimitador, por lo que m = 2n + 1. Por lo tanto, el tiempo de ejecución de N ${\mathsf {TIME}}(f(\left\lfloor m/2\right\rfloor ))={\mathsf {TIME}}(f(\left\lfloor (2n+1)/2\right\rfloor ))={\mathsf {TIME}}(f(n)).$
Si alimentamos ahora [N] como entrada en la misma N (siendo n la longitud de [N]) y preguntamos si N acepta su propia descripción como entrada, obtenemos:
* Si N acepta [N] (la cual sabemos que al menos hace f(n) operaciones), significa que K rechaza ([N], [N]), por lo que ([N], [N]) no pertenece a H$_f$, por lo que N no acepta [N] en f(n) pasos. ¡Contradicción!
* Si N rechaza [N] (la cual sabemos que al menos hace f(n) operaciones), significa que K acepta ([N], [N]), por lo que ([N], [N]) pertenece a H$_f$, por lo que N acepta [N] en f(n) pasos. ¡Contradicción!
Por tanto concluimos que la máquina K no existe, de lo cual
    $H_{f}\notin {\mathsf {TIME}}(f(\left\lfloor m/2\right\rfloor )).$

### Extensión

El lector se puede haber percatado de que la prueba es sencilla puesto que hemos elegido una simulación de una máquina de Turing sencilla, para lo cual podemos estar seguros de que
    $H_{f}\in {\mathsf {TIME}}(f(m)^{3}).$
Se ha mostrado que un modelo de simulación más eficiente existe el cual establece que
    $H_{f}\in {\mathsf {TIME}}(f(m)\log f(m))$
pero como ese modelo de simulación se ve bastante elaborado, no se incluye aquí.

## Teorema de la jerarquía temporal no determinista

Si g(n) es una función computable, y f(n+1) = o(g(n)), existe un problema de decisión el cual no puede ser solucionado en tiempo no determinista f(n) pero sí en tiempo no determinista g(n). En otras palabras, la clase de complejidad NTIME(f(n)) es un subconjunto estricto de NTIME(g(n)).

## Consecuencias

Los teoremas de jerarquía temporal garantizan que la versión determinista y la no determinista de la jerarquía exponencial son jerarquías genuinas: en otras palabras P ⊂ EXPTIME ⊂ 2-EXPTIME ⊂ ..., y NP ⊂ NEXPTIME ⊂ 2-EXPTIME ⊂ ... Por ejemplo, P ⊂ EXPTIME desde $P\subseteq DTIME(2^{n})\subsetneq DTIME(2^{2n})\subseteq EXPTIME$.
El teorema también garantiza que hay problemas en P que requieren exponentes arbitrariamente largos para ser resueltos; en otras palabras, P no converge a DTIME(n$^k$) para ninguna k constante. Por ejemplo, hay problemas solucionables en tiempo O(n$^{5000}$) pero no en O(n$^{4999}$). Este es un argumento contra la tesis de Cobham, la convención de que P es una clase práctica de algoritmos. Si esa convergencia ocurriese, podríamos deducir que P ≠ PSPACE, puesto que un teorema conocido establece que DTIME(f(n)) está estrictamente contenido en DSPACE(f(n)).
Sin embargo, los teoremas de jerarquía temporal no proporcionan medios para relacionar la complejidad determinista y la no determinista, y tampoco la complejidad espacial y temporal, por lo que no iluminan sobre las grandes cuestiones pendientes de la teoría de la complejidad computacional: Si P y NP, NP y PSPACE, PSPACE y EXPTIME, o EXPTIME y NEXPTIME son iguales o no.