Complexidade Computacional

A computação é uma tarefa que consome recursos. Os recursos que mais usualmente são considerados são o tempo (a duração da computação) e o espaço (uma medida da informação que é armazenada/consumida durante a computação), mas também é possível considerar outras quantidades, como a energia (necessária para executar a computação).
A complexidade computacional consiste no estudo dos recursos necessários para resolver um problema.

Podemos calcular a eficiência de uma máquina de Turing (que seja um classificador) relativamente ao tempo e ao espaço de forma relativamente simples, se tomarmos o número de passos de cada computação como uma medida do tempo, e o número de células de memória lidas/escritas ao longo de cada computação como uma medida de espaço.

Definição

Para uma máquina classificadora MM definimos as funções timeM,spaceM:NN\op{time}_M, \op{space}_M : \mathbb{N} \to \mathbb{N} da seguinte forma:

  • timeM(n)\op{time}_M(n) é o comprimento máximo - ou seja, o número de passos máximo - de uma computaçao de MM sobre um input ω\omega com ωn|\omega| \leq n;
  • spaceM(n)\op{space}_M(n) é o número máximo de células de memória lidas/escritas durante uma computação de MM sobre um input ω\omega com ωn|\omega| \leq n.

Para cada nNn \in \mathbb{N}, timeM(n)\op{time}_M(n) e spaceM(n)\op{space}_M(n) dão-nos uma avaliação do pior caso, em termos de duração da computação ou da quantidade de memória necessária, respetivamente, para processar inputs de tamanho limitado por nn.
Mais do que a expressão exacta das funções timeM\op{time}_M e spaceM\op{space}_M associadas a um classificadora MM, estamos interessados em avaliar o seu crescimento. Por essa razão é usual usar notação assintótica, nomeadamente a notação OO (como visto em cadeiras anteriores como IAED ou ASA).

Classes de Complexidade

Agrupamos problemas, de acordo com a sua dificuldade relativa, em classes de complexidade.

Definição

Seja f:NR0+f : \mathbb{N} \to \mathbb{R}_0^+ uma função. Definem-se as seguintes classes de linguagens:

  • TIME(f(n))={L: existe uma maˊquina M que decide L com timeM(n)=O(f(n))}\mathbf{TIME}(f(n)) = \{ L : \text{ existe uma máquina } M \text{ que decide } L \text{ com } \\ \op{time}_M(n) = O(f(n)) \};
  • SPACE(f(n))={L: existe uma maˊquina M que decide L com spaceM(n)=O(f(n))}\mathbf{SPACE}(f(n)) = \{ L : \text{ existe uma máquina } M \text{ que decide } L \text{ com } \\ \op{space}_M(n) = O(f(n)) \};

Em certas áreas de estudo, são consideradas como eficientes as máquinas cujo comportamento é limitado por um polinómio. Por outro lado, o protótipo das máquinas ineficientes é precisamente o crescimento exponencial. Estas considerações levam à definição das seguintes classes de complexidade:

Definição

Definem-se as seguintes classes de linguagens, em relação ao tempo:

  • P=kNTIME(nk)\mathbf{P} = \bigcup_{k \in \mathbb{N}} \mathbf{TIME}(n^k);
  • EXPTIME=kNTIME(2nk)\mathbf{EXPTIME} = \bigcup_{k \in \mathbb{N}} \mathbf{TIME}(2^{n^k}).

analogamente, para o espaço, definimos

  • PSPACE=kNSPACE(nk)\mathbf{PSPACE} = \bigcup_{k \in \mathbb{N}} \mathbf{SPACE}(n^k);
  • EXPSPACE=kNSPACE(2nk)\mathbf{EXPSPACE} = \bigcup_{k \in \mathbb{N}} \mathbf{SPACE}(2^{n^k}).

Relação entre função tempo e espaço

Para uma máquina classificadora MM, tem-se que timeM\op{time}_M e spaceM\op{space}_M são funções monótonas e, para qualquer, nNn \in \mathbb{N}:

  1. spaceM(n)timeM(n)\op{space}_M(n) \leq \op{time}_M(n)
  2. timeM(n)2O(spaceM(n))\op{time}_M(n) \leq 2^{O(\op{space}_M(n))}.
Prova

O facto de as funções timeM\op{time}_M e spaceM\op{space}_M serem monótonas segue da definição.

