Space Complexity (PowerPoint) by gegeshandong


									Space Complexity

Let M be a deterministic Turing Machine that halts on
  all inputs.
Space Complexity of M is the function f:NN, where
  f(n) is the maximum number of tape cells that M
  scans on any input of length n.
Let f :NN be a function.
SPACE(f(n))={L | L is a language decided by an O(f(n))
  space DTM}
NSPACE(f(n))={L | L is a language decided by an
  O(f(n)) space NTM}

   Eg.
SAT is NP-complete.
SAT can be solved in linear(O(m)) space.
M1=“On input <>, where  is a Boolean formula:
1.  For each truth assignment to the variables x1,…xm of
2.  Evaluate  on that truth assignment.
3.  If  ever evaluate to 1, ACCEPT; if not, REJECT.”
    x1 x2 x3   …   xn
     0 0 0     …    0

   Let ALLNFA={<A> | A is a NFA and L(A)=*}
ALLNFA can be decided in nondeterministic linear space,
    but not known to be in NP or co-NP.
N=“On input <M> where M is an NFA:                 Why 2q ?
1.  Place a marker on the start state of the NFA.
2.  Repeat 2q times, where q is the number of states of
3.     Non-deterministically select an input symbol
       and change the positions of the markers on M’s
       states to simulate reading that symbol.
1.  Accept if Stages 2 and 3 reveal some string that M
    rejects, that is, if at some point none of the
    markers lie on accept states of M. Otherwise,
    reject. “
 Savitch’s Theorem(1970):
For any function f:NN, where f(n)n,
N: an non-deterministic TM deciding a language A in
   space f(n).

Goal: Construct a det TM M deciding A in space f2(n).

Let  be an input string to N.
t: integer;
c1,c2: configurations of N on .

CANYIELD(c1,c2,t) accept if starting from c1 N has a
   branch entering configuration c2 in t steps; o/w
CANYIELD=“On input c1,c2 and t:
1. If t=1, test whether c1=c2 or c1├ c2, then accept;
   else reject.
2. If t>1, then for each configuration cm of N on 
   using space f(n).
                           t 
3. Run CANYIELD(c1,cm,  2  )
                           t 
4. Run CANYIELD(cm,c2,  2  )
5. If 3 & 4 both accept, then accept; else reject.”

caccept: accept configuration.
cstart: start configuration of N on .
Select a constant d so that N has no more than 2df(n)
   configurations using f(n) tape space, n=|  |.
M=“On input 
output the result of CANYIELD(cstart, caccept, 2df(n)).”
CANYIELD is a recursive procedure:
• Recursive depth:log22

• Each recursive call of CANYIELD use O(f(n)) space.

• Thus, it uses O(f (n)) space.

   PSPACE is the class of languages (or problems) that
    are decidable in polynomial space on a det. TM.



Def: (PSPACE completeness)
A language (or problem) B is PSPACE-complete if it satisfies
     2 conditions:
(1)  B is in PSPACE, and
(2)  Every A in PSPACE is poly-time reducible to B.
 : universal quantifier,          x [ x  1  x ]

 : existential quantifier,        y [ y  y  3]
xy [ y  x ]        ( )     yx [ y  x ]   ()

 = xy [( x  y )  ( x  y )]
    ~quantified Boolean formula
    ~fully quantified Boolean formula

TQBF: given a fully quantified Boolean formula, is
      it true?
Thm: TQBF is PSPACE-complete.
     TQBF is in PSPACE:
T=“On input : a fully quantified Boolean formula:
 1) If  has no quantifier, then it is an expression
      with only constants, so evaluate  and
      accept if it is true; otherwise reject.

2)   If  =x, recursively call T on , first with x=0,
     and then x=1. If either result is accept, then
     accept; o/w reject.
3)   If  =x, recursively call T on  with x=0, and
     x=1. If both results are accept, then accept; o/w

     TQBF is PSPACE-hard:
Let A be a language decided by a TM M in space nk for
      some constant k.
Show ApTQBF.

 M accepts  iff  is true.
 c1,c2: configurations, t: integer;       f          
 Construct a formula  c1,c2,t

 = Cstart,Caccept,h, h=2df(n).
  c1,c2,t=m1,(c3,c4){(c1,m1),(m1,c2)} [c3,c4,t  ]
                                                   

Configuration size: O(f(n))
Recursion depth: lg2df(n)=O(f(n))
                                      x {y, z}[...] 
Formula size: O(f2(n))

c1,c2,t=m, [c1,m,  2t   m,c2,  2t  ]
                                       

