Complexity ©D.Moshkovits 1 Space Complexity Complexity ©D.Moshkovits 2 Motivation Complexity classes correspond to bounds on resources One such resource.

Slides:



Advertisements
Similar presentations
Part VI NP-Hardness. Lecture 23 Whats NP? Hard Problems.
Advertisements

Based on Powerpoint slides by Giorgi Japaridze, Villanova University Space Complexity and Interactive Proof Systems Sections 8.0, 8.1, 8.2, 8.3, 10.4.
1 Savitch and Immerman- Szelepcsènyi Theorems. 2 Space Compression  For every k-tape S(n) space bounded offline (with a separate read-only input tape)
1 Nondeterministic Space is Closed Under Complement Presented by Jing Zhang and Yingbo Wang Theory of Computation II Professor: Geoffrey Smith.
Complexity Theory Lecture 3 Lecturer: Moni Naor. Recap Last week: Non deterministic communication complexity Probabilistic communication complexity Their.
INHERENT LIMITATIONS OF COMPUTER PROGRAMS CSci 4011.
1 Space Complexity. 2 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)
Giorgi Japaridze Theory of Computability Savitch’s Theorem Section 8.1.
Department of Computer Science & Engineering
Fall 2013 CMU CS Computational Complexity Lecture 5 Savich’s theorem, and IS theorems. These slides are mostly a resequencing of Chris Umans’ slides.
Umans Complexity Theory Lectures Lecture 4b: Nondeterministic Space: I-S Theorem: NL = coNL.
NL equals coNL Section 8.6 Giorgi Japaridze Theory of Computability.
CSCI 4325 / 6339 Theory of Computation Zhixiang Chen.
Dana Moshkovitz. Back to NP L  NP iff members have short, efficiently checkable, certificates of membership. Is  satisfiable?  x 1 = truex 11 = true.
Having Proofs for Incorrectness
INHERENT LIMITATIONS OF COMPUTER PROGRAMS CSci 4011.
Complexity 12-1 Complexity Andrei Bulatov Non-Deterministic Space.
Complexity 15-1 Complexity Andrei Bulatov Hierarchy Theorem.
Complexity 11-1 Complexity Andrei Bulatov Space Complexity.
Computability and Complexity 22-1 Computability and Complexity Andrei Bulatov Hierarchy Theorem.
Complexity 13-1 Complexity Andrei Bulatov Hierarchy Theorem.
Complexity 18-1 Complexity Andrei Bulatov Probabilistic Algorithms.
Computability and Complexity 19-1 Computability and Complexity Andrei Bulatov Non-Deterministic Space.
Complexity ©D.Moshkovitz 1 Turing Machines. Complexity ©D.Moshkovitz 2 Motivation Our main goal in this course is to analyze problems and categorize them.
1 Mazes In The Theory of Computer Science Dana Moshkovitz.
Randomized Computation Roni Parshani Orly Margalit Eran Mantzur Avi Mintz
1 Slides by Gil Nadel & Lena Yerushalmi. Adapted from Oded Goldreich’s course lecture notes by Amiel Ferman, Noam Sadot, Erez Waisbard and Gera Weiss.
Submitted by : Estrella Eisenberg Yair Kaufman Ohad Lipsky Riva Gonen Shalom.
Computability and Complexity 20-1 Computability and Complexity Andrei Bulatov Class NL.
Complexity 1 The Padding Argument. Complexity 2 Motivation: Scaling-Up Complexity Claims space + non-determinism We have: space + determinism can be simulated.
Non Deterministic Space Avi Ben Ari Lior Friedman Adapted from Dr. Eli Porat Lectures Bar-Ilan - University.
1 Slides: Asaf Shapira & Oded Schwartz; Sonny Ben-Shimon & Yaniv Nahum. Sonny Ben-Shimon & Yaniv Nahum. Notes: Leia Passoni, Reuben Sumner, Yoad Lustig.
Alternating Turing Machine (ATM) –  node is marked accept iff any of its children is marked accept. –  node is marked accept iff all of its children.
Complexity 1 Mazes And Random Walks. Complexity 2 Can You Solve This Maze?
1 Slides: Asaf Shapira & Oded Schwartz; Sonny Ben-Shimon & Yaniv Nahum. Sonny Ben-Shimon & Yaniv Nahum. Notes: Leia Passoni, Reuben Sumner, Yoad Lustig.
Non-Deterministic Space is Closed Under Complementation Neil Immerman Richard Szelepcsenyi Presented By: Subhajit Dasgupta.
INHERENT LIMITATIONS OF COMPUTER PROGRAMS CSci 4011.
Definition: 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.
February 18, 2015CS21 Lecture 181 CS21 Decidability and Tractability Lecture 18 February 18, 2015.
Computational Complexity Theory Lecture 2: Reductions, NP-completeness, Cook-Levin theorem Indian Institute of Science.
Theory of Computing Lecture 17 MAS 714 Hartmut Klauck.
CSCI 2670 Introduction to Theory of Computing November 29, 2005.
Theory of Computing Lecture 21 MAS 714 Hartmut Klauck.
Fall 2013 CMU CS Computational Complexity Lecture 2 Diagonalization, 9/12/2013.
Complexity 24-1 Complexity Andrei Bulatov Interactive Proofs.
Complexity ©D.Moshkovits 1 2-Satisfiability NOTE: These slides were created by Muli Safra, from OPICS/sat/)
Homework 8 Solutions Problem 1. Draw a diagram showing the various classes of languages that we have discussed and alluded to in terms of which class.
CSCI 2670 Introduction to Theory of Computing December 2, 2004.
Complexity ©D.Moshkovitz 1 Our First NP-Complete Problem The Cook-Levin theorem A B C.
Theory of Computational Complexity Yuji Ishikawa Avis lab. M1.
The NP class. NP-completeness Lecture2. The NP-class The NP class is a class that contains all the problems that can be decided by a Non-Deterministic.
Chapter 7 Introduction to Computational Complexity.
Space Complexity Guy Feigenblat Based on lecture by Dr. Ely Porat Complexity course Computer science department, Bar-Ilan university December 2008.
 2005 SDU Lecture14 Mapping Reducibility, Complexity.