(1) A primeira propriedade vem apenas do facto de que, para escrever numa célula de memória de memória, é necessário deslocarmo-nos para essa célula. Desta forma, o número de passos de uma computação é pelo menos igual ao número de células escritas.

(2) Considere-se a computação da máquina de Turing MM com alfabeto de trabalho Γ\Gamma e conjunto de estados QQ, sobre um input de comprimento menor ou igual a nn.
Temos que MM é classificadora pelo que a sua computação termina sempre. Verificamos que a computação de MM não pode passar duas vezes pela mesma configuração: se isto acontecesse, a máquina entraria em ciclo infinito uma vez que todas as transições são deterministas. Sendo assim, o tempo que a máquina demora a fazer a sua computação está majorado pelo seu número de configurações.
Seja m=spaceM(n)m = space_M(n). Temos então que o número de configurações é definido por:

  • o conteúdo na fita, que é no máximo Γm|\Gamma|^m;
  • a posição da cabeça de leitura/escrita, que pode estar numa de mm posições;
  • o estado em que a computação se encontra, que é um de Q|Q|.

Desta forma, o número de estados é majorado por Γm×Q×m|\Gamma|^m \times |Q| \times m.
Então:

timeM(n)Γm×Q×m2mlog2(Γ)2log2(Q)2m=2m(log2(Γ)+1)+log2(Q)=2O(spaceM(n))\begin{align*} \op{time}_M(n) &\leq |\Gamma|^m \times |Q| \times m \leq 2^{m\log_2(|\Gamma|)} \cdot 2^{\log_2(|Q|)} \cdot 2^m \\ &= 2^{m(\log_2(|\Gamma|) + 1) + \log_2(|Q|)} = 2^{O(\op{space}_M(n))} \end{align*}

Corolário

PPSPACEEXPTIMEEXPSPACE\mathbf{P} \subset \mathbf{PSPACE} \subset \mathbf{EXPTIME} \subset \mathbf{EXPSPACE}

Variantes

Movimentos-SS

Proposição

Toda a máquina de Turing MM com transições-SS é equivalente a uma máquina de Turing TT sem transições-SS tal que timeT(n)=O(timeM(n))\op{time}_T(n) = O(\op{time}_M(n)) e spaceT(n)=O(spaceM(n))\op{space}_T(n) = O(\op{space}_M(n))

Prova

Na prova da equivalência, simulamos todos os movimentos-SS com um movimento à direita seguido de um movimento à esquerda. Temos então que cada movimento em MM corresponde no máximo a dois movimentos em TT pelo que

timeT(n)2timeM(n)=O(timeM(n))\op{time}_T(n) \leq 2 \op{time}_M(n) = O(\op{time}_M(n)) \\
spaceT(n)spaceM(n)+1=O(spaceM(n))\op{space}_T(n) \leq \op{space}_M(n) + 1 = O(\op{space}_M(n))

Bidirecional

Proposição

Toda a máquina bidirecional MM é equivalente a uma máquina unidirecional TT tal que timeT(n)=O(n+timeM(n)2)\op{time}_T(n) = O(n + \op{time}_M(n)^2) e spaceT(n)=O(spaceM(n))\op{space}_T(n) = O(\op{space}_M(n))

Prova

Vamos basear-nos na prova de equivalência apresentada no capítulo de Máquinas de Turing.
A computação de TT começa por balizar o input com os símbolos II e FF, fazendo 2n+32n + 3 passos.
O resto da computação é idêntica a MM, exceto nos casos em que é necessário introduzir espaçamento. Para introduzir espaço à direita precisamos apenas de 3 movimentos, enquanto que à esquerda precisamos de copiar a palavra toda, o que implica O(spaceM(n))O(\op{space}_M(n)) passos.
No final há que apagar o delimitador FF, o que demora O(spaceM(n))O(\op{space}_M(n)). Na pior das hipóteses, temos que é preciso abrir espaço à esquerda em cada passo, pelo que:

timeT(n)(2n+3)+timeM(n)O(spaceM(n))+O(spaceM(n))O(n)+timeM(n)O(timeM(n))+O(timeM(n))=O(n+timeM(n)2+timeM(n))=O(n+timeM(n)2)\begin{align*} \op{time}_T(n) &\leq (2n+3) + \op{time}_M(n) \cdot O(\op{space}_M(n)) + O(\op{space}_M(n)) \\ &\leq O(n) + \op{time}_M(n) \cdot O(\op{time}_M(n)) + O(\op{time}_M(n)) \\ &= O(n + \op{time}_M(n)^2 + \op{time}_M(n)) \\ &= O(n + \op{time}_M(n)^2) \end{align*}

