CS21 Decidability and Tractability

1. CS21 Decidability and Tractability Lecture 25 March 11, 2019 CS21 Lecture 25

2. Outline • challenges to the extended Church-Turing Thesis • randomized computation • quantum computation CS21 Lecture 25

3. Extended Church-Turing Thesis • the belief that TMs formalize our intuitive notion of an efficient algorithm is: • randomized computationchallenges this belief The “extended” Church-Turing Thesis everything we can compute in time t(n) on a physical computer can be computed on a Turing Machine in time t(n)O(1) (polynomial slowdown) CS21 Lecture 25

4. Randomness in computation • Example of the power of randomness • Randomized complexity classes CS21 Lecture 25

5. Communication complexity two parties: Alice and Bob function f:{0,1}n x {0,1}n{0,1} Alice holds x {0,1}n; Bob holds y {0,1}n • Goal: compute f(x, y) while communicating as few bits as possible between Alice and Bob • count number of bits exchanged (computation free) • at each step: one party sends bits that are a function of held input and received bits so far CS21 Lecture 25

6. Communication complexity • simple function (equality): EQ(x, y) = 1 iff x = y • simple protocol: • Alice sends x to Bob (n bits) • Bob sends EQ(x, y) to Alice (1 bit) • total: n + 1 bits • (works for any predicate f) CS21 Lecture 25

7. Communication complexity • Can we do better? • deterministic protocol? • probabilistic protocol? • at each step: one party sends bits that are a function of held input and received bits so far and the result of some coin tosses • required to output f(x, y) with high probability over all coin tosses CS21 Lecture 25

8. Communication complexity Theorem: no deterministic protocol can compute EQ(x, y) while exchanging fewer than n+1 bits. • Proof: • “input matrix”: Y = {0,1}n X = {0,1}n f(x,y) CS21 Lecture 25

9. Communication complexity • assume 1 bit sent at a time (but proof works for general case) • A sends 1 bit depending only on x: Y = {0,1}n inputs x causing A to send 1 X = {0,1}n inputs x causing A to send 0 CS21 Lecture 25

10. Communication complexity • B sends 1 bit depending only on y and received bit: Y = {0,1}n inputs y causing B to send 1 X = {0,1}n inputs y causing B to send 0 CS21 Lecture 25

11. Communication complexity • at end of protocol involving k bits of communication, matrix is partitioned into at most 2k combinatorial rectangles • bits sent in protocol are the same for every input (x, y) in given rectangle • conclude: f(x,y) must be constant on each rectangle CS21 Lecture 25

12. Communication complexity Y = {0,1}n • any partition into combinatorial rectangles with constant f(x,y) must have at least 2n + 1 rectangles • protocol that exchanges ≤ n bits can only create 2n rectangles, so must exchange at least n+1 bits. Matrix for EQ: 1 0 1 1 X = {0,1}n 0 1 CS21 Lecture 25

13. Communication complexity • Can we do better? • deterministic protocol? • probabilistic protocol? • at each step: one party sends bits that are a function of held input and received bits so far and the result of some coin tosses • required to output f(x, y) with high probability over all coin tosses CS21 Lecture 25

14. Communication complexity • protocol for EQ employing randomness? • Alice picks random prime p in {1...4n2}, sends: • p • (x mod p) • Bob sends: • (y mod p) • players output 1 if and only if: (x mod p) = (y mod p) CS21 Lecture 25

15. Communication complexity • O(log n) bits exchanged • if x = y, always correct • if x ≠ y, incorrect if and only if: p divides |x – y| • # primes in range is ≥ 2n • # primes dividing |x – y| is ≤ n • probability incorrect ≤ 1/2 Randomness gives an exponential advantage!! CS21 Lecture 25

16. Communication complexity two parties: Alice and Bob function f:{0,1}n x {0,1}n {0,1} Alice holds x {0,1}n; Bob holds y {0,1}n • Goal: compute f(x, y) while communicating as few bits as possible between Alice and Bob Example: EQ(x, y) = 1 iff x = y • Deterministic protocol: no fewer than n+1 bits • Randomized protocol: O(log n) bits CS21 Lecture 25