Space Complexity Complexity ©D.Moshkovits.
Goal: Plan: Explore space complexity Low space classes: L, NL
Part VI NP-Hardness.
Umans Complexity Theory Lectures
Where Can We Draw The Line?
Theory of Computational Complexity
CSC 4170 Theory of Computation Space complexity Chapter 8.
Theory of Computability
Part II Theory of Nondeterministic Computation
S P A C E In this presentation we take a closer look at complexity classes in which the bound is on the amount of memory it takes to compute the problem.
Our First NP-Complete Problem
Reductions Complexity ©D.Moshkovitz.
Instructor: Aaron Roth
CS151 Complexity Theory Lecture 4 April 12, 2019.
Intro to Theory of Computation
CS151 Complexity Theory Lecture 4 April 8, 2004.
Presentation transcript:

Complexity ©D.Moshkovits 1 Space Complexity

Complexity ©D.Moshkovits 2 Motivation Complexity classes correspond to bounds on resources One such resource is space: the number of tape cells a TM uses when solving a problem

Complexity ©D.Moshkovits 3 Introduction Objectives: –To define space complexity classes Overview: –Space complexity classes –Low space classes: L, NL –Savitch’s Theorem –Immerman’s Theorem –TQBF

Complexity ©D.Moshkovits 4 Space Complexity Classes For any function f:N  N, we define: SPACE(f(n))={ L : L is decidable by a deterministic O(f(n)) space TM} NSPACE(f(n))={ L : L is decidable by a non-deterministic O(f(n)) space TM}

Complexity ©D.Moshkovits 5 Low Space Classes Definitions (logarithmic space classes): L = SPACE(logn) NL = NSPACE(logn)

