February 19, 2008

* Review of Savitch's Theorem
* Immerman-Szelepcsenyi Theorem

REVIEW OF SAVITCH'S THEOREM

-- Definition of space complexity
-- Space constructibility assumption
-- Configurations
-- Configuration graph
-- Directed s-t connectivity problem in configuration graph
-- Recursion with small space

IMMERMAN-SZELEPCSENYI THEOREM

Theorem: For all S(n) >= log(n), NSPACE(S(n)) = co-NSPACE(S(n)).

Proof: As in the case of Savitch's Theorem, we will first assume that
S(n) is space-constructible.  In order to prove NSPACE(S(n)) =
co-NPSACE(S(n)), given a space S(n) NDTM M for a language L, we need
to construct a space S(n) NDTM N for language ~L.  Thus, given x in L,
M uses space S(n) and there is a branch that accepts x.  Given x not
in L, we need N to have a branch that accepts x.  How to certify that
x is not in L?

Let x be of length n.  The idea is to first compute the size of (L
intesection Sigma^n), then nondeterministically guess the elements of
this intersection and verify one by one that their membership.  If the
verification succeeds, then x cannot be in L.  There are two
challenges: how to compute the size of the intersection?  how to
verify the membership and do all the computations in S(n).

As usual, we define a configuration for TM M to be the tuple
determined by its state, contents of worktape, and positions of the
two heads -- tape and input.  There are 2^{O(S(n))} such
configurations.  As in the proof of Savitch's theorem, we can assume a
unique accept configuration.  So to decide whether a given x is in L,
we have a configuration graph G and we decide whether there exists a
path from start to accept in this graph.

In the configuration graph G, we have 2^{O(S(n))} nodes.  Thus, if x is
in L, then there is a path with at most 2^{O(S(n))} nodes from start
to accept.  

Define A_m = {a is in G: start reaches a in at most m hops}

Thus, M accepts x iff accept is in A_{2^{O(S(n))}}.

The machine N inductively computes |A_0|, |A_1|, |A_2|, ...,
|A_{|G|}|.  After |A_{|G|}| has been computed, N nondeterministically
guesses the configurations in A_{|G|} in lexicographic order -- each
configuration requires O(S(n)) space.  Note that after each guess, it
can mark down the number of remaining guesses.  For each such
configuration C, it verifies that C is reachable from start in
2^{O(S(n))} steps, and C is different from accept.  How?  For the
former, it guesses the computation path and verifies that C is indeed
the final configuration.  If all of these have been verified, then N
accepts x.

It remains to show how to compute |A_m|.  |A_0| = 1.  Suppose |A_m|
has been computed.  We now compute |A_{m+1}|.  We first write down
|A_m|.  This takes space O(S(n)).  We guess each of the configurations
one by one in lexicographic order (like we did in the above para).
For each configuration C that we write down, we guess each of the
potential predecessor configurations C' (in A_m) one by one.  Verify
C' is in A_m and then verify is C' yields C.  How do you verify C' is
in A_m?  Guess the computation path of length at most m from start,
and verify that C' is indeed the final configuration in this path.

To remove the space constructibility condition, we repeat the above
for S = 1, 2, ....  While doing the computation for S, if we ever find
a reachable configuration from S that needs space S+1, we restart with
S = S + 1.

End Proof