Ip (complexity) Article Index for
Ip
 

Information About

Ip (complexity)




More formally:




wt-avg_{m_{j+1}} N_{M_{j+1}}: j < p\ and\ j\ is\ even\
\end{cases}


where the term wt-avg_{m_{j+1}}N_{M_{j+1}} is defined as follows:

wt-avg_{m_{j+1}}N_{M_{j+1}} = \sum_{m_{j+1}}(Pr_r {Link without Title} )

where Pr_r is the probability taken over the random string r of length p. This expression is the average of N_{M_{j+1}}, weighted by the probability that the verifier sent message m_{j+1}.

Take M_0 to be the empty message sequence, here we will show that N_{M_0} can be computed in polynomial space, and that N_{M_0} = Pr accepts\ w . First, to compute N_{M_0}, an algorithm can recursively calculate the values N_{M_j} for every j and M_j.
Since the depth of the recursion is p, only polynomial space is necessary. The second requirement is that we need N_{M_0} = Pr accepts w , the value needed to determine whether w is in A. We use induction to prove this as follows.

We must show that for every 0 \leq j \leq p and every M_j, N_{M_j} = Pr accepts\ w\ starting\ at M_j , and we will do this using induction on j. The base case is to prove for j = p. Then we will use induction to go from p down to 0.

The base case (j = p) is fairly simple. Since m_p is either accept or reject, if m_p is accept, N_{M_p} is defined to be 1 and Pr accepts w starting at M_j = 1 since the message stream indicates acceptance, thus the claim is true. If m_p is reject, the argument is very similar.

For the inductive hypothesis, we assume that for some j + 1 \leq p and any message sequence M_{j+1}, N_{M_{j+1}} = Pr accepts\ w\ starting\ at\ j+1 and then prove the hypothesis for j and any message sequence M_j.



max_{m_{j+1}} Pr accepts\ w\ starting\ at\ M_{j+1} \leq Pr accepts\ w\ starting\ at\ M_j

because the prover on the right-hand side could send the message m_{j+1} to maximize the expression on the left-hand side. And:

max_{m_{j+1}} Pr accepts\ w\ starting\ at\ M_{j+1} \geq Pr accepts\ w\ starting\ at\ M_j

Since the same Prover cannot do any better than send that same message. Thus, this holds whether i is even or odd and the proof that IP \subseteq '''PSPACE''' is complete.

Here we have constructed a polynomial space machine that uses the best prover P for a particular string w in language A. We use this best prover in place of a prover with random input bits because we are able to try every set of random input bits in polynomial space.
Since we have simulated an interactive proof system with a polynomial space machine, we have shown that IP \subseteq '''PSPACE''', as desired.


\Box


PSPACE is a subset of IP


In order to illustrate the technique that will be used to prove PSPACE \subseteq IP, we will first prove a weaker theorem, which was proven by Lund, et al.: \#SAT \in PSPACE. Then using the concepts
from this proof we will extend it to show that TQBF \in PSPACE. Since TQBF \in PSPACE-Complete, and TQBF \in IP then PSPACE \subseteq IP.


#SAT is a member of IP

We begin by showing that \#SAT \in IP, where:


\#SAT = \{ \langle \phi, k angle \mid \phi is a cnf-formula with exactly k satisfying assignments \}.


Note that this is different from the normal definition of #SAT , in that it is a decision problem, rather than a function.

First we use arithmetization to map the boolean formula with n variables, \phi(b_1, b_2, ..., b_n) to a polynomial p_\phi(x_1, x_2, ..., x_n), where p_\phi mimics \phi in that p_\phi is 1 if \phi is true and 0 otherwise provided that the variables of p_\phi are assigned Boolean values. The Boolean operations ee, \wedge, and
eg used in \phi are simulated in p_\phi by replacing the operators in \phi as shown in the table below.

As an example, \phi = a \wedge b ee
eg c would be converted into a polynomial as follows:




Now let F be a finite field with order q > 2^n; also demand that q be at least 1000. For each 0\leq i\leq n, define a function f_i on F, having parameters a_1, ..., a_{i-1}\in F, and a single variable a_i\in F: For 0 \leq i \leq n and for a_1, ..., a_i \in F let f_i(a_1, ..., a_i) = \Sigma _{a_{i+1}, ..., a_n \in \{0, 1\}} p(a_1, ..., a_n). Note that the value of f_0 is the number of satisfying assignments of \phi. f_0 is a void function, with no variables.

Now the protocol for \#SAT works as follows:


Note that this is a public-coin algorithm.

If \phi has k satisfying assignments, clearly V will accept. If \phi does not have k satisfying assignments we assume there is a prover ilde P that tries to convince V that \phi does have k satisfying assignments. We show that this can only be done with low probability.