Computational Complexity Lecture 9 Alternation (Continued) 1 - - PowerPoint PPT Presentation

Computational Complexity

Lecture 9 Alternation (Continued)

1

ATM

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine At each step, execution can fork into two (like NTM or co-NTM)

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine At each step, execution can fork into two (like NTM or co-NTM) Two kinds of configurations: ∃ and ∀

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine At each step, execution can fork into two (like NTM or co-NTM) Two kinds of configurations: ∃ and ∀ A ∃ configuration is accepting if either child is accepting

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine At each step, execution can fork into two (like NTM or co-NTM) Two kinds of configurations: ∃ and ∀ 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

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATM

Alternating Turing Machine At each step, execution can fork into two (like NTM or co-NTM) Two kinds of configurations: ∃ and ∀ A ∃ configuration is accepting if either child is accepting A ∀ configuration is accepting only if both children are accepting ATM accepts if start config accepts according to this rule

Guess 0 Guess 1 Guess 0 Guess 0 Guess 1 Guess 1

∃ ∃ ∃ ∀ ∀ ∀ ∀

2

ATIME, ASPACE

3

ATIME, ASPACE

ATIME(T) ⊆ DSPACE(T2)

3

ATIME, ASPACE

ATIME(T) ⊆ DSPACE(T2) AP = PSPACE

3

ATIME, ASPACE

ATIME(T) ⊆ DSPACE(T2) AP = PSPACE ASPACE(S) = DTIME(2O(S))

3

ATIME, ASPACE

ATIME(T) ⊆ DSPACE(T2) AP = PSPACE ASPACE(S) = DTIME(2O(S)) AL = P and APSPACE = EXP

3

DTIME(2O(S)) ⊆ ASPACE(S)

4

DTIME(2O(S)) ⊆ ASPACE(S)

To decide, is configuration after t steps accepting

4

DTIME(2O(S)) ⊆ ASPACE(S)

To decide, is configuration after t steps accepting C(i,j,x) : if after i steps, jth cell of config is x

4

DTIME(2O(S)) ⊆ ASPACE(S)

To decide, is configuration after t steps accepting C(i,j,x) : if after i steps, jth cell of config is 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)

4

DTIME(2O(S)) ⊆ ASPACE(S)

To decide, is configuration after t steps accepting C(i,j,x) : if after i steps, jth cell of config is 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) Base case: C(0,j,x) easy to check from input

4

DTIME(2O(S)) ⊆ ASPACE(S)

To decide, is configuration after t steps accepting C(i,j,x) : if after i steps, jth cell of config is 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) Base case: C(0,j,x) easy to check from input Naive recursion: Extra O(S) space to store i,j at each level for 2O(S) levels!

4

ATM for TM simulation

5

ATM for TM simulation

ATM to check if C(i,j,x)

5

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)

5

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

5

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, and non-deterministically choose one of the three conditions to check

5

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, and non-deterministically choose one of the three conditions to check Overwrite C(i,j,x) with C(i-1,...) and reuse space

5

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, and non-deterministically choose one of the three conditions to check Overwrite C(i,j,x) with C(i-1,...) and reuse space Stay within the same O(S) space at each level!

5

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, and non-deterministically choose one of the three conditions to check 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 .

5

Zoo

P

PSPACE

EXP NP NEXP L NL

NPSPACE

ΣkP

AP

PH

6

Zoo

P

PSPACE

EXP NP NEXP L NL

NPSPACE APSPACE

AL ΣkP

AP

PH

6

Zoo

P

PSPACE

EXP NP NEXP L NL

NPSPACE APSPACE

AL ΣkP

AP

PH

6

Non-Uniform Computation

Lecture 10 Non-Uniform Computational Models: Circuits

7

Non-Uniform Computation

8

Non-Uniform Computation

Uniform: Same program for all (the infinitely many) inputs

8

Non-Uniform Computation

Uniform: Same program for all (the infinitely many) inputs Non-uniform: A different “program” for each input size

8

Non-Uniform Computation

Uniform: Same program for all (the infinitely many) inputs Non-uniform: A different “program” for each input size Then complexity of building the program and executing the program

8

Non-Uniform Computation

Uniform: Same program for all (the infinitely many) inputs Non-uniform: A different “program” for each input size Then complexity of building the program and executing the program Sometimes will focus on the latter alone

8

Non-Uniform Computation

Uniform: Same program for all (the infinitely many) inputs Non-uniform: A different “program” for each input size Then complexity of building the program and executing the program Sometimes will focus on the latter alone Not entirely realistic if the program family is uncomputable

