Perché P = NP non implica P = AP (cioè P = PSPACE)?

È noto che se allora la gerarchia polinomiale collassa e .P = P $\mathbf{P}=\mathbf{NP}$$\mathbf{P}=\mathbf{PH}$

Questo può essere facilmente compreso induttivamente usando macchine oracolari. La domanda è: perché non possiamo continuare il processo induttivo oltre un livello costante di alternanze e dimostrare (aka )?A P = P S P A C $\mathbf{P}=\mathbf{AltTime}(n^{O(1)})$$\mathbf{AP}=\mathbf{PSPACE}$

Sto cercando una risposta intuitiva.

La prova per $\mathbf{P}=\mathbf{AltTime}(O(1))$ ( $=\mathbf{PH}$ ) è un'induzione con $\mathbf{P}=\mathbf{NP}$ . L'induzione mostra che per qualsiasi numero naturale $k$ , $\mathbf{P}=\mathbf{AltTime}(k)$ (e $\mathbf{AltTime}(O(1))$ è solo la loro unione).

L'induzione non funziona quando il numero di alternanza può variare con la dimensione di input (cioè quando il numero di possibili alternanze della macchina non è un numero ma una funzione della dimensione di input, cioè non stiamo dimostrando che un'esecuzione della macchina su un singolo input può essere ridotto a nessuna alternanza, stiamo dimostrando che le esecuzioni della macchina su tutti gli input possono essere "uniformemente" ridotte a nessuna alternanza).

