18.405J/6.841J Advanced Complexity Theory March 19, 1998

Lecture 12

Lecturer: Daniel A. Spielman Scribe: Yoav Yerushalmi

1 Toda’s Theorem

In the previous class, we proved the following theorem:

Theorem 1 For any depth d AC_{0} predicate 𝔄, there exists a family of polynomials P (x, r) such that:

∀x, Pr_{r}[P (\overline{x}, \overline{r}) = 𝔄(x)] ≥ \frac{3}{4}

x is a normal input, and r is a random input. The degree of P is (log n)^{O(d)}, where \overline{x} = x_{1}, x_{2}, …, x_{n} and |r| = (log n)^{O(1)}

We will use that theorem to prove Toda’s Theorem, but first we need to introduce a new class and explain some symbols.

Our new class (introduced by Valiant) is #P. This class is used to count the number of accepting paths in the computation tree of P, and is useful for solving some problems:

f(x) ← #P iff ∃L ∈ P such that f(\overline{x}) = |\{y|(x, y) ∈ L\}|

This class can be used to solve some problems that are seemingly harder than NP. One such example is the permanent of a matrix, which is similar to the determinant, with the minor difference that all of its nonzero coefficients are +1. The permanent is defined thus:

P erm(M) = ∑_{π∈permutation(1,...,n)} ∏_{i=1}^{n} M_{i,π(i)}

Unlike the determinant, no efficient algorithm for computing the permanent is known. Valiant has proved that P erm(M) ⊆ #P

Next we show that for all instantiations of problems in NP, we can solve them by reduction to P erm. This is simple, since we know that given any nondeterministic polynomial time turing machine M, there exist polynomial-time computable functions f, g, such that the number of accepting paths of M on w = g(P erm(f(w))). Since we can count the number of accepting paths, we can easily decide if there will be a path which accepts. Therefore:

NP ⊆ P^{#P}

We now have what is required to define Toda’s Theorem

Theorem 2 (Toda’s Theorem) Toda’s Theorem puts a class in between the polynomial hierarchy and PSPACE:

P H ⊂ P^{#P} ⊂ P SP ACE

12-1 However, we can’t prove the theorem just yet. We define another new class ⊕P which we shall call parity-P:

⊕P = {f|∃g ∈ #P such that f = g mod 2}

That is, ⊕P tells us whether the number of accepting branches in a computation tree is even or odd. We will use parity-P and the theorem from the previous class to show that for any language L in the polynomial hierarchy, there exists a randomized bounded-error reduction from L to a language in P^{#P}, which will enable us to prove half of Toda’s Theorem.

It is implied that P ⊂ ⊕P, since all languages in P are solved by turing machines that have only one accepting path, which is therefore an odd number of paths.

Also, if L_{1}, L_{2} ∈ ⊕P where M_{1} ∈ ⊕P accepts L_{1} and M_{2} ∈ ⊕P accepts L_{2}, then:

(L_{1} ⊕ L_{2}) ∈ ⊕P :

The above tree shows how we demonstrate this fact. If both branches accept, then we have an even number of accepting branches, so we do not include it. If neither do, then still even (or zero). Only if only one side accepts does it remain within the tree (and therefore it is a unique element to one of the two languages).

(L_{1} · L_{2}) ∈ ⊕P :

The above tree shows how we demonstrate this fact. For each accepting branch in M_{1} we run the rest through M_{2}, if this yields a net sum of even branches that accept, we will not end up accepting, and vice-versa.

Now, let

L ∈ P, define f(w) = ∑_{k=1}^{2^{poly(|w|)}} number of y such that (w, y, k) ∈ L

then f ∈ #P, or when taken mod 2, f ∈ ⊕P

The machine in question existentially guesses the appropriate k, and then existentially guesses y. Similarly, we can argue for the same fact with ∑ replaced with ∏.

Now, we take a language L ∈ ∑_{k} P, and examine its computation tree. This forms an AC_{0} circuit with N gates where N = 2^{poly(n)}:

12-2

The theorem proved in the previous class yields us a probabilistic polynomial P (\overline{x}, \overline{r}) where deg(P) = (logN)^{O(k)} = poly(n) and |r| = (logN)^{O(1)} = poly(n). That is, ∃ a function f on two inputs w, \overline{r}, such that f(w, \overline{r}) ∈ ⊕P:

w ∈ L ⟹ Pr_{\overline{r}} [f(w, \overline{r}) = 1] ≥ \frac{3}{4}

w ∉ L ⟹ Pr_{\overline{r}} [f(w, \overline{r}) = 0] ≥ \frac{3}{4}

This is equivalent to thinking of the following: for L, existsA ∉ P such that w ∈ L iff ∃y_{1}, ∀y_{2}, ∃y_{3}, ∀y_{4}, …, ∃y_{k}:

(w, y_{1}, y_{2}, y_{3}, y_{4}, …, y_{k}) ← A

the above is contained in ⊕P.

Now, given a function that outputs bits, we want to determing if mostly their parity is 0 or 1. Let M be the nondeterministic polynomial-time machine corresponding to our function f(). That is, if w ∈ L, then for 3/4 of the settings of \overline{r}, M(w, \overline{r}) has an odd number of accepting paths.

Now, let x_{r} be the number of accepting paths of M(w, \overline{r}). Consider:

h(z) = 3z^{2} − 2z^{3} ≡ \{ \begin{matrix}0 (mod 2^{2^{k}}) & if z ≡ 0 (mod 2^{k}) \\ 1 (mod 2^{2^{k}}) & if z ≡ 1 (mod 2^{k}) \end{matrix}

Define h^{c}(z) = h(h^{c−1}(z)), h^{1}(z) = h(z). This is a simple recursive definition. We know that

h^{c}(z) ≡ \{ \begin{matrix}0 (mod 2^{2^{c}}) & if z ≡ 0 (mod 2) \\ 1 (mod 2^{2^{c}}) & if z ≡ 1 (mod 2) \end{matrix}

deg(h^{c}) = O(2^{c}); Choose c = ⌈log |r|⌉ + 1 → 2^{2^{c}} > 2^{|r|}. We can now claim that

∑_{r} h^{(c)}(X_{r}) mod 2^{2^{c}} ≥ 3/4 · 2^{|r|} iff w ∈ L

or alternatively stated, most of the X_{r}’s were odd. X_{r} is basically the number of accepting paths of M(w, \overline{r}). We now resolve the above equation:

∑_{r} h^{(c)}(X_{r}) ∈ #P ≡ ∑_{r} h^{(c)}(#M(w, \overline{r})) ∈ #P

The above equation means that

P H ⊂ P^{#P}

The latter part of the theorem is presumably proved in the next lecture.

12-3