• r very complex to compute

8

Non-uniform advice

9

Non-uniform advice

Program: TM M and advice strings {An}

9

Non-uniform advice

Program: TM M and advice strings {An} M given A|x| along with x

9

Non-uniform advice

Program: TM M and advice strings {An} M given A|x| along with x An can be the program for inputs of size n

9

Non-uniform advice

Program: TM M and advice strings {An} M given A|x| along with x An can be the program for inputs of size n |An|=2n is sufficient

9

Non-uniform advice

Program: TM M and advice strings {An} M given A|x| along with x An can be the program for inputs of size n |An|=2n is sufficient But {An} can be uncomputable (even if just one bit long)

9

Non-uniform advice

Program: TM M and advice strings {An} M given A|x| along with x An can be the program for inputs of size n |An|=2n is sufficient But {An} can be uncomputable (even if just one bit long) e.g. advice to decide undecidable unary languages

9

P/poly and P/log

10

P/poly and P/log

DTIME(T)/a

10

P/poly and P/log

DTIME(T)/a Languages decided by a TM in time T(n) using non-uniform advice of length a(n)

10

P/poly and P/log

DTIME(T)/a Languages decided by a TM in time T(n) using non-uniform advice of length a(n) P/poly = ∪c,d,k>0 DTIME(knc)/knd

10

P/poly and P/log

DTIME(T)/a Languages decided by a TM in time T(n) using non-uniform advice of length a(n) P/poly = ∪c,d,k>0 DTIME(knc)/knd P/log = ∪c,k>0 DTIME(knc)/k log n

10

NP vs. P/log, P/poly

11

NP vs. P/log, P/poly

P/log (or even DTIME(1)/1) has undecidable languages

11

NP vs. P/log, P/poly

P/log (or even DTIME(1)/1) has undecidable languages e.g. unary undecidable languages

11

NP vs. P/log, P/poly

P/log (or even DTIME(1)/1) has undecidable languages e.g. unary undecidable languages So P/log cannot be contained in any of the uniform complexity classes

11

NP vs. P/log, P/poly

P/log (or even DTIME(1)/1) has undecidable languages e.g. unary undecidable languages So P/log cannot be contained in any of the uniform complexity classes P/log contains P

11

NP vs. P/log, P/poly

P/log (or even DTIME(1)/1) has undecidable languages e.g. unary undecidable languages So P/log cannot be contained in any of the uniform complexity classes P/log contains P Does P/log or P/poly contain NP?

11

NP ⊆ P/log ⇒ NP=P

12

NP ⊆ P/log ⇒ NP=P

Recall finding witness for an NP language is Turing reducible to deciding the language

12

Search using Decision

Suppose given “oracles” for deciding all NP languages, can we easily find certificates? Yes! So, if decision easy (decision-oracles realizable), then search is easy too! Say, given x, need to find w s.t. (x,w) ∈ L ’ (if such w exists) consider L1 in NP: (x,y) ∈ L1 iff ∃z s.t. (x,yz) ∈ L ’. (i.e., can y be a prefix of a certificate for x). Query L1-oracle with (x,0) and (x,1). If ∃w, one of the two must be positive: say (x,0) ∈ L1; then first bit of w be 0. For next bit query L1-oracle with (x,00) and (x,01)

Recall

13

Search using Decision

Suppose given “oracles” for deciding all NP languages, can we easily find certificates? Yes! So, if decision easy (decision-oracles realizable), then search is easy too! Say, given x, need to find w s.t. (x,w) ∈ L ’ (if such w exists) consider L1 in NP: (x,y) ∈ L1 iff ∃z s.t. (x,yz) ∈ L ’. (i.e., can y be a prefix of a certificate for x). Query L1-oracle with (x,0) and (x,1). If ∃w, one of the two must be positive: say (x,0) ∈ L1; then first bit of w be 0. For next bit query L1-oracle with (x,00) and (x,01)

Use L2 so that (x,z,pad) in L2 iff (x,z) in L1. Can query L2 with same size instances

Recall

13

NP ⊆ P/log ⇒ NP=P

Recall finding witness for an NP language is Turing reducible to deciding the language

14

NP ⊆ P/log ⇒ NP=P

If NP ⊆ P/log, then for each L in NP, there is a poly-time TM with log advice which can find witness (via self- reduction) Recall finding witness for an NP language is Turing reducible to deciding the language

14

NP ⊆ P/log ⇒ NP=P