17. Extended Church-Turing Thesis • Common to insert “probabilistic”: The “extended” Church-Turing Thesis everything we can compute in time t(n) on a physical computer can be computed on a probabilisticTuring Machine in time t(n)O(1) (polynomial slowdown) CS21 Lecture 25

18. Randomized complexity classes • model: probabilistic Turing Machine • deterministic TM with additional read-only tape containing “coin flips” input tape … 1 1 0 0 1 1 0 0 0 0 1 1 finite control read/write head q0 read head … 1 1 0 0 1 1 0 0 0 0 1 1 CS21 Lecture 25

19. Randomized complexity classes • RP(Random Polynomial-time) • L RP if there is a p.p.t. TM M: x L Pry[M(x,y) accepts] ≥ ½ x L Pry[M(x,y) rejects] = 1 • coRP(complement of Random Polynomial-time) • L coRPif there is a p.p.t. TM M: x L Pry[M(x,y) accepts] = 1 x L Pry[M(x,y) rejects] ≥ ½ “p.p.t” = probabilistic polynomial time CS21 Lecture 25

20. Randomized complexity classes • BPP(Bounded-error Probabilistic Poly-time) • L BPP if there is a p.p.t. TM M: x L Pry[M(x,y) accepts] ≥ 2/3 x L Pry[M(x,y) rejects] ≥ 2/3 CS21 Lecture 25

21. Randomized complexity classes These classes may capture “efficiently computable” better than P. One more important class: • ZPP(Zero-error Probabilistic Poly-time) • ZPP = RP coRP • Pry[M(x,y) outputs “fail”] ≤ ½ • otherwise outputs correct answer CS21 Lecture 25

22. RP,coRP, BPP ZPP coRP RP P PSPACE BPP EXP • from definitions: ZPP RP, coRPBPP CS21 Lecture 25

23. Relationship to other classes • all these classes contain P • they can simply ignore the tape with coin flips • all are in PSPACE • can exhaustively try all strings y • count accepts/rejects; compute probability • RP NP (and coRPcoNP) • multitude of accepting computations • NP requires only one CS21 Lecture 25

24. Polynomial identity testing • Given: polynomial p(x1, x2, …, xn) as arithmetic formula (fan-out 1): * • multiplication (fan-in 2) • addition (fan-in 2) • negation (fan-in 1) - * * + - x1 x2 x3 … xn CS21 Lecture 25

25. Polynomial identity testing • Question: Is p identically zero? • i.e., is p(x) = 0 for all xFn • (assume |F| larger than degree…) • “polynomial identity testing” because given two polynomials p, q, we can check the identity p qby checking if (p – q) 0 CS21 Lecture 25

26. Polynomial identity testing • try all |F|n inputs? • may be exponentially many • multiply out symbolically, check that all coefficients are zero? • may be exponentially many coefficients • Best known deterministic algorithm places in EXP CS21 Lecture 25

27. Polynomial identity testing Lemma (Schwartz-Zippel): Let p(x1, x2, …, xn) be a total degree d polynomial over a field F and let S beany subset of F. Then if p is not identically 0, Prr1,r2,…,rnS[ p(r1, r2, …, rn)= 0] ≤ d/|S|. CS21 Lecture 25

28. Polynomial identity testing • Given: polynomial p(x1, x2, …, xn) over field F • Is p identically zero? • Note: degree d is at most the size of input * - * * + - x1 x2 x3 … xn CS21 Lecture 25

29. Polynomial identity testing • randomized algorithm: pick a subset S F of size 2d • pick r1, r2, …, rnfrom S uniformly at random • if p(r1, r2, …, rn) = 0, answer “yes” • if p(r1, r2, …, rn) ≠ 0, answer “no” • if p identically zero, never wrong • if not, Schwartz-Zippel ensures probability of error at most ½ CS21 Lecture 25

30. Randomized complexity classes • We have shown: • Polynomial Identity Testing is in coRP • note: no sub-exponential time deterministic algorithm know CS21 Lecture 25

31. Randomized complexity classes • How powerful is randomized computation? • We have seen an example of a problem in BPP that we only know how to solve deterministically in EXP. Is randomness a panacea for intractability? CS21 Lecture 25

32. Randomized complexity classes ZPP coRP RP P PSPACE BPP EXP • believed that P = ZPP = RP = coRP = BPP (!) CS21 Lecture 25