Complexity ©D.Moshkovits 6 Problem! How can a TM use only logn space if the input itself takes n cells?! !?

Complexity ©D.Moshkovits 7 3Tape Machines aababb_... bbbbb__ baaba__ input work output read- only write- only read/ write Only the size of the work tape is counted for complexity purposes

Complexity ©D.Moshkovits 8 Example Question: How much space would a TM that decides {a n b n | n>0} require? Note: to count up to n, we need logn bits

Complexity ©D.Moshkovits 9 Graph Connectivity CONN Instance: a directed graph G=(V,E) and two vertices s,t  V Problem: To decide if there is a path from s to t in G? An undirected version is also worth considering

Complexity ©D.Moshkovits 10 Graph Connectivity s t

Complexity ©D.Moshkovits 11 CONN is in NL Start at s For i = 1,.., |V| { –Non-deterministically choose a neighbor and jump to it –Accept if you get to t } If you got here – reject! Counting up to |V| requires log|V| space Storing the current position requires log|V| space

Complexity ©D.Moshkovits 12 Configurations The content of the work tape The machine’s state The head position on the input tape The head position on the work tape The head position on the output tape Which objects determine the configuration of a TM of the new type? If the TM uses logarithmic space, there are polynomially many configurations

Complexity ©D.Moshkovits 13 Log-Space Reductions Definition: A is log-space reducible to B, written A  L B, if there exists a log space TM M that, given input w, outputs f(w) s.t. w  A iff f(w)  B the reduction

Complexity ©D.Moshkovits 14 Do Log-Space Reductions Imply what they should? Suppose A 1 ≤ L A 2 and A 2  L; how to construct a log space TM which decides A 1 ? Wrong Solution: w f(w) Use the TM for A 2 to decide if f(w)  A 2 Too Large!

Complexity ©D.Moshkovits 15 Log-Space reductions Claim: if 1. A 1 ≤ L A 2 – f is the log-space reduction 2. A 2  L – M is a log-space machine for A 2 Then, A 1 is in L Proof: on input x, in or not-in A 1 : Simulate M and whenever M reads the i th symbol of its input tape run f on x and wait for the i th bit to be outputted

Complexity ©D.Moshkovits 16 NL Completeness Definition: A language B is NL-Complete if 1. B  NL 2. For every A  NL, A  L B. If (2) holds, B is NL-hard

Complexity ©D.Moshkovits 17 Savitch’s Theorem Theorem:  S(n) ≥ log(n) NSPACE(S(n))  SPACE(S(n) 2 ) Proof: First we’ll prove NL  SPACE(log 2 n) then, show this implies the general case

Complexity ©D.Moshkovits 18 Savitch’s Theorem Theorem: NSPACE(logn)  SPACE(log 2 n) Proof: 1.First prove CONN is NL-complete (under log-space reductions) 2.Then show an algorithm for CONN that uses log 2 n space

Complexity ©D.Moshkovits 19 CONN is NL-Complete Theorem: CONN is NL-Complete Proof: by the following reduction: LL s t “Does M accept x?” “Is there a path from s to t?”

Complexity ©D.Moshkovits 20 Technicality Observation: Without loss of generality, we can assume all NTM’s have exactly one accepting configuration.

Complexity ©D.Moshkovits 21 Configurations Graph A Computation of a NTM M on an input x can be described by a graph G M,x : st (u,v)  E if M can move from u to v in one step A vertex per configuration the start configuration the accepting configuration

Complexity ©D.Moshkovits 22 Correctness Claim: For every non-deterministic log- space Turing machine M and every input x, M accepts x iff there is a path from s to t in G M,x

Complexity ©D.Moshkovits 23 CONN is NL-Complete Corollary: CONN is NL-Complete Proof: We’ve shown CONN is in NL. We’ve also presented a reduction from any NL language to CONN which is computable in log space (Why?) 

Complexity ©D.Moshkovits 24 A Byproduct Claim: NL  P Proof: Any NL language is log-space reducible to CONN Thus, any NL language is poly-time reducible to CONN CONN is in P Thus any NL language is in P. 

