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

\newcommand{\TIME}[1]{\ensuremath{\mbox{TIME}(#1)}}
\newcommand{\SPACE}[1]{\ensuremath{\mbox{SPACE}(#1)}}
\newcommand{\setof}[1]{\ensuremath{\left\{ #1\right\}}}
\newcommand{\sizeof}[1]{\ensuremath{\left| #1\right|}}
\newcommand{\Sizeof}[1]{\ensuremath{\Big| #1 \Big|}}

\newcommand{\NP}{\mathrm{NP}}
\newcommand{\EQBF}{\exists\mathrm{QBF}}
\newcommand{\coNP}{\mathrm{coNP}}
\newcommand{\Pt}{\mathrm{P}}
\renewcommand{\bigO}{\mathrm{O}}
\newcommand{\Ppoly}{\mathrm{P/poly}}
\newcommand{\SAT}{\mathrm{SAT}}
\newcommand{\GOOD}{\mathrm{GOOD}}
\renewcommand{\FOR}{\textbf{for}}
\newcommand{\FORALL}{\textbf{for all}}
\newcommand{\CHOOSE}{\textbf{choose}}
\renewcommand{\TO}{\textbf{to}}
\renewcommand{\DO}{\textbf{do}}
\renewcommand{\WHILE}{\textbf{while}}
\renewcommand{\AND}{\textbf{and}}
\renewcommand{\IF}{\textbf{if}}
\renewcommand{\THEN}{\textbf{then}}
\renewcommand{\ELSE}{\textbf{else}}
\newcommand{\ACCEPT}{\textbf{accept}}
\newcommand{\REJECT}{\textbf{reject}}
\newcommand{\settabs}{\hspace{0.25 in}\= \hspace{0.25 in}\=\hspace{0.25 in}\= \ hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \hspace{0.25 in}\= \kill}
\begin{document}

\lecture{6}{February 23, 1998}{Daniel A. Spielman}{Matthew Secor}

\section*{NP and P/poly}

The major result that we will show here is that if $\NP$ is contained
within $\Ppoly$, then the polynomial hierarchy collapses.  We will
prove that if $\NP \subseteq \Ppoly$ then $\Sigma_2 P = \Pi_2 P$.
Before we prove this, let's review what this all means. Recall the
definition of $\Ppoly$:
\begin{eqnarray*}
  \Ppoly = \{L&:& \exists k>0, A\in P\textrm{ and a sequence of
  strings } \{S_n\}_{n=1}^{\infty} \textrm{ such that } \\&&|S_n| =
  \bigO(n^k) \textrm{ and } \forall w, w\in L \Longleftrightarrow
  (w,S_{|w|})\in A \}
\end{eqnarray*}
Using this definition, we know the following, which
will be useful later:
\begin{proposition}
\begin{eqnarray*}
  \NP \subseteq \Ppoly \Longrightarrow \SAT \in \Ppoly &\Longrightarrow&
  \exists k>0, A\in P, \{S_n\}_{n=1}^{\infty} \textrm{ such that } \\&&|S_n| \le
  (k n)^k \textrm{ and } \forall \phi, \phi\in \SAT \Longleftrightarrow
  (\phi,S_{|\phi|})\in A\ .
\end{eqnarray*}
\label{Prop:SATinPpoly}
\end{proposition}
We can think of the sequence of strings $\{S_n\}_{n=1}^\infty$ as
advice strings which, in conjunction with the original input to
$\SAT$, allow us to decide $\SAT$ in polynomial time.

For the following definitions, we will assume that $\NP \subseteq
\Ppoly$ and thus $\SAT \in \Ppoly$. We begin with a definition:
\begin{definition}
  A sequence of strings $(a_1, \dots, a_\ell)$ is {\em good}
  if $|a_i| \le (ki)^k$ and
for
  all $|\phi|\le \ell$,
  $$
     \phi \in \SAT \Longleftrightarrow
     (\phi,a_{|\phi|}) \in A,
  $$
  where $A$ is defined as the machine in Proposition \ref{Prop:SATinPpoly}.
\end{definition}
Note that these good strings are not necessarily the same as the
sequence of strings $\{S_n\}_{n=1}^{\infty}$ in Proposition
\ref{Prop:SATinPpoly}. There could be many different good sequences of
length $\ell$, although the sequence $\{S_n\}_{n=1}^\ell$ is, by
definition, good.
\begin{definition}
  $\GOOD$ is the language consisting of all of the good sequences of
  strings.  
\end{definition}
\begin{proposition}
  $\GOOD \in \Pi_2^\Pt$
\end{proposition}
\begin{proof}
  Given a candidate sequence, $(a_1, \dots, a_\ell)$, we must show two
  things. 
  First, we need to check that the size constraint is met
  ($|a_i|\le(ki)^k$ for some $k$). This is easy.
  Second,
  we must show that the check to see if some sequence of strings is
  good can be done with a $\Pi_2^\Pt$ machine. In order to see
  this, consider the verification that needs to be done for
  the input $(a_1, \dots, a_\ell)$. The following
  property must hold:
  $$
    \forall \phi, |\phi|\le \ell: \phi \in \SAT \Longleftrightarrow
    (\phi,a_{|\phi|}) \in A \ .
  $$
  If we can show that $\GOOD$ is in $\coNP^\SAT$, we are done because
  $\coNP^\SAT \subseteq \Pi_2^\Pt$. We can show this by noting that
  checking for $\phi \in \SAT$ takes a single call to a $\SAT$ oracle,
  and checking $(\phi,a_{|\phi|})\in A$ requires polynomial time. So,
  for each $\phi$ that we check, we require polynomial time with a
  call to a $\SAT$ oracle, and we can use a $\forall$ state to perform
  the computation over each possible $\phi$, giving rise to a
  $\coNP^\SAT$ machine.
\end{proof}\\
Now, we will introduce the concept of self-reducibility, needed to
prove a stricter containment of $\GOOD$.
\begin{definition}
  A language $L$ is {\em self-reducible} if there exists a polynomial
  time oracle Turing machine $M^L$ such that
  \begin{itemize}
    \item[(i)] $M^L$ accepts $L$, and
    \item[(ii)] $M^L$ can only ask oracle about strings of length
  strictly less than the length of its input.
  \end{itemize}
\end{definition}
According to this definition, almost all of the languages we have seen
are self-reducible.\footnote{There are languages in $\Ppoly$ that are
not self-reducible. Also, it is possible to choose languages in $\NP$
which are not self-reducible.} In particular, $\SAT$ is self-reducible.
\begin{proposition}
  $\SAT$ is self-reducible.
\end{proposition}
\begin{proof}
  In order to show this, we need to find out how to tell whether
  $\phi(x_1, \dots, x_n)$ is satisfiable, if we only have access to an
  oracle that can tell us about formulas shorter than $\phi$. Consider
  the following two formulas:
  \begin{eqnarray*}
    \phi_0(x_2, \dots, x_n) &=& \phi(0, x_2, \dots, x_n)\ \mathrm{, and}\\
    \phi_1(x_2, \dots, x_n) &=& \phi(1, x_2, \dots, x_n)\ .
  \end{eqnarray*}
  Given $\phi$, we can build $\phi_0$ and $\phi_1$ in polynomial time,
  and we also know that $|\phi_0|$ and $|\phi_1|$ are less than
  $|\phi|$. So, in order to check whether $\phi \in \SAT$, we only
  need to check if either $\phi_0$ or $\phi_1$ are in $\SAT$, and
  accept if either is. Thus, we can construct a machine $M^\SAT$ which
  computes $\phi_0$ and $\phi_1$ and accepts only if one of them is
  satisfiable (determined with two calls to the $\SAT$ oracle).
\end{proof}\\
We now use this definition of self-reducibility to show that
$\GOOD\in\Pi_1^\Pt$, which will allow us to construct a $\Sigma_2^\Pt$
machine that decides $\EQBF_3$ if $\SAT\in\Ppoly$.
\begin{lemma}
  $\GOOD \in \Pi_1^\Pt$
\end{lemma}
\begin{proof}
  We start by defining a Turing machine $M_\GOOD$, then we show that it accepts
  $\GOOD$ and that it is in $\Pi_1^\Pt$. Essentially, $M_\GOOD$ is trying to
  verify the following property for every $\phi$ such that
  $|\phi|\le\ell$:
  \begin{equation}
    \phi \in \SAT \Longleftrightarrow (\phi,a_{|\phi|}) \in A \ .
  \label{Eq:GOOD}
  \end{equation}
  $M_\GOOD$ performs the following
  algorithm on each input $(a_1,\dots,a_n)$:
  {\sffamily
  \begin{tabbing}
    \settabs
    \textbf{Algorithm:}\\
    I\>\FORALL\ $\phi$ such that $|\phi|\le\ell$ (using a $\forall$ state)\\
    II\>\>check if $(\phi,a_{|\phi|}) \in A$\\
    III\>\>\IF\ $|\phi|=1$, verify Property (\ref{Eq:GOOD}) directly,\\
    \>\>\>\ACCEPT\ if the property is satisfied\\
    \>\>\>\REJECT\ otherwise\\
    IV\>\>\IF\ $(\phi,a_{|\phi|})\not\in A$,\\
    \>\>\>\ACCEPT\ if no assignment satisfies $\phi$ (using
  $\forall$ state to try all possible assignments)\\
    \>\>\>\REJECT\ otherwise\\
    V\>\>\IF\ $(\phi,a_{|\phi|})\in A$, self-reduce $\phi$ to get
  $\phi_0$ and $\phi_1$ and\\
    \>\>\>\ACCEPT\ if $(\phi_0,a_{|\phi_0|})\in A$ or
  $(\phi_1,a_{|\phi_1|})\in A$ \\ 
    \>\>\>\REJECT\ otherwise\\
  \end{tabbing}
  }
  Step \textsf{V} requires some explanation. In order to show that
  $\phi\in\SAT$, by self-reducibility, it suffices to show that
  $\phi_0\in\SAT$ or $\phi_1\in\SAT$. If we know the algorithm works
  for shorter formulas, then checking that $(\phi_0, a_{|\phi_0|})\in
  A$ is equivalent to checking whether $\phi_0\in\SAT$. So, by an
  inductive argument, we can show that this will work for a formula of
  a certain length once we know it works for all shorter lengths.

  Now, we need to prove this algorithm accepts $\GOOD$. (i) and (ii)
  will establish this.
  \begin{itemize}
    \item[(i)] If the input $(a_1, \dots, a_\ell)$ is good, then the
  program accepts. This is clear from the definition of the algorithm.
    \item[(ii)] If the program accepts, then the input is good. Assume
  (for contradiction) that it accepts, but the input is not good. Let
  $\phi$ have minimal length such that
    \begin{itemize}
      \item[(a)] $(\phi,a_{|\phi|})\in A$ but $\phi\not\in\SAT$, or
      \item[(b)] $(\phi,a_{|\phi|})\not\in A$ but $\phi\in\SAT$.
    \end{itemize}
    Then, if (b) were the case, we would reach step \textsf{IV}, but we would
  reject because a satisfying assignment would be found. If (a) were
  the case, we would reach step \textsf{V}, and produce $\phi_0$ and $\phi_1$
  that must both not be satisfiable because $\phi$ has minimal length
  such that the program accepts incorrectly, so we would reject. The
  final case is for $|\phi|=1$. In this case, step \textsf{III} provides the
  correct behavior.

  Also, note that we only used $\forall$ states in the construction of
  $M_\GOOD$ and the computation required is polynomial in the input length,
  so that $M_\GOOD$ is in $\Pi_1^\Pt$.
  \end{itemize}
\end{proof}
\begin{theorem}[Karp and Lipton]
  $\SAT\in\Ppoly\Longrightarrow\Sigma_3^\Pt=\Sigma_2^\Pt$
\label{Thm:KarpLipton}
\end{theorem}
\begin{proof}
  We will show that if $\SAT\in\Ppoly$ then
  $\EQBF_3\in\Sigma_2^\Pt$. If this is true, then because $\EQBF_3$ is
  $\Sigma_3^\Pt$-complete, $\Sigma_3^\Pt=\Sigma_2^\Pt$. Remember that
  strings in $\EQBF_3$ are true statements of the form
  $$
    \exists x \forall y \exists z \;:\; \phi(x,y,z)\textrm{ is satisfiable}
  $$
  We can determine whether a statement of this form is in $\EQBF_3$
  using a Turing machine which implements the following algorithm:
  {\sffamily
  \begin{tabbing}
    \settabs
    \textbf{Algorithm:}\\
    \>\CHOOSE\ $x_0$ (using $\exists$ state)\\
    \>\CHOOSE\ $(a_1, \dots, a_{|\phi|})$, $|a_i|\le(ki)^k$ (using $\exists$ state)\\
    \>\FORALL\ $y_0$ (using $\forall$ state)\\
    \>\>check that $(a_1, \dots, a_{|\phi|})$ is good (using
  $M_\GOOD$ from above which only has $\forall$ states)\\
    \>\>compute $\hat\phi(z) = \phi(x_0, y_0, z)$\\
    \>\>\ACCEPT\ if $(\hat\phi(z),a_{|\hat\phi(z)|})\in A$\\
    \>\>\REJECT\ otherwise\\
  \end{tabbing}
  }
  The basic idea is to choose $x$ and $y$ using $\exists$ and
  $\forall$ states, as well as a good sequence $(a_1, \dots,
  a_{|\phi|})$. Then, we just have to check whether the simpler
  $\hat\phi(z)$ is in $\SAT$ in order to answer whether the overall
  statement is in $\EQBF_3$. To do this, we can use the definition of
  a good sequence which tells us that
  $$
    \hat\phi(z)\in\SAT\Longleftrightarrow
    (\hat\phi(z),a_{|\hat\phi(z)|})\in A
  $$
  To show that this algorithm is correct, observe that if 
  $\SAT\in\Ppoly$, then there exists a good $(a_1, \dots,
  a_{|\phi|})$; in particular, $\{S_n\}_{n=1}^{|\phi|} = (S_1, \dots,
  S_{|\phi|})$ is good. In any accepting computation, you obtain such
  a string so the algorithm accepts if and only if the statement
  ``$\exists x \forall y \exists z : \phi(x,y,z)$ is satisfiable'' is
  true. We have described a Turing machine that starts with $\exists$
  states, and switches only once to $\forall$ states, so the language
  decided by the machine is in $\Sigma_2^\Pt$.
\end{proof}\\
Finally, we can prove our original statement.
\begin{theorem}
  $\NP\subseteq\Ppoly\Longrightarrow\Sigma_2^\Pt=\Pi_2^\Pt$
\end{theorem}
\begin{proof}
  Theorem \ref{Thm:KarpLipton} tells us that
  $\Sigma_3^\Pt=\Sigma_2^\Pt$ if $\NP\subseteq\Ppoly$. We also know
  then that $\Pi_3^\Pt=\Pi_2^\Pt$ because $\Pi_k^\Pt =
  \mathrm{co}\Sigma_k^\Pt$. From this we have that
  \begin{eqnarray*}
  \Pi_2^\Pt\subseteq\Sigma_3^\Pt
           =\Sigma_2^\Pt
  \end{eqnarray*}
  and
  \begin{eqnarray*}
  \Sigma_2^\Pt\subseteq\Pi_3^\Pt
           =\Pi_2^\Pt\ ,
  \end{eqnarray*}
  Which leads to $\Sigma_2^\Pt = \Pi_2^\Pt$ and a collapse of the
  polynomial hierarchy.
\end{proof}
\end{document}