Quando ao espaço, TT usa apenas mais duas células, as que usa para delimitar a palavra. Então:

spaceT(n)2+spaceM(n)=O(spaceM(n))\op{space}_T(n) \leq 2 + \op{space}_M(n) = O(\op{space}_M(n))

Multifita

Proposição

Toda a máquina de Turing multifita MM é equivalente a uma máquina com apenas uma fita TT tal que timeT(n)=O(n+timeM(n)2)\op{time}_T(n) = O(n + \op{time}_M(n)^2) e spaceT(n)=O(spaceM(n))\op{space}_T(n) = O(\op{space}_M(n))

Prova

Atente-se na máquina TT construída a partir de MM tal como no capítulo de Máquinas de Turing.
A computação de TT começa por inicializar a fita de memória, balizando o input com os símbolos II e FF, e demarcando o espaço de cada uma das kk fitas da máquina TT, num número de passos da ordem de O(n+k)O(n + k), onde nn é o tamanho do input e kk o número de fitas.
De seguida simula cada uma das transições de MM, percorrendo a fita da esquerda para a direita de forma a ler os símbolos marcados, e depois da direita para a esquerda atualizando as marcações, visitando um número de células da ordem de O(spaceM(n))O(\op{space}_M(n)). Pode ter de efetuar um máximo de kk espaçamentos, 1 em cada fita, visitando assim um número máximo de células da ordem de kO(spaceM(n))k \cdot O(\op{space}_M(n)).
Finalmente, após a aceitação por MM, os símbolos marcados são adequadamente substituídos, e o símbolo FF é removido, o que de novo implica que um número de células da ordem de O(spaceM(n))O(\op{space}_M(n)) seja visitado.
Assim, temos:

timeT(n)O(n+k)+timeM(n)(O(spaceM(n))+kO(spaceM(n)))+O(spaceM(n))O(n)+timeM(n)O(timeM(n))+O(timeM(n))=O(n+timeM(n)2)\begin{align*} \op{time}_T(n) &\leq O(n+k) + \op{time}_M(n) \cdot \left( O(\op{space}_M(n)) + k O(\op{space}_M(n)) \right) \\ &\quad + O(\op{space}_M(n)) \\ &\leq O(n) + \op{time}_M(n) \cdot O(\op{time}_M(n)) + O(\op{time}_M(n)) \\ &= O(n + \op{time}_M(n)^2) \end{align*}

Quanto ao espaço, a máquina TT usa exatamente k+1k+1 células de memória adicionais, pelo que:

spaceT(n)=k+1+spaceM(n)=O(spaceM(n))\op{space}_T(n) = k+1+\op{space}_M(n) = O(\op{space}_M(n))

Não-Determinismo

No caso das máquinas não-deterministas vai surgir a primeira diferença substancial relativamente à teoria da computabilidade.

Definição

Seja MM uma máquina não-determinista classificadora. Definem-se as funções ntimeM,nspaceM:NN\op{ntime}_M, \op{nspace}_M: \mathbb{N} \to \mathbb{N} da seguinte forma:

  • ntimeM(n)\op{ntime}_M(n) é o comprimento do maior ramo de computação de MM sobre um input ω\omega com ωn| \omega | \leq n;
  • nspaceM(n)\op{nspace}_M(n) é o número máximo de células de memória lidas/escritas durante algum dos ramos de computação de MM sobre um input ω\omega com ωn| \omega | \leq n.

Tal como para as máquinas deterministas, definimos as classes de tempo e espaço não-deterministas:

Definição

Seja f:NR0+f : \mathbb{N} \to \mathbb{R}_0^+ uma função. Definem-se as seguintes classes de linguagens:

  • NTIME(f(n))={L: existe uma maˊquina na˜o-determinista M que decide L com ntimeM(n)=O(f(n))}\mathbf{NTIME}(f(n)) = \{ L : \text{ existe uma máquina não-determinista } \\ M \text{ que decide } L \text{ com } \op{ntime}_M(n) = O(f(n)) \};
  • NSPACE(f(n))={L: existe uma maˊquina na˜o-determinista M que decide L com nspaceM(n)=O(f(n))}\mathbf{NSPACE}(f(n)) = \{ L : \text{ existe uma máquina não-determinista } \\ M \text{ que decide } L \text{ com } \op{nspace}_M(n) = O(f(n)) \};