Complexity ©D.Moshkovits 25 What Next? We need to show CONN can be decided by a deterministic TM in O(log 2 n) space.

Complexity ©D.Moshkovits 26 The Trick u v... “Is there a path from u to v of length d?”“Is there a vertex z, so there is a path from u to z of size  d/2  and one from z to v of size  d/2  ?” d z  d/2  d/2 

Complexity ©D.Moshkovits 27 Recycling Space The two recursive invocations can use the same space

Complexity ©D.Moshkovits 28 The Algorithm Boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if d=1 return FALSE for every vertex v { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } }

Complexity ©D.Moshkovits 29 Example of Savitch’s algorithm (a,b,c)=Is there a path from a to b, that takes no more than c steps. 3Log 2 (d) boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } (1,4,3) (1,4,3)(1,2,2) (1,4,3)(1,2,2)TRUE (1,4,3)(2,4,1) (1,4,3)(2,4,1)FALSE (1,4,3)(1,3,2) (1,4,3)(1,3,2)(1,2,1) (1,4,3)(1,3,2)(1,2,1)TRUE (1,4,3)(1,3,2)(2,3,1) (1,4,3)(1,3,2)(2,3,1)TRUE (1,4,3)(1,3,2)TRUE (1,4,3)(3,4,1) (1,4,3)(3,4,1)TRUE (1,4,3) TRUE boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE } boolean PATH(a,b,d) { if there is an edge from a to b then return TRUE else { if (d=1) return FALSE for every vertex v (not a,b) { if PATH(a,v,  d/2  ) and PATH(v,b,  d/2  ) then return TRUE } return FALSE }

Complexity ©D.Moshkovits 30 O(log 2 n) Space DTM Claim: There is a deterministic TM which decides CONN in O(log 2 n) space. Proof: To solve CONN, we invoke PATH(s,t,|V|) The space complexity: S(n)=S(n/2)+O(logn)=O(log 2 n) 

Complexity ©D.Moshkovits 31 Conclusion Theorem: NSPACE(logn)  SPACE(log 2 n) How about the general case NSPACE(S(n))  SPACE(S 2 (n))?

Complexity ©D.Moshkovits 32 The Padding Argument Motivation: Scaling-Up Complexity Claims space + non-determinism We have: space + determinism can be simulated by… We want: space + non-determinism space + determinism can be simulated by…

Complexity ©D.Moshkovits 33 Formally NSPACE(s 1 (n))  SPACE(s 2 (n))  NSPACE(s 1 (f(n)))  SPACE(s 2 (f(n))) Claim: For any two space constructible functions s 1 (n),s 2 (n)  logn, f(n)  n: s i (n) can be computed with space s i (n) simulation overhead E.g NSPACE(n)  SPACE(n 2 )  NSPACE(n 2 )  SPACE(n 4 )

Complexity ©D.Moshkovits 34 Idea NTM n space: O(s 1 (f(n))) f(n) space: s 1 (.) in the size of its input DTM space: O(s 2 (f(n))) n

Complexity ©D.Moshkovits 35 Padding argument Let L  NPSPACE(s 1 (f(n))) There is a 3-Tape-NTM M L : babba      Input Work |x| O(s 1 (f(|x|)))

Complexity ©D.Moshkovits 36 Padding argument Let L’ = { x0 f(|x|)-|x| | x  L } We’ll show a NTM M L’ which decides L’ in the same number of cells as M L. babba#      Input Work f(|x|) O(s 1 (f(|x|))

Complexity ©D.Moshkovits 37 Padding argument – M L’ 1.Count backwards the number of 0’s and check there are f(|x|)-|x| such. 2.Run M L on x. babba      Input Work f(|x|) O(s 1 (f(|x|))) In O(log(f(|x|)) space in O(s 1 (f(|x|))) space

Complexity ©D.Moshkovits 38 Padding argument babba      Input Work f(|x|) O(s 1 (f(|x|))) Total space: O(s 1 (f(|x|)))

Complexity ©D.Moshkovits 39 Padding Argument We started with L  NSPACE(s 1 (f(n))) We showed: L’  NSPACE(s 1 (n)) Thus, L’  SPACE(s 2 (n)) Using the DTM for L’ we’ll construct a DTM for L, which will work in O(s 2 (f(n))) space.

Complexity ©D.Moshkovits 40 Padding Argument The DTM for L will simulate the DTM for L’ when working on its input concatenated with zeros babba   Input

Complexity ©D.Moshkovits 41 Padding Argument When the input head leaves the input part, just pretend it encounters 0s. maintaining the simulated position (on the imaginary part of the tape) takes O(log(f(|x|))) space. Thus our machine uses O(s 2 (f(|x|))) space.  NSPACE(s 1 (f(n)))  SPACE(s 2 (f(n)))

Complexity ©D.Moshkovits 42 Savitch: Generalized Version Theorem (Savitch):  S(n) ≥ log(n) NSPACE(S(n))  SPACE(S(n) 2 ) Proof: We proved NL  SPACE(log 2 n). The theorem follows from the padding argument. 

Complexity ©D.Moshkovits 43 Corollary Corollary: PSPACE = NPSPACE Proof: Clearly, PSPACE  NPSPACE. By Savitch’s theorem, NPSPACE  PSPACE. 

Complexity ©D.Moshkovits 44 Space Vs. Time We’ve seen space complexity probably doesn’t resemble time complexity: –Non-determinism doesn’t decrease the space complexity drastically (Savitch’s theorem). We’ll next see another difference: –Non-deterministic space complexity classes are closed under completion (Immerman’s theorem).

Complexity ©D.Moshkovits 45 NON-CONN Instance: A directed graph G and two vertices s,t  V. Problem: To decide if there is no path from s to t.

Complexity ©D.Moshkovits 46 NON-CONN Clearly, NON-CONN is coNL-Complete. (Because CONN is NL-Complete. See the coNP lecture) If we’ll show it is also in NL, then NL=coNL. (Again, see the coNP lecture)

Complexity ©D.Moshkovits 47 An Algorithm for NON-CONN 1.Count how many vertices are reachable from s. 2.Take out t and count again. 3.Accept if the two numbers are the same. We’ll see a log space algorithm for counting reachability

Complexity ©D.Moshkovits 48 N.D. Algorithm for reach s (v, l) reach s (v, l) 1. length = l; u = s 2. while (length > 0) { 3. if u = v return ‘YES’ 4. else, for all (u’  V) { 5. if (u, u’)  E nondeterministic switch: 5.1 u = u’; --length; break 5.2 continue } } 6. return ‘NO’ Takes up logarithmic space This N.D. algorithm might never stop

Complexity ©D.Moshkovits 49 N.D. Algorithm for CR s CR s ( d ) 1. count = 0 2. for all u  V { 3. count d-1 = 0 4. for all v  V { 5. nondeterministic switch: 5.1 if reach(v, d - 1) then ++count d-1 else fail if (v,u)  E then ++count; break 5.2 continue } 6. if count d-1 < CR s (d-1) fail } 7.return count Recursive call! Assume (v,v)  E

Complexity ©D.Moshkovits 50 N.D. Algorithm for CR s CR s ( d 1. count = 0 2. for all u  V { 3. count d-1 = 0 4. for all v  V { 5. nondeterministic switch: 5.1 if reach(v, d - 1) then ++count d-1 else fail if (v,u)  E then ++count; break 5.2 continue } 6. if count d-1 < fail } 7.return count Main Algorithm: CR s C = 1 for d = 1..|V| C = CR(d, C) return C parameter C, C)

Complexity ©D.Moshkovits 51 Efficiency Lemma: The algorithm uses O(log(n)) space. Proof: There is a constant number of variables ( d, count, u, v, count d-1 ). Each requires O(log(n)) space (range |V|). 

Complexity ©D.Moshkovits 52 Immerman’s Theorem Theorem[ Immerman/Szelepcsenyi ]: NL=coNL Proof: (1) NON-CONN is NL-Complete (2) NON-CONN  NL Hence, NL=coNL. 

Complexity ©D.Moshkovits 53 Corollary Corollary:  s(n)  log(n), NSPACE(s(n))=coNSPACE(s(n)) Proof: By a padding argument.

Complexity ©D.Moshkovits 54 TQBF We can use the insight of Savich’s proof to show a language which is complete for PSPACE. We present TQBF, which is the quantified version of SAT.

Complexity ©D.Moshkovits 55 TQBF Instance: a fully quantified Boolean formula  Problem: to decide if  is true  x  y  z[(x  y  z)  (  x  y)] Example: a fully quantified Boolean formula Variables` range is {0,1}

Complexity ©D.Moshkovits 56 TQBF is in PSPACE Theorem: TQBF  PSPACE Proof: We’ll describe a poly-space algorithm A for evaluating  : If  has no quantifiers: evaluate it If  =  x(  (x)) call A on  (0) and on  (1); Accept if both are true. If  =  x(  (x)) call A on  (0) and on  (1); Accept if either is true. in poly time

Complexity ©D.Moshkovits 57 Algorithm for TQBF  x  y[(x  y)  (  x  y)]  y[(0  y)  (  0  y)]  y[(1  y)  (  1  y)] (0  0)  (  0  0) (0  1)  (  0  1) (1  1)  (  1  1) (1  0)  (  1  0)

Complexity ©D.Moshkovits 58 Efficiency Since both recursive calls use the same space, the total space needed is polynomial in the number of variables (the depth of the recursion)  TQBF is polynomial-space decidable 

Complexity ©D.Moshkovits 59 PSAPCE Completeness Definition: A language B is PSPACE-Complete if 1. B  PSPACE 2. For every A  PSAPCE, A  P B. If (2) holds, then B is PSPACE-hard standard Karp reduction

Complexity ©D.Moshkovits 60 TQBF is PSPACE-Complete Theorem: TQBF is PSAPCE-Complete Proof: It remains to show TQBF is PSAPCE-hard: PP “Will the poly-space M accept x?” “Is the formula true?”  x 1  x 2  x 3 …[…]

Complexity ©D.Moshkovits 61 TQBF is PSPACE-Hard Given a TM M for a language L  PSPACE, and an input x, let f M,x (u, v), for any two configurations u and v, be the function evaluating to TRUE iff M on input x moves from configuration u to configuration v f M,x (u, v) is efficiently computable

Complexity ©D.Moshkovits 62 Formulating Connectivity The following formula, over variables u,v  V and path’s length d, is TRUE iff G has a path from u to v of length ≤d  (u,v,1)  f M,x (u, v)  u=v  (u,v,d)   w  x  y[((x=u  y=w)  (x=w  y=v))  (x,y,d/2)] w is reachable from u in  d/2  steps. v is reachable from w in  d/2  steps. simulates AND of  (u,w,d/2) and  (w,v,d/2)

Complexity ©D.Moshkovits 63 TQBF is PSPACE-Complete Claim: TQBF is PSPACE-Complete Proof:    (s,t,|V|) is TRUE iff there is a path from s to t.  is constructible in poly-time. Thus, any PSPACE language is poly-time reducible to TQBF, i.e – TQBF is PSAPCE- hard. Since TQBF  PSPACE, it’s PSAPCE-Complete. 

Complexity ©D.Moshkovits 64 Summary We introduced a new way to classify problems: according to the space needed for their computation. We defined several complexity classes: L, NL, PSPACE. 

Complexity ©D.Moshkovits 65 Summary Our main results were: –Connectivity is NL-Complete –TQBF is PSPACE-Complete –Savitch’s theorem (NL  SPACE(log 2 )) –The padding argument (extending results for space complexity) –Immerman’s theorem (NL=coNL)  By reducing decidability to reachability