1. Complexity 1 The Padding Argument

2. Complexity 2 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…

3. Complexity 3 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 )

4. Complexity 4 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))) 0 0...... n

5. Complexity 5 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|)))

6. Complexity 6 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. babba00000000000000000000000000000000      Input Work f(|x|) O(s 1 (f(|x|))

7. Complexity 7 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. babba00000000000000000000000000000000      Input Work f(|x|) O(s 1 (f(|x|))) In O(log(f(|x|)) space in O(s 1 (f(|x|))) space

8. Complexity 8 Padding argument babba00000000000000000000000000000000      Input Work f(|x|) O(s 1 (f(|x|))) Total space: O(s 1 (f(|x|)))

9. Complexity 9 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.

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

11. Complexity 11 Padding Argument When the input head leaves the input part, just pretend it encounters 0s. keeping track after the simulated position 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)))

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

13. Complexity 13 Corollary Corollary: PSPACE = NPSPACE Proof: Clearly, PSPACE  NPSPACE. By Savitch’s theorem, NPSPACE  PSPACE. 