Definição

Definem-se as seguintes classes de linguagens, em relação ao tempo:

  • NP=kNNTIME(nk)\mathbf{NP} = \bigcup_{k \in \mathbb{N}} \mathbf{NTIME}(n^k);
  • NEXPTIME=kNNTIME(2nk)\mathbf{NEXPTIME} = \bigcup_{k \in \mathbb{N}} \mathbf{NTIME}(2^{n^k}).

analogamente, para o espaço, definimos

  • NPSPACE=kNNSPACE(nk)\mathbf{NPSPACE} = \bigcup_{k \in \mathbb{N}} \mathbf{NSPACE}(n^k);
  • NEXPSPACE=kNNSPACE(2nk)\mathbf{NEXPSPACE} = \bigcup_{k \in \mathbb{N}} \mathbf{NSPACE}(2^{n^k}).

Uma vez que máquinas deterministas são casos particulares de máquinas não-deterministas, temos que:

Proposição

PNPPSPACENPSPACEEXPTIMENEXPTIMEEXPSPACENEXPSPACE\begin{matrix} \mathbf{P} \subset \mathbf{NP} & \mathbf{PSPACE} \subset \mathbf{NPSPACE} \\ \mathbf{EXPTIME} \subset \mathbf{NEXPTIME} & \mathbf{EXPSPACE} \subset \mathbf{NEXPSPACE} \end{matrix}

A seguinte proposição também transita para máquinas não deterministas:

Proposição

Para uma máquina não-determinista classificadora MM, tem-se que ntimeM\op{ntime}_M e nspaceM\op{nspace}_M são funções monótonas e, para qualquer, nNn \in \mathbb{N}:

  1. nspaceM(N)ntimeM(n)\op{nspace}_M(N) \leq \op{ntime}_M(n)
  2. ntimeM(n)2O(nspaceM(n))\op{ntime}_M(n) \leq 2^{O(\op{nspace}_M(n))}.
Prova

Idêntica à para máquinas deterministas, quando considerado um ramo específico da computação não determinista.

e consequentemente

Corolário

NPNPSPACENEXPTIMENEXPSPACE\mathbf{NP} \subset \mathbf{NPSPACE} \subset \mathbf{NEXPTIME} \subset \mathbf{NEXPSPACE}

Finalmente, é importante estabelecer a relação entre a eficiência de máquinas deterministas com máquinas não-deterministas.

Proposição

Toda a máquina de Turing não-determinista NN é equivalente a uma máquina de Turing determinista TT tal que timeT(n)=O(n+ntimeN(n))2O(ntimeN(n))\op{time}_T(n) = O(n + \op{ntime}_N(n)) \cdot 2^{O(\op{ntime}_N(n))} e spaceT(n)=O(n+ntimeN(n))\op{space}_T(n) = O(n + \op{ntime}_N(n))

Prova

Vamos considerar a máquina TT construída a partir de NN como no capítulo de Máquinas de Turing.
A computação de TT começa por inicializar 3 fitas de memória, a segunda das quais com o comprimento máximo das computações possíveis, que pode ser calculado num número de passos da ordem de O(ntimeN(n))O(\op{ntime}_N(n)). De seguida, copia o input da primeira para a terceira fita, balizando-o com os símbolos II e FF, e executando um número de passos da ordem de O(n)O(n). Na terceira fita é então simulado o caminho de computação de NN descrito na fita 2, num número de passos inferior ou igual a ntimeN(n)\op{ntime}_N(n), após o que volta a limpar a fita 3, visitando um número de células da ordem de O(spaceN(n))O(\op{space}_N(n)).
Em caso de aceitação por NN, há ainda que, na terceira fita, remover o símbolo FF e colocar a cabeça de leitura/escrita no início da palavra, visitando um número de células da ordem de O(nspaceN(n))O(\op{nspace}_N(n)).
Se bb for o número máximo de escolhas não-deterministas na máquina NN, temos assim:

