# Space Complexity (PowerPoint) by gegeshandong

VIEWS: 7 PAGES: 42

• pg 1
```									Space Complexity

1
Def:
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.
Def:
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}

2
   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

3
Let ALLNFA={<A> | A is a NFA and L(A)=*}
Eg.
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
M.
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. “
4
Savitch’s Theorem(1970):
For any function f:NN, where f(n)n,
NSPACE(f(n))SPACE(f2(n)).
pf:
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 .

5
CANYIELD(c1,c2,t) accept if starting from c1 N has a
branch entering configuration c2 in t steps; o/w
rejects.
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.”

6
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
df(n)=O(f(n))

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

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

7
   PSPACE is the class of languages (or problems) that
are decidable in polynomial space on a det. TM.
PSPACE=  SPACE(nk).
k

Thm:
PNP  PSPACE=NPSPACE EXPTIME=  TIME( 2n )
k

k

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.
8
 : 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

9
TQBF: given a fully quantified Boolean formula, is
it true?
Thm: TQBF is PSPACE-complete.
pf:
     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.

10
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
reject.”

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

11
 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  ]

2
 

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

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

What is the formula size?

12
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.

13
Eg.
 Let 1 =x1 x2 x3[(x1 x2)  (x2  x3)  (x2
x3)]
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
x3)]
Player A has a winning strategy.

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

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

15
Geography Game:

16
Generalized geography:(GG)

Eg.
 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.

17
   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.
Pf:
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.

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

<G,b>
• Player 1 in GG ~ player E in formula game.

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

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

For simplicity, let Q=

21
1)
    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
lose.

22
2)
 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.

23
 The class of L and NL
L=SPACE(log n)
NL=NSPACE(log n)
Eg.
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?

24
   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

25
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

26
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.

27
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.
28
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
L=NL.

29
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.
30
 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.
31
   Cor: NL P.
PATH P  NLP (?)

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

   Thm: NL = co-NL.

32
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.

33
Thm: NL = co-NL.

pf:
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.

34
     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.
35
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.
36
Nondeterminitic Space is Closed under Complement

   NSPACE = co-NSPACE.
   LNSPACE  Lco-NSPACE.

•   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.

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

   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.

38
    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
m:=m+1
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.

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

40
•  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
complementation.
pf:
Call M1 on x to compute RchM,X(t|x|).
For each configuration u call M0 on
<x,n,t(|x|),u>.
If No accepting configuration accessible, then
accept.
41
Input: M, s, x.
Compute initial conf. C0.                   NTM accept
L(M).
I1:=0;
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