Por que P = NP não implica P = AP (ou seja, P = PSPACE)?

É sabido que se , a hierarquia polinomial entra em colapso e .$\mathbf{P}=\mathbf{NP}$$\mathbf{P}=\mathbf{PH}$

Isso pode ser facilmente entendido por indução usando máquinas oracle. A questão é: por que não podemos continuar o processo indutivo além de um nível constante de alternância e provar (também conhecido como )?$\mathbf{P}=\mathbf{AltTime}(n^{O(1)})$$\mathbf{AP}=\mathbf{PSPACE}$

Estou procurando uma resposta intuitiva.

A prova para $\mathbf{P}=\mathbf{AltTime}(O(1))$ ( $=\mathbf{PH}$ ) é uma indução utilizando $\mathbf{P}=\mathbf{NP}$ . A indução mostra que, para qualquer número natural $k$ , $\mathbf{P}=\mathbf{AltTime}(k)$ (e $\mathbf{AltTime}(O(1))$ é apenas a união deles).

A indução não funciona quando o número de alternância pode mudar com o tamanho da entrada (ou seja, quando o número de alternâncias possíveis da máquina não é um número, mas uma função do tamanho da entrada, ou seja, não estamos mostrando que uma execução da máquina em uma única entrada pode ser reduzida a nenhuma alternância, estamos mostrando que as execuções da máquina em todas as entradas podem ser "uniformemente" reduzidas a nenhuma alternância).

Vejamos uma afirmação semelhante, mas mais simples. Queremos mostrar que a função de identidade acaba dominando todas as funções constantes ( f ≪ g se, para todos, mas finitamente muitas n f ( n ) ≤ g ( n ) ). Pode ser provado dizer por indução. Para todos k , k ≪ n (isto é, f k ≪ i d onde f k ( n ) = $id(n)=n$$f \ll g$$n$ $f(n) \leq g(n)$$k$$k \ll n$$f_k \ll id$$f_k(n)=k$$n^2$$n^2 \not \ll n$

Compare a hierarquia polinomial com a hierarquia para provas interativas. Se, para alguns k fixos , você tiver k alternações em uma prova interativa - IP ( k ) - a classe de complexidade resultante não tem mais poder do que o que você obtém com duas alternações - ou seja, IP ( k ) = IP (2) ) = AM (assumindo k ≥2). No entanto, se você permitir um número polinomial de alternâncias, obterá a classe de complexidade IP = PSPACE, que se acredita ser muito maior que a AM, uma classe estará contida em Π ₂ P, no segundo nível da hierarquia polinomial. Portanto, esse fenômeno realmente acontece (embora, até onde sabemos, com a hierarquia polinomial).

Isso acontece porque a redução que pega um problema de tamanho n no IP ( k ) e o transforma em um problema no IP (2) aumenta o tamanho do problema, de modo que, para qualquer IP específico ( k ), o problema permanece com tamanho polinomial , se você deixar k variar, a redução resultante não causará problemas polinomiais em k .

Aqui está uma pequena intuição sobre o intervalo entre alternâncias constantes e ilimitadas: uma operação polinomial repetida um número constante de vezes é polinomial, mas repetida um número polinomial de vezes pode ser exponencial. Por exemplo, considere a multiplicação repetida em si mesma:

v = 2
for(i=1 to n)
  v = v*v

O número de iterações é linear e a saída é exponencial. Mas se você corrigir n, é polinomial no tamanho do valor inicial.

Abaixo, expanda um pouco o ponto na resposta de Peter, tentando realizar a remoção do quantificador por mais do que um número constante de etapas para ver onde ele falha e se alguma coisa pode ser recuperada dessa tentativa.

Vamos tentar amplificar $\mathsf{P}=\mathsf{NP}$ por mais do que um número constante de vezes.

Assume-se que $\mathsf{P}=\mathsf{NP}$ . Portanto, existe uma máquina do tempo polinomial que resolve o Ext-Circuit-SAT (existe uma extensão satisfatória para um determinado circuito e uma atribuição parcial às suas entradas?).

Mais formalmente, temos um algoritmo polytime $A$ com tempo de execução polinomial $p(n)\in\rm{poly}(n)$ st

