SLIDE 1
Computational Complexity
Lecture 9 More of the Polynomial Hierarchy Alternation
1
PH is in terms of verification
2
Computational Complexity Lecture 9 More of the Polynomial - - PowerPoint PPT Presentation
Computational Complexity Lecture 9 More of the Polynomial - - PowerPoint PPT Presentation
Computational Complexity Lecture 9 More of the Polynomial Hierarchy Alternation 1 PH is in terms of verification 2 PH is in terms of verification Recall kp 2 PH is in terms of verification Recall kp Languages L = {x| w 1 w
SLIDE 2
SLIDE 3
PH is in terms of verification
Recall Σkp
2
SLIDE 4
PH is in terms of verification
Recall Σkp Languages L = {x| ∃w1∀w2...Qwk F(x;w1,w2,..,wk)}, where F in P
2
SLIDE 5
PH is in terms of verification
Recall Σkp Languages L = {x| ∃w1∀w2...Qwk F(x;w1,w2,..,wk)}, where F in P Consider deterministic polynomial time machine M for F , with k read-once tapes for the certificates
2
SLIDE 6
PH is in terms of verification
Recall Σkp Languages L = {x| ∃w1∀w2...Qwk F(x;w1,w2,..,wk)}, where F in P Consider deterministic polynomial time machine M for F , with k read-once tapes for the certificates Tapes read one after the other
2
SLIDE 7
PH is in terms of verification
Recall Σkp Languages L = {x| ∃w1∀w2...Qwk F(x;w1,w2,..,wk)}, where F in P Consider deterministic polynomial time machine M for F , with k read-once tapes for the certificates Tapes read one after the other x in L if ∃w1 ∀w2 ... Qwk such that M(x;w1,w2,..,wk) accepts
2
SLIDE 8
PH is in terms of verification
Recall Σkp Languages L = {x| ∃w1∀w2...Qwk F(x;w1,w2,..,wk)}, where F in P Consider deterministic polynomial time machine M for F , with k read-once tapes for the certificates Tapes read one after the other x in L if ∃w1 ∀w2 ... Qwk such that M(x;w1,w2,..,wk) accepts Plan: Formulate in terms of a non-deterministic TM (with no certificates)
2
SLIDE 9
Verification → Non-determinism
3
SLIDE 10
Verification → Non-determinism
3
SLIDE 11
Verification → Non-determinism
3
SLIDE 12
Verification → Non-determinism
Read from Tape 1
3
SLIDE 13
Verification → Non-determinism
Read from Tape 1 Read from Tape 1
3
SLIDE 14
Verification → Non-determinism
Read from Tape 1 Read from Tape 1
3
SLIDE 15
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2
3
SLIDE 16
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2
3
SLIDE 17
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0
3
SLIDE 18
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1
3
SLIDE 19
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0
3
SLIDE 20
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 1
3
SLIDE 21
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1
3
SLIDE 22
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
3
SLIDE 23
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
3
SLIDE 24
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
3
SLIDE 25
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2
3
SLIDE 26
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2 ∃ ∃ ∃
3
SLIDE 27
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2 ∃ ∃ ∃ ∀ ∀ ∀ ∀
3
SLIDE 28
ATM
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 29
ATM
Alternating Turing Machine
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 30
ATM
Alternating Turing Machine At each step, execution can fork into two
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 31
ATM
Alternating Turing Machine At each step, execution can fork into two Exactly like an NTM or co-NTM
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 32
ATM
Alternating Turing Machine At each step, execution can fork into two Exactly like an NTM or co-NTM Accepting rule is more complex
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 33
ATM
Alternating Turing Machine At each step, execution can fork into two Exactly like an NTM or co-NTM Accepting rule is more complex Like in the game tree for QBF
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
4
SLIDE 34
ATM
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
5
SLIDE 35
ATM
Two kinds of configurations: ∃ and ∀
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
5
SLIDE 36
ATM
Two kinds of configurations: ∃ and ∀ Depending on the state
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
5
SLIDE 37
ATM
Two kinds of configurations: ∃ and ∀ Depending on the state A ∃ configuration is accepting if either child is accepting
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
5
SLIDE 38
ATM
Two kinds of configurations: ∃ and ∀ Depending on the state A ∃ configuration is accepting if either child is accepting A ∀ configuration is accepting only if both children are accepting
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
5
SLIDE 39
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2 ∃ ∃ ∃ ∀ ∀ ∀ ∀
6
SLIDE 40
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2 ∃ ∃ ∃ ∀ ∀ ∀ ∀
Given a verifier for L using k certificate tapes, can build an ATM for L with at most k alternations
6
SLIDE 41
Verification → Non-determinism
Read from Tape 1 Read from Tape 1 Read from Tape 2 Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃w1 ∀w2 ∃ ∃ ∃ ∀ ∀ ∀ ∀
Given a verifier for L using k certificate tapes, can build an ATM for L with at most k alternations Non-deterministically guesses tape contents and runs verifier
6
SLIDE 42
Verification ← Non-determinism
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
Read from Tape 1 Read from Tape 1 Read from Tape 2
∃w1 ∀w2
7
SLIDE 43
Verification ← Non-determinism
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
Given ATM for L with at most k alternations, can build a verifier (using k certificate tapes)
Read from Tape 1 Read from Tape 1 Read from Tape 2
∃w1 ∀w2
7
SLIDE 44
Verification ← Non-determinism
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
Given ATM for L with at most k alternations, can build a verifier (using k certificate tapes) Same time/space requirements (in terms of |x|)
Read from Tape 1 Read from Tape 1 Read from Tape 2
∃w1 ∀w2
7
SLIDE 45
Verification ← Non-determinism
Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1
∃ ∃ ∃ ∀ ∀ ∀ ∀
Given ATM for L with at most k alternations, can build a verifier (using k certificate tapes) Same time/space requirements (in terms of |x|) |wi| = #choices
Read from Tape 1 Read from Tape 1 Read from Tape 2
∃w1 ∀w2
7
SLIDE 46
Time, Space, Alternations
8
SLIDE 47
Time, Space, Alternations
Complexity measures
8
SLIDE 48
Time, Space, Alternations
Complexity measures Time: Maximum number of steps in any thread
8
SLIDE 49
Time, Space, Alternations
Complexity measures Time: Maximum number of steps in any thread Space: Maximum space in any configuration reached
8
SLIDE 50
Time, Space, Alternations
Complexity measures Time: Maximum number of steps in any thread Space: Maximum space in any configuration reached Alternations: Maximum number of quantifier switches in any thread
8
SLIDE 51
ATIME
9
SLIDE 52
ATIME
ΣkTIME, ΠkTIME
9
SLIDE 53
ATIME
ΣkTIME, ΠkTIME ΣkTIME(T): languages decided by ATMs with at most k alternations starting with ∃, in time T(n)
9
SLIDE 54
ATIME
ΣkTIME, ΠkTIME ΣkTIME(T): languages decided by ATMs with at most k alternations starting with ∃, in time T(n) ΣkTIME(poly) = Σkp
9
SLIDE 55
ATIME
ΣkTIME, ΠkTIME ΣkTIME(T): languages decided by ATMs with at most k alternations starting with ∃, in time T(n) ΣkTIME(poly) = Σkp Latter being exactly the certificate version
9
SLIDE 56
ATIME
ΣkTIME, ΠkTIME ΣkTIME(T): languages decided by ATMs with at most k alternations starting with ∃, in time T(n) ΣkTIME(poly) = Σkp Latter being exactly the certificate version ATIME
9
SLIDE 57
ATIME
ΣkTIME, ΠkTIME ΣkTIME(T): languages decided by ATMs with at most k alternations starting with ∃, in time T(n) ΣkTIME(poly) = Σkp Latter being exactly the certificate version ATIME ATIME(T): languages decided by ATMs in time T(n)
9
SLIDE 58
ATIME vs. DSPACE
10
SLIDE 59
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2)
10
SLIDE 60
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2) c.f. NTIME(T) ⊆ DSPACE(T)
10
SLIDE 61
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2) c.f. NTIME(T) ⊆ DSPACE(T) AP ⊆ PSPACE
10
SLIDE 62
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2) c.f. NTIME(T) ⊆ DSPACE(T) AP ⊆ PSPACE But PSPACE ⊆ AP
10
SLIDE 63
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2) c.f. NTIME(T) ⊆ DSPACE(T) AP ⊆ PSPACE But PSPACE ⊆ AP TQBF in AP (why?)
10
SLIDE 64
ATIME vs. DSPACE
ATIME(T) ⊆ DSPACE(T2) c.f. NTIME(T) ⊆ DSPACE(T) AP ⊆ PSPACE But PSPACE ⊆ AP TQBF in AP (why?) AP = PSPACE
10
SLIDE 65
ATIME(T) ⊆ DSPACE(T2)
11
SLIDE 66
ATIME(T) ⊆ DSPACE(T2)
Evaluate if the start configuration is accepting, recursively
11
SLIDE 67
ATIME(T) ⊆ DSPACE(T2)
Evaluate if the start configuration is accepting, recursively A ∃ configuration is accepting if any child is, and a ∀ configuration is accepting if all children are
11
SLIDE 68
ATIME(T) ⊆ DSPACE(T2)
Evaluate if the start configuration is accepting, recursively A ∃ configuration is accepting if any child is, and a ∀ configuration is accepting if all children are Space needed: depth x size of configuration
11
SLIDE 69
ATIME(T) ⊆ DSPACE(T2)
Evaluate if the start configuration is accepting, recursively A ∃ configuration is accepting if any child is, and a ∀ configuration is accepting if all children are Space needed: depth x size of configuration Depth = # alternations = O(T). Also, size of configuration = O(T) as any thread runs for time O(T)
11
SLIDE 70
ATIME(T) ⊆ DSPACE(T2)
Evaluate if the start configuration is accepting, recursively A ∃ configuration is accepting if any child is, and a ∀ configuration is accepting if all children are Space needed: depth x size of configuration Depth = # alternations = O(T). Also, size of configuration = O(T) as any thread runs for time O(T) O(T2)
11
SLIDE 71
ASPACE vs. DTIME
12
SLIDE 72
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S))
12
SLIDE 73
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) Recall, already seen NSPACE(S) ⊆ DTIME(2O(S))
12
SLIDE 74
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) Recall, already seen NSPACE(S) ⊆ DTIME(2O(S)) Poly-time connectivity in configuration graph
- f size at most 2O(S)
12
SLIDE 75
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) Recall, already seen NSPACE(S) ⊆ DTIME(2O(S)) Poly-time connectivity in configuration graph
- f size at most 2O(S)
Instead of connectivity, can recursively label all accepting nodes (2 lookups per node: in poly(S) time). So ASPACE(S) ⊆ DTIME(2O(S))
12
SLIDE 76
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) Recall, already seen NSPACE(S) ⊆ DTIME(2O(S)) Poly-time connectivity in configuration graph
- f size at most 2O(S)
Instead of connectivity, can recursively label all accepting nodes (2 lookups per node: in poly(S) time). So ASPACE(S) ⊆ DTIME(2O(S)) To show DTIME(2O(S)) ⊆ ASPACE(S)
12
SLIDE 77
DTIME(2O(S)) ⊆ ASPACE(S)
13
SLIDE 78
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting
13
SLIDE 79
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting Accept configuration, with unique first cell α (blank tape cell and unique accept state)
13
SLIDE 80
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting Accept configuration, with unique first cell α (blank tape cell and unique accept state) Once there, stays there
13
SLIDE 81
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting Accept configuration, with unique first cell α (blank tape cell and unique accept state) Once there, stays there Is first cell of config after t steps α
13
SLIDE 82
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting Accept configuration, with unique first cell α (blank tape cell and unique accept state) Once there, stays there Is first cell of config after t steps α C(i,j,x) : if after i steps, jth cell of config is x
13
SLIDE 83
DTIME(2O(S)) ⊆ ASPACE(S)
To decide, is configuration after t steps accepting Accept configuration, with unique first cell α (blank tape cell and unique accept state) Once there, stays there Is first cell of config after t steps α C(i,j,x) : if after i steps, jth cell of config is x Need to check C(t,1,α)
13
SLIDE 84
ATM for TM simulation
14
SLIDE 85
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x
14
SLIDE 86
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x Recall reduction in Cook’ s theorem
14
SLIDE 87
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x Recall reduction in Cook’ s theorem If C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) then C(i,j,x) iff x=F(a,b,c)
14
SLIDE 88
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x Recall reduction in Cook’ s theorem If C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) then C(i,j,x) iff x=F(a,b,c) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c)
14
SLIDE 89
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x Recall reduction in Cook’ s theorem If C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) then C(i,j,x) iff x=F(a,b,c) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Base case: C(0,j,x) easy to check from input
14
SLIDE 90
ATM for TM simulation
C(i,j,x) : if after i steps, jth cell of config is x Recall reduction in Cook’ s theorem If C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) then C(i,j,x) iff x=F(a,b,c) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Base case: C(0,j,x) easy to check from input Naive recursion: Extra O(S) space at each level for 2O(S) levels!
14
SLIDE 91
ATM for TM simulation
15
SLIDE 92
ATM for TM simulation
ATM to check if C(i,j,x)
15
SLIDE 93
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c)
15
SLIDE 94
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Tail-recursion (in parallel forks)
15
SLIDE 95
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Tail-recursion (in parallel forks) Check x=F(a,b,c); then enter universal state, fork out for each of the three configurations to be checked
15
SLIDE 96
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Tail-recursion (in parallel forks) Check x=F(a,b,c); then enter universal state, fork out for each of the three configurations to be checked Overwrite C(i,j,x) with C(i-1,...) and reuse space
15
SLIDE 97
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Tail-recursion (in parallel forks) Check x=F(a,b,c); then enter universal state, fork out for each of the three configurations to be checked Overwrite C(i,j,x) with C(i-1,...) and reuse space Stay within the same O(S) space at each level!
15
SLIDE 98
ATM for TM simulation
ATM to check if C(i,j,x) C(i,j,x): ∃a,b,c st x=F(a,b,c) and C(i-1,j-1,a), C(i-1,j,b), C(i-1,j+1,c) Tail-recursion (in parallel forks) Check x=F(a,b,c); then enter universal state, fork out for each of the three configurations to be checked Overwrite C(i,j,x) with C(i-1,...) and reuse space Stay within the same O(S) space at each level!
G e t s t h e A N D c h e c k f
- r
f r e e . N
- n
e e d t
- u
s e a s t a c k .
15
SLIDE 99
ASPACE vs. DTIME
16
SLIDE 100
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S))
16
SLIDE 101
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) APSPACE = EXP
16
SLIDE 102
ASPACE vs. DTIME
ASPACE(S) = DTIME(2O(S)) APSPACE = EXP AL = P
16
SLIDE 103
Zoo
P
PSPACE
EXP NP NEXP L NL
NPSPACE
ΣkP
AP
PH
17
SLIDE 104
Zoo
P
PSPACE
EXP NP NEXP L NL
NPSPACE APSPACE
AL ΣkP
AP
PH
17
SLIDE 105
Zoo
P
PSPACE
EXP NP NEXP L NL
NPSPACE APSPACE
AL ΣkP
AP
PH
17
SLIDE 106
DTISP(T,S)
18
SLIDE 107
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0
18
SLIDE 108
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space
18
SLIDE 109
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space
18
SLIDE 110
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space Follows (after careful choice of parameters) from
18
SLIDE 111
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space Follows (after careful choice of parameters) from DTISP(T,S) ⊆ Σ2TIME(T1/2 S)
18
SLIDE 112
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space Follows (after careful choice of parameters) from DTISP(T,S) ⊆ Σ2TIME(T1/2 S)
quantification to guess intermediate configs, check consecutive ones good
18
SLIDE 113
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space Follows (after careful choice of parameters) from DTISP(T,S) ⊆ Σ2TIME(T1/2 S) NTIME(n) ⊆ DTIME(n1+ε) ⇒ Σ2TIME(T) ⊆ NTIME(T1+ε)
quantification to guess intermediate configs, check consecutive ones good
18
SLIDE 114
DTISP(T,S)
Theorem: NTIME(n) ⊄ DTISP(n1+ε,nδ) for some ε, δ > 0 i.e., cannot solve SAT in some slightly super-linear time and slightly super-logarithmic space Commonly Believed: can’t solve in less than exponential time or with less than linear space Follows (after careful choice of parameters) from DTISP(T,S) ⊆ Σ2TIME(T1/2 S) NTIME(n) ⊆ DTIME(n1+ε) ⇒ Σ2TIME(T) ⊆ NTIME(T1+ε) NTIME(n) ⊆ DTISP(n1+ε,nδ) ⇒ NTIME(nt) ⊆ NTIME(nt(1/2+ε’)) !
quantification to guess intermediate configs, check consecutive ones good
18
SLIDE 115
Today
19
SLIDE 116
Today
ATM to define levels of PH
19
SLIDE 117
Today
ATM to define levels of PH ATIME and ASPACE
19
SLIDE 118
Today
ATM to define levels of PH ATIME and ASPACE AP = PSPACE and APSPACE = EXP
19
SLIDE 119
Today
ATM to define levels of PH ATIME and ASPACE AP = PSPACE and APSPACE = EXP Using Σ2TIME for a DTISP lower-bound
19