পি = এনপি কেন পি = এপি বোঝায় না (অর্থাত্ পি = পিএসপিএসি)?

Question

এটা সর্বজনবিদিত যে $\mathbf{P}=\mathbf{NP}$ তারপর বহুপদী অনুক্রমের ভেঙে এবং $\mathbf{P}=\mathbf{PH}$ ।

এটি সহজেই ওরাকল মেশিনগুলি ব্যবহার করে সূক্ষ্মভাবে বোঝা যায়। প্রশ্ন হল - কেন আমরা পরিবর্তনও একটি ধ্রুবক স্তর অতিক্রম করিয়া প্রস্তাবনামূলক প্রক্রিয়াটি চালিয়ে যান এবং প্রমাণ করতে $\mathbf{P}=\mathbf{AltTime}(n^{O(1)})$ (ওরফে $\mathbf{AP}=\mathbf{PSPACE}$ )?

আমি একটি স্বজ্ঞাত উত্তর খুঁজছি।

Comments

সম্পর্কিত প্রশ্নগুলিও দেখুন cstheory.stackexchange.com/questions/2032/… এবং cstheory.stackexchange.com/questions/5463/…

— আন্দ্রে সালামন

জানা যায় $\mathsf{NL} = \mathsf{coNL}$ কিন্তু এটা সন্দেহ করা হয় যে $\mathsf{AL}$ (অর্থাত $\mathsf{P}$ ) সমান নয় $\mathsf{NL}$ ।

— sdcvvc

সম্পর্কিত: এনপি = কোএনপি এমপি = পিএসপিএসিই বোঝায়

— কাভেঃ

Answer 1

জন্য প্রমাণ পি = একটি ঠ টি টি ই আছি ই ( হে ( 1 ) ) ( = পি এইচ ) ব্যবহার করে একটি আনয়ন হয় পি = এন পি । অন্তর্ভুক্তি দেখায় যে যে কোনও প্রাকৃতিক সংখ্যার জন্য কে , পি = এ এল টি টি আই এম ই ( কে ) (এবং এ এল টি টি আই এম ই ( ও ( 1 ) $\mathbf{P}=\mathbf{AltTime}(O(1))$$=\mathbf{PH}$$\mathbf{P}=\mathbf{NP}$ $k$$\mathbf{P}=\mathbf{AltTime}(k)$$\mathbf{AltTime}(O(1))$ কেবল তাদের ইউনিয়ন)।

আনয়নটি যখন ইনপুট আকারের সাথে পরিবর্তনের সংখ্যা পরিবর্তন করতে পারে তখন কাজ করে না (যেমন যখন মেশিনের সম্ভাব্য পরিবর্তনের সংখ্যা কোনও সংখ্যার নয় তবে ইনপুট আকারের একটি ফাংশন হয়, অর্থাৎ আমরা দেখায় না যে মেশিনের একটি কার্যকরকরণ একক ইনপুটটিতে কোনও বিকল্পকে হ্রাস করা যায় না, আমরা দেখিয়ে দিচ্ছি যে সমস্ত ইনপুটগুলিতে মেশিনের সম্পাদনকে "অভিন্নভাবে" কোনও বিকল্পে পরিণত করা যায় না)।

আসুন একটি অনুরূপ কিন্তু সহজ বিবৃতি তাকান। আমরা দেখাতে হবে যে পরিচয় ফাংশন চান আমি ঘ ( এন ) = ঢ অবশেষে সব ধ্রুবক ফাংশন প্রাধান্য পায় ( চ « ছ iff জন্য সব কিন্তু finitely অনেক এন চ ( এন ) ≤ ছ ( এন ) )। ইন্ডাকশন দ্বারা এটি প্রমাণিত হতে পারে। সমস্ত কে , কে ≪ এন (অর্থাত্ চ কে ≪ আই ডি যেখানে এফ কে ( এন ) = $id(n)=n$$f \ll g$$n$ $f(n) \leq g(n)$$k$$k \ll n$$f_k \ll id$$f_k(n)=k$), but we don't have this for non-constant functions like $n^2$, $n^2 \not \ll n$.

Answer 2

Compare the polynomial hierarchy with the hierarchy for interactive proofs. If for some fixed k, you have k alternations in an interactive proof -- IP(k) -- the resulting complexity class has no more power than what you get with two alternations -- that is, IP(k) = IP(2) = AM (assuming k≥2). However, if you allow a polynomial number of alternations, you get the complexity class IP = PSPACE, which is believed to be much bigger than AM, a class is contained in Π₂P, at the second level of the polynomial hierarchy. So this phenomenon actually happens (although, not so far as we know, with the polynomial hierarchy).

This happens because the reduction which takes a problem of size n in IP(k) and turns it into a problem in IP(2) blows up the problem size, so that while for any specific IP(k) the problem remains polynomial-size, if you let k vary, the resulting reduction doesn't give problems that are polynomial in k.

Answer 3

Here is a little intuition concerning the gap between constant and unbounded alternations: a polynomial operation repeated a constant number of times is polynomial, but repeated a polynomial number of times can be exponential. For example, take multiplication repeated on itself:

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

The number of iterations is linear, and output is exponential. But if you fix n, it is polynomial on the size of initial value.

Answer 4

Below I expand a little bit on the point in Peter's answer by trying to carry out the quantifier removal for more than constant number of steps to see where it fails and if anything can be salvaged from such an attempt.

Let's try to amplify $\mathsf{P}=\mathsf{NP}$ for more than constant number times.

Assume that $\mathsf{P}=\mathsf{NP}$. Therefore there is polynomial time machine that solves Ext-Circuit-SAT (is there a satisfying extension for a given circuit and a partial assignment to its inputs?).

More formally, we have a polytime algorithm $A$ with polynomial running time $p(n)\in\rm{poly}(n)$ s.t.

Given a Boolean circuit $\varphi$, and a partial assignment $\tau$ to the inputs,
$A$ returns "yes" if there is an extension of $\tau$ that satisfies $\varphi$, and return "no" otherwise.

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).

Comments

I really like this answer!!

— Tayfun Pay

@kaveh What if $p(n)=2^{\Omega(n)}$ while $l(t)=O(t)$ then do we need at least double exponential time for $NP^{NP^{NP}}$? Your argument seems to suggest that possibility while we know $PSPACE$ is in $EXP$ and so how to get the single exponential back?

— T....

Answer 5

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).