\documentclass[11pt]{article}
%\usepackage{amssymb}

\textwidth=6in
\oddsidemargin=0.25in
\evensidemargin=0.25in
\topmargin=-0.1in
\footskip=0.8in
\parindent=0.0cm
\parskip=0.3cm
\textheight=8.00in
\setcounter{tocdepth} {3}
\setcounter{secnumdepth} {2}
\sloppy


\newtheorem{example}{Example}
% \P and \time are already used by LaTeX.  :-(
\newcommand{\ti}{\hbox{TIME}}
\newcommand{\spa}{\hbox{SPACE}}
\newcommand{\ntime}{\hbox{NTIME}}
\newcommand{\nspace}{\hbox{NSPACE}}
\newcommand{\conspace}{\hbox{co-NSPACE}}
\newcommand{\p}{\hbox{P}}
\newcommand{\np}{\hbox{NP}}
\newcommand{\pspace}{\hbox{PSPACE}}
\newcommand{\lspace}{\hbox{L}}
\newcommand{\conp}{\hbox{coNP}}
\newcommand{\exptime}{\hbox{EXPTIME}}
\newcommand{\elem}{\hbox{E}}
\newcommand{\nl}{\hbox{NL}}
\newcommand{\bpp}{\hbox{BPP}}

\newcommand{\nregexp}{\hbox{NREGEXP}}

\newcommand{\tqbf}{\hbox{TQBF}}
\newcommand{\threesat}{\hbox{3SAT}}
\newcommand{\cvp}{\hbox{CVP}}
\newcommand{\stconn}{\hbox{STCONN}}
\newcommand{\ispath}{\hbox{ISPATH}}


%\newcommand{\class}{\hbox{$\mathbb{C}$}} 
\newcommand{\class}{\hbox{$\mathbf{C}$}} 

\newcommand{\lep}{\leq _{\hbox{P}}}
\newcommand{\lel}{\leq _{\hbox{L}}}

\begin{document}
\input{preamble.tex}
\lecture{1}{February 1, 2000}{Daniel A. Spielman}{Shaun Cutts (from 1998: Zulfikar A. Ramzan)}

\section{Course Overview}

\subsection{Warnings} \begin{description} 

\item[Practical warning:] this course
follows the material in 18.404/6.840, but it is about an order of
magnitude harder.

\item[Philosophical warning:] much material in the course concerns itself
with what would be the case if $\p \neq \np$ . If it turns out that $ \p = \np $,
then much of what you will learn will be not true and/or irrelevant. In addition,
the course covers many things that are now considered blind alleys in the attempt
to prove that $\p \neq \np$. I think that they are good to learn, so you don't 
try to do them yourselves. There will be a few things covered of independent interest: 
e.g. De-randomization.

One other general remark: many of the techniques uses will have an algorithmic
flavor. Lately, some practitioners have wondered if there is perhaps too much
reliance on this approach.\footnote{Question: what would be a good example of 
a different approach? Answer: for instance, in Galois theory, the non-existence
of certain things is proved without considering possible constructions in detail.}

\end{description}

\subsection{Topics to be Covered}
\begin{itemize}
  \item ``things about \np''
  \item randomized classes
  \item non-uniform classes
  \item circuit classes \& lower-bound proofs
  \item interactive proofs, probabilisticly checkable proofs (PCPs)
  \item De-randomization
  \item possibly quantum complexity
\end{itemize}

\subsection{Mechanics}
There will be 4-5 problem sets. You can collaborate (just cite all collaborators).
Please don't look at old solution sets. In addition, one participant will be asked
to take scribe notes each class, and write them up in Latex.


\section{Review}

We won't specify the sort of Turing machine (e.g., one or two tape, or
even a RAM or Kolmogorov machine).  As long as we are consistent, it
won't matter.  Different definitions can change times by a polynomial
factor, but that does not change the definitions of classes like $\p$
and $\np$.  Also note that we used big $O$ notation in our definition.  
We won't look
at constant factors in too much detail for this course.  Blum proved
results a while back formally showing that we can more or less ignore constant
factors for the time complexity classes in which we are
interested.\footnote{Basic idea: increase \# of states in the machine, 
and the \# of tape symbols, and simulate more than one step at once.}

You have all seen definitions for \ti, \ntime, \spa, and \nspace. Briefly, for \class
\ one of the above, $L \in \class(t(n))$ if there exists a (nondeterministic) TM that accepts
$L$ in $\{ \hbox{time},\hbox{space} \}\ \bigO (t(n))$.

With the exception of CVP, you will probably be familiar with the following table: 
(More inclusive classes listed first.)
\par
\begin{tabular}{|lll|}
\hline
{\bf Class} & {\bf Complete Problem} & {\bf Reduction} \\
\hline

\exptime & \nregexp 	& $\lep$ \\
\pspace  & \tqbf 		& $\lep$ \\
\np	 & \threesat	& $\lep$ \\
\p	 & \cvp		& $\lel$ \\
\nl	 & \stconn	& $\lel$ \\
\lspace	 & \ispath	& $\lel$ \\
\hline
\end{tabular}
\par

In addition, $\p \subset \bpp \subset \pspace$. $\p \neq \exptime$ and $\nl 
\neq \pspace$ are give by the time and space hierarchy theorems:

\begin{theorem}[Time Hierarchy Theorem] If $f(n) = o(g(n)/\lg(n))$, and
$f$, $g$ are ``well-behaved'', then $\ti(f(n)) \not \subseteq \ti(g(n))$.
\end{theorem}

\begin{theorem}[Space Hierarchy Theorem] If $f(n) = o(g(n))$, and
$f$, $g$ are ``well-behaved'', then $\spa(f(n)) \not \subseteq \spa(g(n))$.
\end{theorem}

Thus, either $\hbox{L} \neq \p$ or $P \neq \pspace$ (or both). But we haven't
been able to prove either.

\section{P-Completeness and the Circuit Value Problem (CVP)}



A language $L$ is said to be {\sl P-complete} under {\sl logspace mapping
reductions} if:

\begin{enumerate}


\item $L \in P$
\item For all languages $A \in P,$ there exists a logspace bounded Turing
Machine with a read-only input tape, a write-only output tape, and a
read/write work tape, that 
computes a function $f$ such that: $x \in A \Longleftrightarrow f(x) \in L$. 
\end{enumerate}

One reason why we are interested in P-complete problems is that we
believe they are difficult to compute on a parallel machine.  There
are many known P-complete problems.  We will be interested in the {\sl
Circuit Value Problem (CVAL)}.  In the Circuit Value Problem, we are
given both the description of a circuit and inputs to the circuit, and
we are asked to determine the output of the circuit on those
particular inputs.\footnote{We are concerned only with
``feed-forward'' circuits here: consider a directed acyclic graph with
many inputs and one output, where the nodes are typical boolean logic
gates. A given input $<D,\bar{x}> \in \cvp$ just if $D$ is the
description of a circuit and $\bar{x}$ is an appropriately long binary
input string such that the output wire of $D$ will output 1 on input
$\bar{x}$.}  It's not hard to see that this can be done in polynomial
time.  We conjecture, however, that it's hard to come up with an
efficient parallel solution.

We will now argue that the CVAL is P-complete under logspace
reductions.  The following argument is meant to be a proof sketch, and
is by no means rigorous.  First of all, it's not hard to see that the
problem is in \p. Suppose we are given $<D,\bar{x}>$, where $D$ is some
reasonable description of a circuit (say, a list of circuit types,
input and output wires), and $\bar{x}$ is input to that circuit. Then
we can simulate the activity of each gate directly by at each step
selecting one gate for which all inputs have been calculated, and
recording it's output. We can certainly calculate the value of the
output wire in polynomial time.

Now, we must show that for every polynomial time bounded TM $M$, we can 
construct a logspace computable function $f$ that takes as input 
$\bar{x}$ and outputs a circuit $C$ and an assignment to the inputs $\bar{y}$
such that $C(\bar{y})$ accepts if and only if $M$ accepts $\bar{x}$ (in polynomial time).   Our construction will be similar to the Cook-Levin construction for the
NP-completeness of SAT.  

Let $t(n)$ be a bound on the running time of $M$.  Assume without loss
of generality, that when $M$ is about to accept (reject), it erases
its tape, moves its read head all the way to the left, and enters its
accept (reject) state. Moreover, $M$ will continue to stay in the same
configuration until it has executed $t(n)$ steps. To complete the
proof, it is sufficient to specify a logspace TM that outputs a
circuit which simulates this $t(n)*t(n)$ tableau. Note that the
tableau as a whole is much too big to fit in the memory of our
logspace machine. However, it turns out that the structure of the
circuit is highly repetitive. All we need to keep in memory is a
pointer into the tableau, which is possible in logspace.

To see this in a little more detail, consider one cell. The
information for the cell in the tableau can be represented with a set
of wires: One wire for each combination of tape symbol and machine
state (representing the state of the machine when the head is not
present. We add one ``state symbol'' to represent the absence of the
head.) Only one of this set of wires can be on at any time. The values
of the wires in the cell can be determined from the values of the
wires in the circuits representing the three cells just above. Other
than changes in the numbers to connect wires, the circuitry to simulate
the cell is constant.  Since all of the numbering needed to output
this circuit is local, the machine can operate with a constant number
of pointers into the tableau in memory. It completes its task by
duplicating the circuitry for a cell $t^2(n)$ times.\footnote{Of
course, we need to fix up this algorithm for the boarders.}.

\section{Final Note}

$\nspace(t(n))\subseteq \spa (t^2(n))$ because $\nspace (t(n)) =
\conspace (t(n))$. Proof next time, perhaps.

 

\end{document}