Dado um circuito booleano $\varphi$ e uma atribuição parcial $\tau$ às entradas,
$A$ retorna "yes" se houver uma extensão de $\tau$ que satisfaça $\varphi$ e retorne "no" caso contrário.

Para passar por tempos constantes, precisamos fazer a remoção do quantificador de forma eficaz. Nós podemos fazer isso porque o Cook-Levin teorema é um teorema construtiva, na verdade, dá um polinômio tempo algoritmo $Cook$ st

Dado um DTM $M$ receber duas entradas e três números unárias $n$ , $m$ e $t$ ,
$Cook(M, n, m, t)$ retorna um circuito booleano de tamanho $O(t^2)$ que simula $M$ em entradas de comprimento $(n,m)$ para $t$ etapas.

$\mathsf{P}=\mathsf{PH}$

$Cook$$A$$Cook$$\mathsf{P}$$CV$

No entanto, veremos que essa ideia não funciona (pela mesma razão apontada por Peter).

• $\varphi$
• $k$$\varphi$

• $i$$k$$1$

  • $\psi$$Qx_k \sigma(x_1,...,x_k)$

  • Se , $Q = "\exists"$

    1. Calcular , $C = Cook(A, |\sigma|, |x_1|+...+|x_k-1|, p)$
    2. Substitua os bits de entrada por no circuito , $\sigma$$C$
    3. Substitua por em . $\psi$$C$$\varphi$

  • Se , $Q = "\forall"$

    1. Considere como , $\psi$$\lnot \exists x_k \lnot \sigma$
    2. Calcular , $C = Cook(A, |\lnot \sigma|, |x_1|+...+|x_k-1|, p)$
    3. Substitua os bits de entrada por no circuito , $\lnot \sigma$$C$
    4. Substitua pelo em .$\psi$$\lnot C$$\varphi$
• Calcule e retorne .$CV(\varphi)$

O algoritmo resultante parece com tempo polinomial: temos muitas etapas polinomiais, cada etapa é computável em tempo polinomial. No entanto, isso não está correto, o algoritmo não é de tempo polinomial.

O uso de sub-rotinas de tempo polinomial em um algoritmo de tempo polinomial é tempo polinomial. O problema é que, em geral, isso não precisa ser verdadeiro se os valores retornados pelas sub-rotinas não tiverem tamanho polinomial na entrada original e assumimos que fazemos atribuições sobre os valores retornados pelas sub-rotinas. (No modelo da TM, precisamos ler a saída de qualquer sub-rotina de tempo polinomial pouco a pouco.) Aqui o tamanho do valor retornado do algoritmo está aumentando (pode ser uma potência do tamanho da entrada fornecida, o valor exato a potência depende do tempo de execução de e é em torno de , portanto, como sabemos que não pode ser menor que o tempo linear, é pelo menos$Cook$$A$$p^2(|input|)$$A$$|output|$$|input|^2$)

O problema é semelhante ao código simples abaixo:

• Dado ,$x$
• $n = |x|$
• $y = x$
• $i$$1$$n$
  • $y = y^{|y|}$$|y|$$y$
• Retorno y

$y = y^{|y|}$$y$$n$$y$$x^{2^n}$$n2^n$

$k(n)$$n$

$A$$p$$Cook$$l(t)$$t^2$$(l\circ p)^{O(k)}(n)=\underbrace{l(p(l(p(\dots(l(p(n)))))))}_{O(k)\mbox{ compositions}}$$l$$p$$a\geq 2$$\Omega(n2^{k(n)})$$k(n) = \Theta(n)$$\Omega(n2^n)$ semelhante ao algoritmo de força bruta (e mesmo isso foi baseado no pressuposto de que Cook-Levin pode ser executado em algoritmos resultantes de circuitos de tamanho linear no tempo de execução do algoritmo).

Eu acho que isso ocorre porque em cada nível do PH, o número de alternâncias é uma constante (ou seja, independente do tamanho da entrada), enquanto no AP, o número de alternações pode ser ilimitado (ainda que polinomial no tamanho da entrada).