If NP ⊆ P/log, then for each L in NP, there is a poly-time TM with log advice which can find witness (via self- reduction) Guess advice (poly many), and for each guessed advice, run the TM and see if it finds witness Recall finding witness for an NP language is Turing reducible to deciding the language

14

NP ⊆ P/log ⇒ NP=P

If NP ⊆ P/log, then for each L in NP, there is a poly-time TM with log advice which can find witness (via self- reduction) Guess advice (poly many), and for each guessed advice, run the TM and see if it finds witness If no advice worked (one of them was correct), then input not in language Recall finding witness for an NP language is Turing reducible to deciding the language

14

NP ⊆ P/poly ⇒ PH=Σ2P

15

NP ⊆ P/poly ⇒ PH=Σ2P

Will show Π2P = Σ2P

15

NP ⊆ P/poly ⇒ PH=Σ2P

Will show Π2P = Σ2P Consider L = {x| ∀w1 (x,w1) ∈ L ’ } ∈ Π2P where L ’ = {(x,w1)| ∃w2 F(x,w1,w2)} ∈ NP

15

NP ⊆ P/poly ⇒ PH=Σ2P

Will show Π2P = Σ2P Consider L = {x| ∀w1 (x,w1) ∈ L ’ } ∈ Π2P where L ’ = {(x,w1)| ∃w2 F(x,w1,w2)} ∈ NP If NP ⊆ P/poly then consider M with advice {An} which finds witness for L ’: i.e. if (x,w1) ∈ L ’, then M(x,w1; An) outputs a witness w2 s.t. F(x,w1,w2)

15

NP ⊆ P/poly ⇒ PH=Σ2P

Will show Π2P = Σ2P Consider L = {x| ∀w1 (x,w1) ∈ L ’ } ∈ Π2P where L ’ = {(x,w1)| ∃w2 F(x,w1,w2)} ∈ NP If NP ⊆ P/poly then consider M with advice {An} which finds witness for L ’: i.e. if (x,w1) ∈ L ’, then M(x,w1; An) outputs a witness w2 s.t. F(x,w1,w2) L = {x| ∃z ∀w1 F(x, w1, M(x,w1; z)) }

15

Boolean Circuits

16

Boolean Circuits

Non-uniformity: circuit family {Cn}

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn}

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} An,q0 (x,An) x

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} Advice An is hard-wired into circuit Cn An,q0 (x,An) x

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} Advice An is hard-wired into circuit Cn Size of circuit polynomially related to running time of TM An,q0 (x,An) x

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} Advice An is hard-wired into circuit Cn Size of circuit polynomially related to running time of TM An,q0 (x,An) x S i z e = n

• .
• f

w i r e s

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} Advice An is hard-wired into circuit Cn Size of circuit polynomially related to running time of TM Conversely, given {Cn}, can use description of Cn as advice An for a “universal” TM An,q0 (x,An) x S i z e = n

• .
• f

w i r e s

16

Boolean Circuits

Non-uniformity: circuit family {Cn} Given non-uniform computation (M,{An}), can define equivalent {Cn} Advice An is hard-wired into circuit Cn Size of circuit polynomially related to running time of TM Conversely, given {Cn}, can use description of Cn as advice An for a “universal” TM |An| comparable to size of circuit Cn An,q0 (x,An) x S i z e = n

• .
• f

w i r e s

16

SIZE(T)

17

SIZE(T)

SIZE(T): languages solved by circuit families of size T(n)

17

SIZE(T)

SIZE(T): languages solved by circuit families of size T(n) P/poly = SIZE(poly)

17

SIZE(T)

SIZE(T): languages solved by circuit families of size T(n) P/poly = SIZE(poly) SIZE(poly) ⊆ P/poly: Size T circuit can be described in O(T log T) bits (advice). Universal TM can evaluate this circuit in poly time

17

SIZE(T)

SIZE(T): languages solved by circuit families of size T(n) P/poly = SIZE(poly) SIZE(poly) ⊆ P/poly: Size T circuit can be described in O(T log T) bits (advice). Universal TM can evaluate this circuit in poly time P/poly ⊆ SIZE(poly): Transformation from Cook’ s theorem, with advice string hardwired into circuit

17

SIZE bounds

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n)

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n) Circuit encodes truth-table

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n) Circuit encodes truth-table Most languages need circuits of size !(2n/n)

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n) Circuit encodes truth-table Most languages need circuits of size !(2n/n) Number of circuits of size T is at most T2T

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n) Circuit encodes truth-table Most languages need circuits of size !(2n/n) Number of circuits of size T is at most T2T If T = 2n/ 4n, say, T2T < 2(2^n)/2