Diamo un'occhiata a un'affermazione simile ma più semplice. Vogliamo dimostrare che la funzione identità alla fine domina tutte le funzioni costanti ( f ≪ g iff per tutti ma finitamente molte n f ( n ) ≤ g ( n ) ). Si può dimostrare per induzione. Per tutti k , k ≪ n (cioè f k ≪ i d dove 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$

Confronta la gerarchia polinomiale con la gerarchia per prove interattive. Se per alcune k fisse , hai k alternanze in una prova interattiva - IP ( k ) - la classe di complessità risultante non ha più potenza di quella che ottieni con due alternanze - cioè IP ( k ) = IP (2 ) = AM (assumendo k ≥2). Tuttavia, se si consente un numero polinomiale di alternanze, si ottiene la classe di complessità IP = PSPACE, che si ritiene sia molto più grande di AM, una classe è contenuta in Π ₂ P, al secondo livello della gerarchia polinomiale. Quindi questo fenomeno si verifica effettivamente (sebbene, per quanto non sappiamo, con la gerarchia polinomiale).

Ciò accade perché la riduzione che prende un problema di dimensione n in IP ( k ) e lo trasforma in un problema in IP (2) fa esplodere la dimensione del problema, in modo che mentre per qualsiasi IP specifico ( k ) il problema rimanga polinomiale , se lasci che k cambi, la riduzione risultante non dà problemi polinomiali in k .

Ecco una piccola intuizione riguardo al divario tra alternanze costanti e illimitate: un'operazione polinomiale ripetuta un numero costante di volte è polinomiale, ma ripetere un numero polinomiale di volte può essere esponenziale. Ad esempio, prendi la moltiplicazione ripetuta su se stessa:

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

Il numero di iterazioni è lineare e l'output è esponenziale. Ma se si corregge n, è polinomiale sulla dimensione del valore iniziale.

Di seguito espongo un po 'il punto nella risposta di Peter, cercando di eseguire la rimozione del quantificatore per più di un numero costante di passaggi per vedere dove fallisce e se qualcosa può essere salvato da un simile tentativo.

Proviamo ad amplificare $\mathsf{P}=\mathsf{NP}$ per più di un numero costante di volte.

Si supponga che $\mathsf{P}=\mathsf{NP}$ . Pertanto esiste una macchina del tempo polinomiale che risolve Ext-Circuit-SAT (esiste un'estensione soddisfacente per un dato circuito e un'assegnazione parziale ai suoi ingressi?).

Più formalmente, abbiamo un algoritmo polytime $A$ con tempo di esecuzione polinomiale $p(n)\in\rm{poly}(n)$ st

Dato un circuito booleano $\varphi$ e un'assegnazione parziale $\tau$ agli ingressi,
$A$ restituisce "sì" se esiste un'estensione di $\tau$ che soddisfa $\varphi$ e restituisce "no" in caso contrario.

Per superare tempi costanti, è necessario eseguire la rimozione del quantificatore in modo efficace. Possiamo farlo perché la Cook-Levin teorema è un teorema costruttiva, infatti dà un polinomio tempo algoritmo di $Cook$ st

Dato un DTM $M$ riceve due ingressi, e tre numeri unari $n$ , $m$ , e $t$ ,
$Cook(M, n, m, t)$ restituisce un circuito booleano di dimensione $O(t^2)$ che simula $M$ su input di largo $(n,m)$ per $t$ passi.

Proviamo a usarli per estendere l'argomento di $\mathsf{P}=\mathsf{PH}$ per ottenere un algoritmo che risolve TQBF (in realtà TQBCircuit, ovvero il problema del circuito booleano totalmente quantificato).

L'idea dell'algoritmo è il seguente: useremo ripetutamente $Cook$ su $A$ per rimuovere le occorrenze di un dato circuito quantificato. Ci sono certo numero lineare di occorrenze quindi speriamo di ottenere un algoritmo di tempo polinomiale (abbiamo un algoritmo con polinomialmente molti passaggi utilizzando il polinomio tempo subroutine $Cook$ ). Alla fine di questo processo di eliminazione del quantificatore avremo un circuito privo di quantificatore che può essere valutato in tempo polinomiale (il problema del valore del circuito è in $\mathsf{P}$ , lascia che $CV$ sia un algoritmo del tempo polinomiale per calcolare il valore del circuito di un dato circuito) .

Tuttavia vedremo che questa idea non funziona (per lo stesso motivo indicato da Peter).

• Sia $\varphi$ un circuito quantificato (inizializzato con la formula quantificata fornita).
• Sia $k$ il numero di quantificatori in $\varphi$ .

• Per $i$ da $k$ a $1$ do

  • Lasciare $\psi$ = $Qx_k \sigma(x_1,...,x_k)$ l'ultimo quantificatore e la parte libera-quantificatore.

  • Se , $Q = "\exists"$

    1. Calcola , $C = Cook(A, |\sigma|, |x_1|+...+|x_k-1|, p)$
    2. Sostituire i bit di ingresso con nel circuito , $\sigma$$C$
    3. Sostituisci con in . $\psi$$C$$\varphi$

  • Se , $Q = "\forall"$

    1. Considera come , $\psi$$\lnot \exists x_k \lnot \sigma$
    2. Calcola , $C = Cook(A, |\lnot \sigma|, |x_1|+...+|x_k-1|, p)$
    3. Sostituire i bit di ingresso con nel circuito , $\lnot \sigma$$C$
    4. Sostituisci con in .$\psi$$\lnot C$$\varphi$
• Calcola e ritorna $CV(\varphi)$ .

L'algoritmo risultante sembra tempo polinomiale: abbiamo molti passaggi polinomiali, ogni passo è calcolabile nel tempo polinomiale. Tuttavia, ciò non è corretto, l'algoritmo non è il tempo polinomiale.

L'uso delle subroutine di tempo polinomiale in un algoritmo di tempo polinomiale è tempo polinomiale. Il problema è che in generale questo non deve essere vero se i valori restituiti dalle subroutine non hanno dimensioni polinomiali nell'input originale e supponiamo che eseguiamo assegnazioni sui valori restituiti dalle subroutine. (Nel modello TM dobbiamo leggere l'uscita di ogni bit tempo subroutine polinomiale per bit.) Qui la dimensione del valore restituito da algoritmo $Cook$ sta aumentando (può essere una potenza della dimensione della sollecitazione che gli , la potenza esatta dipende dal tempo di esecuzione di $A$ ed è intorno a $p^2(|input|)$, quindi poiché sappiamo che $A$ non può essere inferiore al tempo lineare, $|output|$è almeno $|input|^2$ ).

Il problema è simile al semplice codice seguente:

• Dato $x$ ,
• Sia $n = |x|$,
• Lascia $y = x$ ,
• Per $i$ da $1$ a $n$ fare
  • Lascia $y = y^{|y|}$, (ovvero concatenazione di $|y|$ copie di $y$ )
• Ritorna y

Ogni volta che eseguiamo $y = y^{|y|}$quadriamo la dimensione di $y$ . Dopo $n$ esecuzioni avremo una $y$ che è $x^{2^n}$ e ha dimensione $n2^n$ , ovviamente non un polinomio nella dimensione dell'input.

Supponiamo che prendiamo in considerazione solo le formule quantificate con alternanze di quantificatori $k(n)$ (dove $n$ è la dimensione totale della formula quantificata).

Supporre che $A$ viene eseguita in tempo $p$ (es lineare di tempo che non è esclusa finora), e hanno forse un più efficiente $Cook$ algoritmo uscita un piccolo circuito di dimensioni $l(t)$ al posto del $t^2$ , otteniamo un algoritmo per ExtCircuitSat che viene eseguito nel tempo $(l\circ p)^{O(k)}(n)=\underbrace{l(p(l(p(\dots(l(p(n)))))))}_{O(k)\mbox{ compositions}}$ . Anche nel caso in cui sia$l$e$p$è lineare (ma con coefficiente totale$a\geq 2$) si otterrebbe un algoritmo che esegue in un tempo$\Omega(n2^{k(n)})$e se$k(n) = \Theta(n)$it sarebbe$\Omega(n2^n)$ simile all'algoritmo a forza bruta (e anche questo si basava sull'ipotesi che Cook-Levin potesse essere eseguito su algoritmi risultanti circuiti di dimensione lineare nel tempo di esecuzione dell'algoritmo).

Penso che ciò sia dovuto al fatto che ad ogni livello del PH, il numero di alternanze è una costante (cioè indipendente dalla dimensione dell'input), mentre in AP il numero di alternanze può essere illimitato (eppure polinomiale nella dimensione dell'input).