\documentclass{article}
\usepackage{amsmath}
\input{preamble.tex}

\newcommand{\p}{{\rm P}}
\newcommand{\pspace}{{\rm PSPACE}}
\newcommand{\exptime}{{\rm EXPTIME}}
\newcommand{\ppoly}{{\rm P/poly}}
\newcommand{\plog}{{\rm P/log}}
\newcommand{\np}{{\rm NP}}
\newcommand{\sat}{{\rm SAT}}
\newcommand{\good}{{\rm GOOD}}
\newcommand{\true}{{\rm TRUE}}
\newcommand{\false}{{\rm FALSE}}
\newcommand{\conp}{{\rm coNP}}

\begin{document}

\lecture{5}{February 22, 2001}{Dan Spielman}{Adam Winkel}

In this lecture, we will prove a major theorem in Complexity 
Theory which states that if NP is contained in P/poly, 
then the polynomial hierarchy collapses.  Because it is currently
thought that the polynomial hierarchy is incollapsable, this leads
us to believe 
that NP problems cannot be solved with polynomial sized circuits.   
The proof of the theorem will  illustrate  some interesting techniques 
in Complexity Theory.  

%In the original paper \cite{kls}, the same techniques were used
%to show the following results:
%\begin{enumerate}
%\item $\pspace \subseteq \p/poly \implies \pspace = \Sigma_2^P \cap \Pi_2^P$
%\item $\pspace \subseteq \p/log \iff \pspace = \p$
%\item $\exptime \subseteq \pspace/poly \iff \exptime = \pspace$
%\item $\np \subseteq \p/log \iff \p=\np$
%\item $\exptime \subseteq \p/poly \implies \exptime = \Sigma_2^P \implies \p \neq \np$
%\end{enumerate}

Toward the end of the lecture, we will consider some general
results in circuit complexity starting with Claude Shannon's initial
result on the number of hard functions.

\begin{section}{NP and P/poly }\end{section} 

First, recall the definition of P/poly :
\begin{eqnarray*}
\mbox{P/poly} = \{ \mbox{ all languages, $L$, where } \exists k>0, A \in \mbox{P}, \mbox{ and a sequence of strings } \\
\{s_n\}_{n \in {\cal N}} \mbox{ such that } |s_n|=O(n^k) \mbox{ and }
w \in L \iff (w,s_{|w|}) \in A \}
\end{eqnarray*}

The $s_n$ strings can be thought of as input-size dependent advice given
to a Turing machine.  We will start by assuming that the canonical 
NP-complete problem, SAT $\in$ P/poly, and then define what it
means to for a sequence of strings to be a {\em good} sequence of advice
strings for SAT.  In turn, we will define the language, GOOD, of 
good advice sequences, and then we will show that 
$\good \in \conp$.   This allows us to construct a
$\Sigma_2 P$ TM that can guess a {\em good} sequence, then verify that the
sequence is {\em good}, and finally use the sequence to decide complete 
problems for $\Sigma_3 P$.  Therein lies the collapse of PH.

\begin{theorem}[Karp, Lipton, Sipser]If $\np \subset \mbox{P/poly}$ then $\Sigma_3 P \equiv \Sigma_2 P$ (PH collapses)\end{theorem}

Take the $\np$ complete problem $\sat$.
Since $\sat \in \mbox{P/poly}$, then there is some constant $k$, 
some polynomial language, $A\in P$, and a sequence of strings $\{s_n\}_{n \in {\cal N}}$ such that $|s_n| < {kn^k}$ and $ w \in SAT \iff (w,s_{|w|}) \in A$.  We fix the language $A$ for the rest of this lecture.
 
\begin{definition}  The sequence of strings $(g_1,...,g_l)$ is a {\em good } sequence if
\begin{enumerate}
\item $\forall i, \ |g_i| \leq ki^k$
\item $\forall \phi, \ |\phi|<l, \phi \in SAT \iff (\phi,g_{|\phi|}) \in A$
\end{enumerate} 
\end{definition}

\begin{definition} 
$\good = \{ (g_1,...,g_l) | (g_1,...,g_l) \mbox{ is a good sequence } \}$
\end{definition}