18

SIZE bounds

All languages (decidable or not) are in SIZE(T) for T=O(n2n) Circuit encodes truth-table Most languages need circuits of size !(2n/n) Number of circuits of size T is at most T2T If T = 2n/ 4n, say, T2T < 2(2^n)/2 Number of languages = 22^n

18

SIZE hierarchy

19

SIZE hierarchy

SIZE(T’) ⊊ SIZE(T) if T=!(t2t) and T’=O(2t/t)

19

SIZE hierarchy

SIZE(T’) ⊊ SIZE(T) if T=!(t2t) and T’=O(2t/t) Consider functions on t bits (ignoring n-t bits)

19

SIZE hierarchy

SIZE(T’) ⊊ SIZE(T) if T=!(t2t) and T’=O(2t/t) Consider functions on t bits (ignoring n-t bits) All of them in SIZE(T), most not in SIZE(T’)

19

Uniform Circuits

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)!

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)! Uniform circuit family: constructed by a TM

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)! Uniform circuit family: constructed by a TM Undecidable languages are undecidable for these circuits families

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)! Uniform circuit family: constructed by a TM Undecidable languages are undecidable for these circuits families Can relate their complexity classes to classes defined using TMs

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)! Uniform circuit family: constructed by a TM Undecidable languages are undecidable for these circuits families Can relate their complexity classes to classes defined using TMs Logspace-uniform:

20

Uniform Circuits

Circuits are interesting for their structure too (not just size)! Uniform circuit family: constructed by a TM Undecidable languages are undecidable for these circuits families Can relate their complexity classes to classes defined using TMs Logspace-uniform: An O(log n) space TM can compute the circuit

20

NC and AC

21

NC and AC

NC and AC: languages decided by poly size and poly-log depth logspace-uniform circuits

21

NC and AC

NC and AC: languages decided by poly size and poly-log depth logspace-uniform circuits NC with bounded fan-in and AC with unbounded fan-in

21

NC and AC

NC and AC: languages decided by poly size and poly-log depth logspace-uniform circuits NC with bounded fan-in and AC with unbounded fan-in NCi: decided by bounded fan-in logspace-uniform circuits of poly size and depth O(logi n)

21

NC and AC

NC and AC: languages decided by poly size and poly-log depth logspace-uniform circuits NC with bounded fan-in and AC with unbounded fan-in NCi: decided by bounded fan-in logspace-uniform circuits of poly size and depth O(logi n) NC = ∪i>0 NCi

21

NC and AC

NC and AC: languages decided by poly size and poly-log depth logspace-uniform circuits NC with bounded fan-in and AC with unbounded fan-in NCi: decided by bounded fan-in logspace-uniform circuits of poly size and depth O(logi n) NC = ∪i>0 NCi Similarly ACi and AC = ∪i>0 ACi

21

NCi and ACi

22

NCi and ACi

NCi ⊆ ACi ⊆ NCi+1

22

NCi and ACi

NCi ⊆ ACi ⊆ NCi+1 Clearly NCi ⊆ ACi

22

NCi and ACi

NCi ⊆ ACi ⊆ NCi+1 Clearly NCi ⊆ ACi ACi ⊆ NCi+1 because polynomial fan-in can be reduced to constant fan-in by using a log depth tree

22

NCi and ACi

NCi ⊆ ACi ⊆ NCi+1 Clearly NCi ⊆ ACi ACi ⊆ NCi+1 because polynomial fan-in can be reduced to constant fan-in by using a log depth tree So NC = AC

22

NC and P

23

NC and P

NC ⊆ P

23

NC and P

NC ⊆ P Build the circuit in logspace (so poly time) and evaluate it in time polynomial in the size of the circuit

23

NC and P

NC ⊆ P Build the circuit in logspace (so poly time) and evaluate it in time polynomial in the size of the circuit Open problem: Is NC = P?

23

Motivation for NC

24

Motivation for NC

Fast parallel computation is (loosely) modeled as having poly many processors and taking poly-log time

24

Motivation for NC

Fast parallel computation is (loosely) modeled as having poly many processors and taking poly-log time Corresponds to NC

24

Motivation for NC

Fast parallel computation is (loosely) modeled as having poly many processors and taking poly-log time Corresponds to NC Depth translates to time

24

Motivation for NC

Fast parallel computation is (loosely) modeled as having poly many processors and taking poly-log time Corresponds to NC Depth translates to time Total “work” is size of the circuit

24