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
0 0 0
…
…
xn
0
3
Let ENFA={<A> | A is a NFA and L(A)=}
Eg.
ENAF can be decided in nondeterministic linear space.
N=“On input <M> where M is an NFA:
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.
Nondeterministically select an input symbol and
change the positions of the markers on M’s states
to simulate reading that symbol.
4.
If a marker was ever placed on an input state,
Reject; otherwise ACCEPT. “
4
Savitch’s Theorem:
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:
df(n)=O(f(n))
• Recursive depth:log22
• Each recursive call of CANYIELD use O(f(n)) space.
2
• Thus,it uses O(f (n)) space.
7
PSPACE is the class of languages (or problems) that are
decidable in polynomial space on a det. TM.
k).
PSPACE= 
SPACE(n
k
Thm:
n
PNP  PSPACE=NPSPACE EXPTIME= 
TIME(
)
2
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:
I.
TQBF is in PSPACE:
T=“On input : a fully quantified Boolean formula:

If  has no quantifier, then it is an expression
with only constants, so evaluate  and accept
if it is true; otherwise reject.
10
2)
3)
If  =x, recursively call T on , first with x=0,
and then x=1. If either result is accept, then
accept; o/w reject.
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.
II.
11
M accepts  iff  is true.
f
 c1,c2: configurations.


 t: integer;  c1,c2,t: a formula.
 = 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))
Formula size: O(f2(n))

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: FIRMULA-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 interal 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:
M

read only input tape
working tape
A configuration of M on  is a setting of the
state, work tape, and the position of the tape
heads.
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
e work
tape.
State
position.
Possible
state.
Head position of
input head.
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

1)
Def: (log space reducibility)
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)
3)
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.
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.
2.
Robert Szelepcs’enyi, “The method of forcing
for nondeterminitic automata,” Bull of the
EATCS, 33, p.96-100, 1987.
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

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
M=“On input G, s, t:
c0=1
/* counter */
For i=0 to m-1
/* m=#of vertex */
ci+1=0
d=0
For each node v in G
••For each node u in G
Non-det. Either skip or perform the following steps:
• Non-det. Follow a path of length i from s, and if
non of the nodes met are u, reject.
• Increase d.
• If (u,v) E(G), then increase ci+1 and goto 6
with next v.
••If dci, then reject.
35
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.
12.
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

1.
2.
3.
M0: Input: x, n, t, u;
accept if u is reachable in t=1 steps.
m:=0
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.
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;
I1: Rch(k-1)
D:=I1; 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
}