It is easy to see that $\good \in \Pi_2 P$ by exploiting an earlier
definition that $\Pi_2 P = \mbox{co-Np}^{SAT}$.  Consider the following ATM: 
\begin{enumerate}
\item On input $(g_1,...,g_l)$, first check to make sure that 
$|g_i| \leq ki^k$ for $1\leq i \leq l$.  Otherwise, reject.
\item Next, use the $\forall$
states to choose a boolean formula $\phi$ such that $|\phi|<l$.  
\item Let $a$ be a boolean variable.  Use the polynomial TM to compute 
$a \leftarrow (\phi, s_{|\phi|}) \stackrel{?}{\in} A$.  
\item Ask the $SAT$ oracle whether $\phi \in SAT$.  
\item Accept if $a \iff \phi \in SAT$.  Otherwise, reject.
\end{enumerate}

However, we can prove an even better containment, $\good \in \conp$,
by understanding the notion of self-reducibility.

\begin{definition} A language $L$ is self-reducible if there exists a 
polynomial time Oracle Turing Machine (OTM) $M$ such that 
\begin{enumerate}
\item $M^L$ accepts $L$
\item on inputs of length $n$, $M$ only queries the oracle about
words of length less than $n$.
\end{enumerate}
\end{definition}

One can think about self-reducible languages as those accepted by
some sort of dynamic programming Turing machine that can look up answers to smaller problems.  Now we show that SAT is self-reducible.

\begin{lemma}$SAT$ is self-reducible. \end{lemma}
\begin{proof} 
Consider a boolean formula $\phi$ of $n$ variables, $\phi(x_1,...,x_m)$.
We can fix $x_1=TRUE$ and $x_1=FALSE$ and evaluate the formula
$\phi$ with those assignments.  The resulting formulas 
\begin{eqnarray*}
	\phi_0  &= \phi(0,x_2,...,x_m) \\ 
	\phi_1 &= \phi(1,x_2,...,x_m)
\end{eqnarray*}
will be smaller formulas, and moreover, $\phi \in SAT$ iff 
( $\phi_0 \in SAT \vee \phi_1 \in SAT$ )
\end{proof}

\begin{lemma}$\good \in \Pi_1 P \ (\mbox{ i.e. } \conp)$\end{lemma}
\begin{proof}
Consider the following Turing machine that decides GOOD:
\begin{enumerate}
\item On input $(g_1,...,g_l)$, check the length requirement as before.
\item As before, use $\forall$ states to choose $\phi$ such that $|\phi| \leq l$.  
\item As before, $a \leftarrow (\phi, s_{|\phi|}) \stackrel{?}{\in} A$.  
\item If $\phi$ contains no bound variables (base case),
then evaluate $\phi$ and accept only if $a \iff \phi \in SAT$.
\item Otherwise, use self-reduction to construct $\phi_0, \phi_1$.
\item Let $a_i \leftarrow ( ( \phi_i, g_{|\phi_i|} ) \in A )$.
\item Accept iff $a \iff a_0 \vee a_1$.
\end{enumerate}

Note that we only use $\forall$ states, so this TM is in $\conp$.

We show correctness by first observing that we could either 1) reject a {\em good } sequence, or 2) accept a non-{\em good} sequence.
It is easy to see that we will accept all {\em good} sequences.

Now we show that we will reject all non-{\em good} sequences. Observe that sequences can fail to be {\em good} in two ways:
\begin{enumerate}
\item   A sequence might cause $A$ to reject an otherwise 
satisfiable formula.   In this case, at step (3), the boolean
variable $a$ will be $false$.  If $\phi$ is trivial, then we
will evaluate it and notice that it in fact is $\in SAT$.  Therefore,
our machine will reject the sequence.  

If $\phi$ is not trivial,
then we will compute $a_i$ in step (6).  Observe that since the sequence
$(g_1,...,g_l)$ is a bad sequence, then there is some minimal length 
satisfiable formula $\phi_min$ on which $(g_1,...,g_l)$ convinces 
$A$ to reject.   We can assume that our $\forall$ states will find 
this $\theta$.  However,  since $\phi_{min_0},\phi_{min_1}$ are smaller formulas, 
then $(g_1,...,g_l)$ will offer the correct advice on these strings.
In particular, since $\phi_min$ was satisfiable, either $a_0=\true$ or
$a_1=\true$.  Therefore, our machine will reject in step (7).

\item  The sequence might convince $A$ to accept a formula that is
not satisfiable.  At step (3), the boolean variable $a$ will be set
to $true$.  Like before, the base case in (4) will reject the sequence 
immediately if $\phi$ evaluates to false.