timeT(n)O(ntimeN(n))+bntimeN(n)(O(n)+ntimeN(n)+O(nspaceN(n)))+O(nspaceN(n))O(ntimeN(n))+bntimeN(n)(O(n)+O(ntimeN(n)))=O(n+ntimeN(n))2O(ntimeN(n))\begin{align*} \op{time}_T(n) &\leq O(\op{ntime}_N(n)) + b^{\op{ntime}_N(n)} \left( O(n) + \op{ntime}_N(n) + O(\op{nspace}_N(n)) \right) \\ & \quad + O(\op{nspace}_N(n)) \\ &\leq O(\op{ntime}_N(n)) + b^{\op{ntime}_N(n)} \left( O(n) + O(\op{ntime}_N(n)) \right) \\ &= O(n + \op{ntime}_N(n)) \cdot 2^{O(\op{ntime}_N(n))} \end{align*}

Quanto ao espaço, como vimos na secção de máquinas multifita, temos que o espaço numa máquina multifita tem a mesma complexidade que a máquina de Turing com uma fita correspondente, pelo que:

spaceT(n)O(n)+O(ntimeN(n))+O(nspaceN(n))O(n)+O(ntimeN(n))+O(ntimeN(n))=O(n+ntimeN(n))\begin{align*} \op{space}_T(n) &\leq O(n) + O(\op{ntime}_N(n)) + O(\op{nspace}_N(n)) \\ &\leq O(n) + O(\op{ntime}_N(n)) + O(\op{ntime}_N(n)) \\ &= O(n + \op{ntime}_N(n)) \end{align*}

Note-se que isto implica que a existência de uma máquina não-determinista de tempo polinomial para resolver um problema parece não nos poder garantir mais do que uma máquina determinista de tempo exponencial para resolver o mesmo problema.
O problema P vs NP\mathbf{P} \text{ vs } \mathbf{NP} pode ser compreendido como perguntando se é possível fazer esta simulação de forma mais eficiente (polinomial).

Propriedades de Fecho e Redução Polinomial

Proposição

Seja C\mathcal{C} uma das classes de complexidade P\mathbf{P}, NP\mathbf{NP}, PSPACE\mathbf{PSPACE}, NPSPACE\mathbf{NPSPACE}, EXPTIME\mathbf{EXPTIME}, NEXPTIME\mathbf{NEXPTIME}, EXPSPACE\mathbf{EXPSPACE}, NEXPSPACE\mathbf{NEXPSPACE}, e sejam Σ\Sigma um alfabeto, e L1,L2CL_1, L_2 \in \mathcal{C} linguagens sobre Σ\Sigma.
Então:

  • C\emptyset \in \mathcal{C}
  • ΣC\Sigma^* \in \mathcal{C}
  • L1L2CL_1 \cup L_2 \in \mathcal{C}
  • L1L2CL_1 \cap L_2 \in \mathcal{C}

Se CNP\mathcal{C} \neq \mathbf{NP} e CNEXPTIME\mathcal{C} \neq \mathbf{NEXPTIME}, então temos também que:

  • L1L2CL_1 \setminus L_2 \in \mathcal{C}
Prova

É evidente que \emptyset e Σ\Sigma^* podem ser decididas em O(1)O(1), pelo que estão contidas nas classes enumeradas.

Quanto as proposições 3 e 4, usamos as máquinas MM como definidas nas prova que L1L2L_1 \cap L_2 e L1L2L_1 \cup L_2 são decidíveis, para L1L_1 e L2L_2 decidíveis.
Usamos o caso da disjunção como exemplo, mas a conjunção é análoga. Se M1M_1 é computada em O(f(x))O(f(x)) e M2M_2 é computada em O(g(x))O(g(x)), então a máquina MM que decide L1L2L_1 \cup L_2 computa em O(f(x)+g(x))O(f(x) + g(x)), o que é suficiente para provar ambas proposições (não em teste!).

A quinta proposição fica como exercício (agradecem-se contribuições).

Stephen Cook e Leonid Levin mostraram que existem algumas linguagens em NP\mathbf{NP} às quais todas as outras linguagens dessa classe se reduzem. Mais ainda, mostraram que essa redução pode ser feita em tempo polinomial de forma que se se encontrar uma solução eficiente para um desses problemas, também se consegue decidir eficientemente qualquer outro problema de NP\mathbf{NP}. Vamos então começar por definir o que é uma redução polinomial de uma linguagem a outra:

Definição

