Warum impliziert P = NP nicht P = AP (dh P = PSPACE)?

Es ist gut bekannt , dass , wenn $\mathbf{P}=\mathbf{NP}$ dann das Polynom Hierarchie kollabiert und $\mathbf{P}=\mathbf{PH}$ .

Dies kann mit Orakelmaschinen leicht induktiv verstanden werden. Die Frage ist - warum können wir nicht den induktiven Prozess über einen konstanten Wert von Abwechslungen fortsetzen und beweisen , $\mathbf{P}=\mathbf{AltTime}(n^{O(1)})$ (auch bekannt als $\mathbf{AP}=\mathbf{PSPACE}$ )?

Ich suche eine intuitive Antwort.

Der Beweis für ( = P H ) ist eine Induktion P = N P . Die Induktions zeigen , dass für jede natürliche Zahl k , P = A l t T i m e ( k ) (und A l t T i m e ( O $\mathbf{P}=\mathbf{AltTime}(O(1))$$=\mathbf{PH}$$\mathbf{P}=\mathbf{NP}$ $k$$\mathbf{P}=\mathbf{AltTime}(k)$$\mathbf{AltTime}(O(1))$ ist nur ihre Vereinigung).

Die Induktion funktioniert nicht, wenn sich die Anzahl der Wechsel mit der Eingangsgröße ändern kann (dh wenn die Anzahl der möglichen Wechsel der Maschine nicht a ist Zahl, sondern eine Funktion ist) der Eingabegröße ist, dh wir zeigen nicht, dass eine Ausführung der Maschine erfolgt Wir zeigen, dass die Ausführung der Maschine an allen Eingängen "gleichmäßig" auf "keine Änderung" reduziert werden kann.

Schauen wir uns eine ähnliche, aber einfachere Aussage an. Wir wollen zeigen, dass die Identitätsfunktion letztendlich alle konstanten Funktionen dominiert ( f ≪ g iff für alle bis auf endlich viele n f ( n ) ≤ g ( n ) ). Dies kann durch Induktion nachgewiesen werden. Für alle k gilt k ≪ n (dh f k ≪ i d mit 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$), aber wir haben dies nicht für nicht konstante Funktionen wie , n 2 ≪ ̸ n .$n^2$$n^2 \not \ll n$

Vergleichen Sie die Polynomhierarchie mit der Hierarchie für interaktive Beweise. Wenn aus irgendeinem festen k , Sie haben k Abwechslungen in einem interaktiven Beweis - IP ( k ) - die resultierende Komplexität Klasse keine Leistung mehr als das, was man mit zwei Abwechslungen bekommen - das heißt, IP ( k ) = IP (2 ) = AM (unter der Annahme von k ≥ 2). Wenn Sie jedoch eine polynomielle Anzahl von Abwechslungen zulassen, erhalten Sie die Komplexitätsklasse IP = PSPACE, von der angenommen wird, dass sie viel größer als AM ist. Eine Klasse ist in Π enthalten ₂ P auf der zweiten Ebene der Polynomhierarchie enthalten. Dieses Phänomen tritt also tatsächlich auf (obwohl, soweit wir wissen, mit der Polynomhierarchie).

Dies geschieht, weil die Reduktion, die ein Problem der Größe n in IP ( k ) annimmt und es in ein Problem in IP (2) umwandelt, die Problemgröße in die Luft sprengt, so dass das Problem für eine bestimmte IP ( k ) polynomisch bleibt Wenn Sie k variieren lassen, gibt die resultierende Reduktion keine Probleme, die in k polynomial sind .

Hier ist eine kleine Intuition bezüglich der Lücke zwischen konstanten und unbegrenzten Abwechslungen: Eine Polynomoperation, die eine konstante Anzahl von Malen wiederholt wird, ist polynomiell, aber eine Polynomanzahl von Malen wiederholt, kann exponentiell sein. Nehmen wir zum Beispiel die Multiplikation wiederholt auf sich selbst:

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

Die Anzahl der Iterationen ist linear und die Ausgabe ist exponentiell. Wenn Sie jedoch n festlegen, ist es in Bezug auf die Größe des Anfangswerts polynomisch.

Im Folgenden werde ich ein wenig auf den Punkt in Peters Antwort eingehen, indem ich versuche, die Quantifiziererentfernung für mehr als eine konstante Anzahl von Schritten durchzuführen, um zu sehen, wo dies fehlschlägt und ob aus einem solchen Versuch etwas geborgen werden kann.

Versuchen wir, P = N P zu verstärken$\mathsf{P}=\mathsf{NP}$ mehr als konstant .

Es sei angenommen , dass $\mathsf{P}=\mathsf{NP}$ . Daher gibt es eine Polynom-Zeitmaschine, die Ext-Circuit-SAT löst (gibt es eine zufriedenstellende Erweiterung für eine gegebene Schaltung und eine teilweise Zuordnung zu ihren Eingängen?).

Formal haben wir einen polytime Algorithmus $A$ mit Polynom Laufzeit $p(n)\in\rm{poly}(n)$ st

Bei einer Booleschen Schaltung $\varphi$ und einer teilweisen Zuordnung $\tau$ zu den Eingängen gibt
$A$ "Ja" zurück, wenn es eine Erweiterung von $\tau$ , die $\varphi$ erfüllt , und andernfalls "Nein".

To go over constant times, we need to do the quantifier removal effectively. We can do this because the Cook-Levin theorem is a constructive theorem, in fact it gives a polynomial time algorithm $Cook$ s.t.

Given a DTM $M$ receiving two inputs, and three unary numbers $n$, $m$, and $t$,
$Cook(M, n, m, t)$ returns a Boolean circuit of size $O(t^2)$ that simulates $M$ on inputs of length $(n,m)$ for $t$ steps.

Let's try to use these to extend the argument for $\mathsf{P}=\mathsf{PH}$ to obtain an algorithm solving TQBF (actually TQBCircuit, i.e. Totally Quantified Boolean Circuit problem).

The idea of the algorithm is as follows: we repeatedly use $Cook$ on $A$ to remove the quantifiers from a given quantified circuit. There are linear number of quantifiers so we hope to get a polynomial time algorithm (we have an algorithm with polynomially many steps using the polynomial time subroutine $Cook$). At the end of this process of quantifier elimination we will have a quantifier-free circuit which can be evaluated in polynomial time (Circuit Value problem is in $\mathsf{P}$, let $CV$ be a polynomial time algorithm for computing the circuit value of a given circuit).

However we will see that this idea does not work (for the same reason pointed out by Peter).

• Let $\varphi$ be a quantified circuit, (initialized to the given quantified formula).
• Let $k$ the number of quantifiers in $\varphi$.

• For $i$ from $k$ to $1$ do

  • Let $\psi$ = $Qx_k \sigma(x_1,...,x_k)$ be the last quantifier and the quantifier-free part.

  • If $Q = "\exists"$,

    1. Compute $C = Cook(A, |\sigma|, |x_1|+...+|x_k-1|, p)$,
    2. Substitute the input bits with $\sigma$ in the circuit $C$,
    3. Replace $\psi$ with $C$ in $\varphi$.

  • If $Q = "\forall"$,

    1. Consider $\psi$ as $\lnot \exists x_k \lnot \sigma$,
    2. Compute $C = Cook(A, |\lnot \sigma|, |x_1|+...+|x_k-1|, p)$,
    3. Substitute the input bits with $\lnot \sigma$ in the circuit $C$,
    4. Replace $\psi$ with the $\lnot C$ in $\varphi$.
• Compute and return $CV(\varphi)$.

The resulting algorithm looks polynomial time: we have polynomial many steps, each step is polynomial time computable. However this is not correct, the algorithm is not polynomial time.

Using polynomial time subroutines in a polynomial time algorithm is polynomial time. The problem is that in general this does not need to be true if the values returned by the subroutines are not of polynomial size in the original input and we assume that we do assignments about the values returning from the subroutines. (In the TM model we have to read the output of any polynomial time subroutine bit by bit.) Here the size of the returned value from algorithm $Cook$ is increasing (can be a power of the size of the input given to it, the exact power depends on the running time of $A$ and is around $p^2(|input|)$, so since we know that $A$ cannot be less than linear time, $|output|$ is at least $|input|^2$).

The problem is similar to the simple code below:

• Given $x$,
• Let $n = |x|$,
• Let $y = x$,
• For $i$ from $1$ to $n$ do
  • Let $y = y^{|y|}$, (i.e. concatenation of $|y|$ copies of $y$)
• Return y

Each time we execute $y = y^{|y|}$ we square the size of $y$. After $n$ executions we will have a $y$ which is $x^{2^n}$ and has size $n2^n$, obviously not a polynomial in the size of the input.

Let's assume that we only consider quantified formulas with $k(n)$ quantifier alternations (where $n$ is the total size of the quantified formula).

Assume that $A$ runs in time $p$ (e.g. linear time which is not ruled out so far), and have maybe a more efficient $Cook$ algorithm outputting a smaller circuit of size $l(t)$ in place of $t^2$, then we get an algorithm for ExtCircuitSat that runs in time $(l\circ p)^{O(k)}(n)=\underbrace{l(p(l(p(\dots(l(p(n)))))))}_{O(k)\mbox{ compositions}}$. Even in the case that both $l$ and $p$ were linear (but with total coefficient $a\geq 2$) we would get an algorithm which runs in time $\Omega(n2^{k(n)})$ and if $k(n) = \Theta(n)$ it would be $\Omega(n2^n)$ similar to the brute-force algorithm (and even this was based on assuming Cook-Levin can be performed on algorithms resulting circuits of linear size in the running time of the algorithm).

I think this is because at each level of the PH, the number of alternations is a constant (i.e. independent of the input size), while in AP, the number of alternations can be unbounded (yet polynomial in the size of the input).