Otherwise, we will compute $a_i$ as before.  The same argument about
minimal $\phi_min$ applies in this case.  There is some minimal
length unsatisfiable formula $\phi_min$ on which $(g_1,...,g_l)$ convinces 
$A$ to accept.  Since $\phi_{min_i}$ are smaller formulas, then the
sequence will advise $A$ to reject both of them since neither are satisfiable.
Hence, our machine will reject in step (7).
\end{enumerate}

The key idea is to understand that if the sequence {\em ever} deceives
us, then there must be some minimal length formula on which it deceives
us.  Our $\forall$ states are guaranteed to find this minimal length case.
By using self-reduction, this minimal length case can be transformed into
two smaller questions on which the sequence must act correctly.  In this
way, we can detect the deception and reject.  Remember that one rejecting
branch of a $\conp$ computation tree suffices to reject altogether.

\end{proof}

Now we return to our original goal, proving the theorem of Karp, Lipton , and Sipser.  To refresh our memory, we restate the theorem.

\begin{theorem}[Karp, Lipton, Sipser]If $\np \subset \mbox{P/poly}$, then $\Sigma_3 P \equiv \Sigma_2 P$ (PH collapses)
\end{theorem}

\begin{proof}
We have already shown that $SAT \in \ppoly$ and that $\good \in \conp$.

Let $L$ be a language in $\Sigma_3 P$.  Thus, $\exists B \in P$ and a polynomial p(.), such that
\begin{displaymath}
w \in L \iff ( \ \exists x \forall y \exists z (w,x,y,z) \in B and  |x|,|y|,|z| \leq p(w).
\end{displaymath}

To complete the proof of the theorem, we present a Turing machine that
decides $L$.  On input $w$:
\begin{enumerate}
\item Use $\exists$ states to guess an $x$ and a {\em good} sequence of strings $(g_1,...,g_l)$ for $l$ ``sufficiently large," to be determined later.
\item Use $\forall$ states to guess $y$.  Continue to use $\forall$ states to test if $(g_1,...g_l) \in \good$ using the above lemma.  If not, we reject.
\item We want to know if $\exists z$ such that $(w,x,y,z) \in B$.  This problem is in NP.
\item Reduce the above problem to an NP-complete problem: SAT.  Construct $\phi$ such that $\phi \in SAT \iff \exists z$ such that $(w,x,y,z) \in B$.
\item Use the good sequence $(g_1,...,g_l)$ to decide whether 
$(\phi,g_{|\phi|}) \in A$.  Accept if $A$ accepts, else reject.  
\end{enumerate}

From the last step, we can see that $l$ must be  $\geq |\phi$.
The machine alternates between $\exists$ and $\forall$ states only once, and so it is in $\Sigma_2 P$. 
\end{proof}

\begin{section}{Circuit Complexity}\end{section}

\begin{theorem}[Claude Shannon]  There is a sequence of functions
 $f:\{0.1\}^n \rightarrow \{0,1\}$,
such that the circuit complexity, $C(f) = \Omega(\frac{2^n}{n})$.
\end{theorem}

Aside: It is not too hard to show that $\forall f, C(f) \leq O(2^n)$

\begin{proof}
This is a simple counting argument.  There are $2^{2^n}$ functions from
$\{0,1\}^n \rightarrow \{0,1\}$.  To show this, consider each function as
a table of ones and zeroes for each $n$-bit number.  Hence, each function can
be represented as a $2^n$ bit string, and there are a total of $2^{2^n}$ different $2^n$ bit strings.  

Consider the number of circuits that consist of $g$ 
and/or/not gates.  There are $3^g$ different sets of gates we can use, and
there are $<(g+n)^{2g}$ different input configurations for the gates.
Hence, there are at most $3^g(g+n)^{2g}g$ different boolean circuits of
$g$ gates.  Consider the set of functions such that $C(f)<g$.  This implies
that $2^{2^n} < 3^g(g+n)^{2g}$.  Taking logs, we have $2^n < 2g(\log(g+n+3/2)) + \log{g}$
which implies that $g>\frac{2^n}{2n}$.  There are some more complicated 
methods to eliminate the $2$ in the denominator.
\end{proof}

%\begin{thebibliography}{99}
%\bibitem{kls} Richard M. Karp and Richard J. Lipton. Some connections between nonuniform and uniform complexity classes. In {\em Conference Proceedings of the Twelfth Annual ACM Symposium on Theory of Computing}, pages 302-309, Los
%     Angeles, California, 28-30 April 1980.
%\end{thebibliography}

\end{document}