Dadas linguagens sobre L1L_1 e L2L_2 sobre alfabetos Σ1\Sigma_1 e Σ2\Sigma_2, respetivamente, dizemos que há uma redução polinomial de L1L_1 para L2L_2 ou que L1L_1 reduz polinomialmente a L2L_2, o que denotamos por L1PL2L_1 \leq_P L_2 se existe uma função total f:Σ1Σ2f : \Sigma_1^* \to \Sigma_2^*, calculada por uma máquina determinista em tempo polinomial tal que, para cada ωΣ1\omega \in \Sigma_1^*

ωL1f(ω)L2\omega \in L_1 \Leftrightarrow f(\omega) \in L_2

Obviamente, se L1PL2L_1 \leq_P L_2, então L1L2L_1 \leq L_2.

Proposição

Sejam L1L_1 e L2L_2 linguagens sobre alfabetos Σ1\Sigma_1 e Σ2\Sigma_2, respetivamente. Seja C\mathcal{C} uma das classes de complexidade P\mathbf{P}, NP\mathbf{NP}, PSPACE\mathbf{PSPACE}, NPSPACE\mathbf{NPSPACE}, EXPTIME\mathbf{EXPTIME}, NEXPTIME\mathbf{NEXPTIME}, EXPSPACE\mathbf{EXPSPACE}, NEXPSPACE\mathbf{NEXPSPACE}. Se L1PL2L_1 \leq_P L_2 e L2CL_2 \in \mathcal{C}, então L1CL_1 \in \mathcal{C}.

Prova

As demonstrações são semelhantes para todas as classes. Ilustra-se a demonstração para a classe NP\mathbf{NP}.
Assuma-se então que L1PL2L_1 \leq_P L_2 e L2NPL_2 \in \mathbf{NP}. Seja NN uma máquina de Turing não-determinista que decide L2L_2 e k1k \geq 1 tal que ntimeN(n)=O(nk)\op{ntime}_N(n) = O(n^k). Seja MM uma máquina de Turing que calcula ff e l1l \geq 1 tal que timeM(n)=O(nl)\op{time}_M(n) = O(n^l).
Consideremos a máquina de Turing TT que ao receber um input ω\omega, calcula f(ω)f(\omega) em MM e usa o resultado dessa computação em NN, retornando no final o mesmo que NN. Ora, TT aceita então uma palavra ω\omega se e só se NN aceitar f(ω)f(\omega). Ora, temos que NN aceita f(ω)f(\omega) se e só se f(ω)L2f(\omega) \in L_2. Por definição de redução polinomial, isto acontece se e só se ωL1\omega \in L_1. Conclui-se então que TT decide L1L_1 (pois termina sempre, uma vez que tanto NN como MM terminam sempre).
Basta-nos então provar que ntimeT(n)O(nt)\op{ntime}_T(n) \in O(n^t) para algum xNx \in \mathbb{N}. Ora:

ntimeT(n)=timeM(n)+ntimeN(f(x))timeM(n)+ntimeN(spaceM(x))timeM(n)+ntimeN(x+timeM(x))timeM(n)+ntimeN(n+timeM(n))=O(nl)+O((n+O(nl))k)=O(nlk)\begin{align*} \op{ntime}_T(n) &= \op{time}_M(n) + \op{ntime}_N(|f(x)|) \\ &\leq \op{time}_M(n) + \op{ntime}_N(\op{space}_M(x)) \\ &\leq \op{time}_M(n) + \op{ntime}_N(|x| + \op{time}_M(|x|)) \\ &\leq \op{time}_M(n) + \op{ntime}_N(n + \op{time}_M(n)) \\ &= O(n^l) + O((n + O(n^l))^k) \\ &= O(n^{lk}) \end{align*}

Conclui-se então que L1NPL_1 \in \mathbf{NP}.

Teorema de Savitch

Teorema de Savitch

Seja f:NR+f : \mathbb{N} \to \mathbb{R}^+ tal que f(n)nf(n) \geq n. Então

NSPACE(f(n))SPACE(f(n)2)\mathbf{NSPACE}(f(n)) \subset \mathbf{SPACE}(f(n)^2)

Corolário

PSPACE=NPSPACE\mathbf{PSPACE} = \mathbf{NPSPACE} e EXPSPACE=NEXPSPACE\mathbf{EXPSPACE} = \mathbf{NEXPSPACE}