What is the formula size?

Winning Strategies for games:
  =x1 x2 x3…Qxk[]
Q represents either a  or an  quantifier.
Two players: player A; player E.
Take turns selecting the values of x1,…, xk.
• Player A selects values for the variables that are
  bound to .
• Player E selects values for the variables that are
  bound to .
• Player E wins, if  is TRUE.

• Player A wins, if  is FALSE.

 Let 1 =x1 x2 x3[(x1 x2)  (x2  x3)  (x2
Player E has a winning strategy.
         x2  0, x3  1
x1  1,                  1  TRUE.
         x2  1, x3  0
 Let 2 =x1 x2 x3[(x1 x2)  (x2  x3)  (x2
Player A has a winning strategy.

   FORMULA-GAME={<> | player E has a
    winning strategy in the formula game
    associated with }.

 Thm: FORMULA-GAME is PSPACE-complete.
TQBF exactly when FORMULA-GAME.

Geography Game:

     Generalized geography:(GG)

 Player 1: moves first.

 Player 2: moves second.

Player 1 has a winning strategy:
Starts at node 1,
Player 1 choose 3
Player 2 choose 5
Player 1 choose 6
Player 2 cannot move anywhere
Thus, player 1 wins.

   GG={<G,b> | player 1 has a winning strategy for
    the generalized geography game played on graph
    G starting at node b.}
   Thm: GG is PSPACE-complete.
M=“On input <G,b>, G: directed graph; b: a node of G.
0. REJECT if b has no outgoing edge.
1. Remove node b and all arrows touching it to get a
     new graph G1.
2. For each of the nodes b1,b2,…,bk that b originally
     pointed at, recursively call M on <G,bi>.
3. If all of these accept, player 2 has a winning strategy
     in the original game, so REJECT. O/w player 2
     doesn’t have a winning strategy, so player 1 has,
     thus ACCEPT. “                                       18
   The only space required is for storing the
    recursion stack.

   The level of recursion can be at most m,
    which is the number of node in G.

Each level uses poly. Space, thus in total M
  uses poly. space.

 Next need to show GG is PSPACE-hard:
  =x1 x2 x3…Qxk
                             In conjunctive
              p             normal form.

• Player 1 in GG ~ player E in formula game.

• Player 2 in GG ~ player A in formula game.

 =x1 x2 …Qxk[(x1 x2 x3)  (x2 x3… ) … (…)]

                    For simplicity, let Q=

    If  is FALSE, player 2 may win by selecting
     the unsatisfied clause.
    Then any literal that player 1 may pick is
     FALSE and is connected to the side the
     diamond that hasn’t been played.
    Thus player 2 may choose the node in the
     diamond, then player 1 cannot move and

 If  is TRUE, any clause that player 2 picks
  contains a TRUE literal.
 Player 1 choose that TRUE literal.

∵it is true, ∴ it is connected to the side of the
  diamond that has been chosen.
So, player 2 cannot move and lose.

 The class of L and NL
L=SPACE(log n)
NL=NSPACE(log n)
PATH={<G,s,t> | G is a directed graph that has
  a directed path from s to t}.
PATH: Given a directed graph G and two
  vertices s and t, is there a directed path from
  s to t?

   Def: If M is a TM:

                        read only input tape
      M                  working tape

A configuration of M on  is a setting of the
state, work tape, and the position of the tape

If M runs in f(n) space on , ||=n, then the number of
   configurations of M on  is:
           gf(n)•f(n) •c •n  2O(f(n))
 Possibl                           Head position of
 e work     State       Possible   input head.
 tape.      position.   state.

c: state number.                                      f(n)

g: number of tape symbol

Savitch’s theorem is true for f(n)lgn;
note that the definition of configurations
 is different for small space case. But the
 proof is the same.

NL-completeness: NL=?L
    Def: (log space reducibility)
1)   A log space transducer is a TM with (1) a
     read–only input tape (2) a write-only
     output tape (3) a read/write work tape.
                             May contain O(logn) symbols.

2)   A log space transducer M computes a
     function f:**, where f(n) is the string
     remaining on the output tape after M halts
     when it starts with  on input tape. f is
     called log space computable function.
3)   ALB, if A is mapping reducible to B by
     using a log space computable function.
Def: A language B is NL-complete if
1.  BNL and
2.  Every A in NL is log space reducible to B.

Thm: If A LB and B L then AL.

Cor: If any NL-complete language is in L then

    Thm: PATH is NL-complete.
  Pf:
It has been shown in class that PATHNL.
Need to show that for any ANL, ALPATH.
Let M be a NTM that decides A in O(log n) space.
   Given an input , construct a graph G and 2
   vertices s and t in log space, where G has a
   directed path from s to t iff M accepts .
V(G): configurations of M on .
(c1,c2)E(G) if c1├ c2.
s: start configuration, t: accept configuration.
 Need to show that reduction operates in log
  space. I.e. need to describe G’s vertices and
  edges in log space.
 Each configuration needs c logn space, for
  some constant c.
 Try all c logn bit string and test with M on 

  to see if it is a legal configuration, if yes, put
  it into vertex set.
For any c1, c2, test if c1├ c2 with M on .

        Takes O(log n) space.
   Cor: NL P.
PATH P  NLP (?)

   co-NL = {B : B is in NL}
    B = {x : x B }

   Thm: NL = co-NL.

     Thm: NL = co-NL.

1.   Robert Szelepcs’enyi, “The method of forcing
     for nondeterminitic automata,” Bull of the
     EATCS, 33, p.96-100, 1987.

2.   N. Immerman, “Nondeterministic space is
     closed under complementation,“ SIAM J. on
     computing 17, p.935-938, 1988 .

       Gödel award.

 Thm: NL = co-NL.

PATH is NL-complete  PATH  co-NL.
If <G,s,t> PATH, then there is no directed path
   in G from s to t.
 Every A co-NL has ALPATH.

The rest shows PATH NL.

     M=“On input G, s, t:
1.    c0=1                           /* counter */
2.    For i=0 to m-1              /* m=#of vertex */
3.      ci+1=0
4.      d=0
5.      For each node v in G
6.         ••For each node u in G
7.           Non-det. Either skip or perform the following steps:
8.             • Non-det. Follow a path of length i from s, and if
                 non of the nodes met are u, reject.
9.             • Increase d.
10.            • If (u,v) E(G), then increase ci+1 and goto 6
                         with next v.
11.       ••If dci, then reject.
12.   For each node u in G
13.   Non-det., either skip or perform these steps:
14.      •nondeterminitically follow a path of length i from s
             and if none of the nodes met are u, reject.
15.      •If u=t, then reject.
16.      •Increase d.
17.   If dcm, then reject, otherwise accept.”
•       The algorithm needs to store ci, d, i, j and a pointer to the
        head of a path . Thus, it runs in log space.

         Ai={u : u is reachable from s within i steps.}
         Ci=|Ai|, s•             AiAi+1.
Nondeterminitic Space is Closed under Complement


•   Robert Szelepcse’nyi: “The method of forcing
    for nondeterministic automaya,” Bull of the
    EATCS, 33, p. 96-100, 1987.

•   N. Immerman: “Nondeterministic space in
    closed under complementation,” SIAM J. on
    computing, 17, p. 935-938, 1988.

   M: a nondeterminitic S(n)-bounded-space TM.
   Each configuration of M can be described in

   c0: Initial configuration of M.

 RchM,x(t):
The number of configurations reachable by
  computation on input x in at most t steps
  starting at c0.

    M0: Input: x, n, t, u;
          accept if u is reachable in t=1 steps.
1.   m:=0
2.   for each configuration v of M do
        • non-det simulate M on x during at most t
     steps, checking if v is reached.
        • if so, then
             if M on input x goes from v to u then accept.
3.   if m=n then reject
     else abort by halting in a nonfinal state.

    M1: Input: x;
n:=1; t:=0;
for t from 1 to t(|x|) do
    for each configuration u do
        if u is reachable from c0 in t+1 steps
        then m:=m+1
                             Call M0(x,n,t,u)

•  n is RchM,x(t) for each t.
Thm: If S(n)log n and S is space constructible
   then NSPACE(S) is closed under
Call M1 on x to compute RchM,X(t|x|).
For each configuration u call M0 on
If No accepting configuration accessible, then
     Input: M, s, x.
     Compute initial conf. C0.                   NTM accept
for each conf. C do
     if C0├ 1C then I1:=I1+1;
D:=I1; K:=1;
                                              I1: Rch(k-1)
While K<2S(n)
                                              I2: Rch(k)
{ I2:=0 ;
   for each conf. C2 do
  { I1:=0;
      for each conf. C1 do
     { guess path C0├ K C1;
        if  a correct path, I1++;
        if C1├ 1 C2 then
          { if C2 is accept conf., STOP & REJECT; else { I2++; exit inner
     loop;} }
      if I1D, then STOP;
   if (D=I2) then ACCEPT; else K++; D:=I2;                                  42

To top