DOCSLIB.ORG

Lecture 10: Learning DNF, AC0, Juntas Feb 15, 2007 Lecturer: Ryan O’Donnell Scribe: Elaine Shi

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Lecture 10: Learning DNF, AC0, Juntas Feb 15, 2007 Lecturer: Ryan O’Donnell Scribe: Elaine Shi Analysis of Boolean Functions (CMU 18-859S, Spring 2007) Lecture 10: Learning DNF, AC0, Juntas Feb 15, 2007 Lecturer: Ryan O’Donnell Scribe: Elaine Shi 1 Learning DNF in Almost Polynomial Time From previous lectures, we have learned that if a function f is ǫ-concentrated on some collection , then we can learn the function using membership queries in poly( , 1/ǫ)poly(n) log(1/δ) time.S |S| O( w ) In the last lecture, we showed that a DNF of width w is ǫ-concentrated on a set of size n ǫ , and O( w ) concluded that width-w DNFs are learnable in time n ǫ . Today, we shall improve this bound, by showing that a DNF of width w is ǫ-concentrated on O(w log 1 ) a collection of size w ǫ . We shall hence conclude that poly(n)-size DNFs are learnable in almost polynomial time. Recall that in the last lecture we introduced H˚astad’s Switching Lemma, and we showed that 1 DNFs of width w are ǫ-concentrated on degrees up to O(w log ǫ ). Theorem 1.1 (Hastad’s˚ Switching Lemma) Let f be computable by a width-w DNF, If (I, X) is a random restriction with -probability ρ, then d N, ∗ ∀ ∈ d Pr[DT-depth(fX→I) >d] (5ρw) I,X ≤ Theorem 1.2 If f is a width-w DNF, then f(U)2 ǫ ≤ |U|≥OX(w log 1 ) ǫ b O(w log 1 ) To show that a DNF of width w is ǫ-concentrated on a collection of size w ǫ , we also need the following theorem: Theorem 1.3 If f is a width-w DNF, then 1 |U| f(U) 2 20w | | ≤ XU b Proof: Let (I, X) be a random restriction with -probability 1 . After this restriction, the DNF ∗ 20w becomes a O(1)-depth decision tree with high probability. Due to H˚astad’s Switching Lemma, we 1 have the following: n E [ fX→I 1]= Pr [DT-depth(fX→I)= d] E fX→I 1 DT-depth(fX→I)= d I,X k k I,X · I,X k k Xd=0 n 1 d 5 w 2d (H˚astad’s Switching Lemma, DT of size s has L Fourier norm s) ≤ · 20w · · 1 ≤ Xd=0 n 1 = 2 2d ≤ Xd=0 In addition, we have 2 E [ fX→I 1]= E E fX→I(S) I,X I X ≥ k k I XS⊆ b = E E E [fX→I(y)yS] I X y∈{−1,1}I XS⊆I > E E E[f(y, X)yS] = E f(S) I X y I I I XS⊆ XS⊆ b |U| 1 = f(U) Pr[U I]= f(U) · I ⊆ · 20w UX⊆[n] UX⊆[n] b b 2 Corollary 1.4 If f is a width-w DNF, then O(w log 1 ) f(U) w ǫ ≤ |U|≤OX(w log 1 ) ǫ b Proof: 1 |U| 1 |U| 2 f(U) f(U) ≥ · 20w ≥ · 20w UX⊆[n] |U|≤OX(w log 1 ) ǫ b b O(w log 1 ) 1 ǫ f(U) ≥ 20w |U|≤OX(w log 1 ) ǫ b 2 O(w log 1 ) Corollary 1.5 If f is a width-w DNF, it’s ǫ-concentrated on a collection of size w ǫ . 2 1 ǫ Proof: Define = U : U O(w log ), f(U) 1 . By Parseval, we get that S | | ≤ ǫ ≥ wO(w log ǫ ) |S| ≤ O(w log 1 ) n o w ǫ . We now show that is ǫ-concentrated b on . By Theorem 1.2, we know that S S f(U)2 ǫ ≤ UX∈S / 1 |U|≥O(w log ǫ ) b By Corollary 1.4, we have 2 O(w log 1 ) ǫ f(U) f(U) max f(U) w ǫ = ǫ O(w log 1 ) ≤ · ≤ · ǫ UX∈S / UX∈S / w |U|≤O(w log 1 ) b |U|≤O(w log 1 ) b b ǫ ǫ Therefore, f is 2ǫ-concentrated on . 2 S Corollary 1.6 poly(n)-size DNFs are ǫ-concentrated on collections of size O(log n log 1 ) O(log log n ·log 1 ) n ǫ ǫ n ǫ ǫ log = ǫ ǫ And if ǫ = Θ(1), then the above is nO(log log n). Note that this uses the fact that size-n DNF formulas n are ǫ-close to a width-log( ǫ ) DNF. An open research problem is the following question: Are poly(n)-size DNFs ǫ-concentrated on a collection of size poly(n), assuming that ǫ = Θ(1). 2 LearningAC0 We will now study how to learn polynomial-size, constant-depth circuits, AC0. Consider circuits with unbounded fan-in AND, OR, and NOT gates. The size of the circuit is defined as the number of AND/OR gates. Observe the following fact: Fact 2.1 Let d denote the depth of the circuit. At the expense of a factor of d in size, these circuits can be taken to be “layered”. Here “layered” means that eacy layer consists of the same type of gates, either AND or OR, and adjacent layers contain the opposite gates. In a layered circuit, the number of layers is the depth of the circuit, and define the bottom fan-in of a layered circuit to be the maximum fan-in at the lowest layer (i.e. closest to the input layer). Theorem 2.2 (LMN.) Let f be computable by a size s, depth D, and bottom fan-in w circuit. Then ≤ ≤ ≤ f(U)2 O(s 2−w) ≤ · X D |U|≥(10w) b 3 Before we show a proof of the LMN theorem, let us first look at some corollaries implied by this theorem. Corollary 2.3 If f has a size s, depth D circuit, then f(U)2 ǫ ≤ |U|≥[OX(log s )]D ǫ b Proof: Notice that such an f is ǫ-close to a similar circuit with bottom fan-in log( s ). 2 ≤ ǫ Corollary 2.4 AC0, i.e., the class of poly-size, constant-depth circuits, are learnable from random poly(log( n )) examples in time n ǫ , where n denotes the size of the circuit. 0 poly(log( n )) Proof: According to Corollary 2.3, AC circuits are ǫ-concentrated on a collection of size n ǫ . 2 Corollary 2.5 If f has a size-s, depth-D circuit, then I(f) [O(log s)]D ≤ Remark 2.6 Due to Hastad,˚ the above bound can be improved to [O(log s)]D−1. Proof:(sketch.) Define F (τ)= f(U)2. Recall that |UP|>τ b b n O(log s)D n I(f)= U f(U)2 = F (r)= F (r)+ F (r) | | XU Xr=1 Xr=1 X D b b b r=O(log s) b n = U f(U)2 + F (O(log s)D) O(log s)D + F (r) | | · X D X D |U|≤O(log s) b b r=O(log s) b n O(log s)D + F (r) ≤ X D r=O(log s) b n It remains to show that F (r) O(log s)D. By Corollary 2.3, r=O(log s)D ≤ P b 1/D F (τ)= f(U)2 s 2−Ω(τ ) ≤ · |UX|>τ b b n Using this fact plus some manipulation, it is not hard to show that F (r) O(log s)D. 2 D ≤ r=OP(log s) b Using this fact, we can derive the following two corollaries: 4 Corollary 2.7 Parity / AC0, Majority / AC0. ∈ ∈ Proof: I(Parity)= n, I(Majority)=Θ(√n). 2 Definition 2.8 (PRFG.) A function f : 1, 1 m 1, 1 n 1, 1 is a Pseudo-Random Function Generator (PRFG), if for all Probablistic{− } × {−Polynom} ial→ Time {− (P.P.T)} algorithm A with access to a function, 1 Pr [A(f(S, )) = YES] Pr [A(g)= YES] S⊆{−1,1}m, · − g, ≤ nω(1) A’s random bits A’s random bits where g is a function picked at random from all functions h h : 1, 1 n 1, 1 . { | {− } → {− }} Corollary 2.9 Psuedo-random function generators / AC0. ∈ Proof: Suppose that f AC0. Then we can construct a P.P.T adversary A such that A can tell f ∈ apart from a truly random function with non-negligible probability. Consider an adversary A that picks at random X 1, 1 n, and i [n]. A is given an oracle to g, it queries g at X and X(i). A outputs YES iff g∈(X {−) = g(}X(i)). ∈ 6 If g is truly random, then Pr[A outputs YES]=1/2; if g is in AC0, then Pr[A outputs YES] I(g)/n = polylog(n)/n. 2 ≤ After seeing all these applications of the LMN theorem, we now show how to prove it. To prove the LMN theorem, we need the the following tools: Observation 2.10 A depth-w Decision Tree (DT) is expressible as a width-w DNF or as a width-w CNF. Lemma 2.11 Let f : 1, 1 n 1, 1 , let (I, X) be a random restriction with -probability {− } → {− } ∗ ρ. Then d 5, ∀ ≥ 2 f(U) 2 Pr [DT-depth(fX→I) >d] ≤ (I,X) |UX|≥2d/ρ b Now using Lemma 2.11, we can prove the LMN theorem. Proof:(LMN.) Claim 2.12 −w Pr [DT-depth(fX→I) >w] s 2 I,X ≤ · The above claim in combination with Lemma 2.11 would complete the proof.
Load more

Recommended publications
  • Randomised Computation 1 TM Taking Advices 2 Karp-Lipton Theorem
    INFR11102: Computational Complexity 29/10/2019 Lecture 13: More on circuit models; Randomised Computation Lecturer: Heng Guo 1 TM taking advices An alternative way to characterize P=poly is via TMs that take advices. Definition 1. For functions F : N ! N and A : N ! N, the complexity class DTime[F ]=A consists of languages L such that there exist a TM with time bound F (n) and a sequence fangn2N of “advices” satisfying: • janj ≤ A(n); • for jxj = n, x 2 L if and only if M(x; an) = 1. The following theorem explains the notation P=poly, namely “polynomial-time with poly- nomial advice”. S c Theorem 1. P=poly = c;d2N DTime[n ]=nd . Proof. If L 2 P=poly, then it can be computed by a family C = fC1;C2; · · · g of Boolean circuits. Let an be the description of Cn, andS the polynomial time machine M just reads 2 c this description and simulates it. Hence L c;d2N DTime[n ]=nd . For the other direction, if a language L can be computed in polynomial-time with poly- nomial advice, say by TM M with advices fang, then we can construct circuits fDng to simulate M, as in the theorem P ⊂ P=poly in the last lecture. Hence, Dn(x; an) = 1 if and only if x 2 L. The final circuit Cn just does exactly what Dn does, except that Cn “hardwires” the advice an. Namely, Cn(x) := Dn(x; an). Hence, L 2 P=poly. 2 Karp-Lipton Theorem Dick Karp and Dick Lipton showed that NP is unlikely to be contained in P=poly [KL80].
    [Show full text]
  • BQP and the Polynomial Hierarchy 1 Introduction
    BQP and The Polynomial Hierarchy based on `BQP and The Polynomial Hierarchy' by Scott Aaronson Deepak Sirone J., 17111013 Hemant Kumar, 17111018 Dept. of Computer Science and Engineering Dept. of Computer Science and Engineering Indian Institute of Technology Kanpur Indian Institute of Technology Kanpur Abstract The problem of comparing two complexity classes boils down to either finding a problem which can be solved using the resources of one class but cannot be solved in the other thereby showing they are different or showing that the resources needed by one class can be simulated within the resources of the other class and hence implying a containment. When the relation between the resources provided by two classes such as the classes BQP and PH is not well known, researchers try to separate the classes in the oracle query model as the first step. This paper tries to break the ice about the relationship between BQP and PH, which has been open for a long time by presenting evidence that quantum computers can solve problems outside of the polynomial hierarchy. The first result shows that there exists a relation problem which is solvable in BQP, but not in PH, with respect to an oracle. Thus gives evidence of separation between BQP and PH. The second result shows an oracle relation problem separating BQP from BPPpath and SZK. 1 Introduction The problem of comparing the complexity classes BQP and the polynomial heirarchy has been identified as one of the grand challenges of the field. The paper \BQP and the Polynomial Heirarchy" by Scott Aaronson proves an oracle separation result for BQP and the polynomial heirarchy in the form of two main results: A 1.
    [Show full text]
  • NP-Complete Problems and Physical Reality
    NP-complete Problems and Physical Reality Scott Aaronson∗ Abstract Can NP-complete problems be solved efficiently in the physical universe? I survey proposals including soap bubbles, protein folding, quantum computing, quantum advice, quantum adia- batic algorithms, quantum-mechanical nonlinearities, hidden variables, relativistic time dilation, analog computing, Malament-Hogarth spacetimes, quantum gravity, closed timelike curves, and “anthropic computing.” The section on soap bubbles even includes some “experimental” re- sults. While I do not believe that any of the proposals will let us solve NP-complete problems efficiently, I argue that by studying them, we can learn something not only about computation but also about physics. 1 Introduction “Let a computer smear—with the right kind of quantum randomness—and you create, in effect, a ‘parallel’ machine with an astronomical number of processors . All you have to do is be sure that when you collapse the system, you choose the version that happened to find the needle in the mathematical haystack.” —From Quarantine [31], a 1992 science-fiction novel by Greg Egan If I had to debate the science writer John Horgan’s claim that basic science is coming to an end [48], my argument would lean heavily on one fact: it has been only a decade since we learned that quantum computers could factor integers in polynomial time. In my (unbiased) opinion, the showdown that quantum computing has forced—between our deepest intuitions about computers on the one hand, and our best-confirmed theory of the physical world on the other—constitutes one of the most exciting scientific dramas of our time.
    [Show full text]
  • 0.1 Axt, Loop Program, and Grzegorczyk Hier- Archies
    1 0.1 Axt, Loop Program, and Grzegorczyk Hier- archies Computable functions can have some quite complex definitions. For example, a loop programmable function might be given via a loop program that has depth of nesting of the loop-end pair, say, equal to 200. Now this is complex! Or a function might be given via an arbitrarily complex sequence of primitive recursions, with the restriction that the computed function is majorized by some known function, for all values of the input (for the concept of majorization see Subsection on the Ackermann function.). But does such definitional|and therefore, \static"|complexity have any bearing on the computational|dynamic|complexity of the function? We will see that it does, and we will connect definitional and computational complexities quantitatively. Our study will be restricted to the class PR that we will subdivide into an infinite sequence of increasingly more inclusive subclasses, Si. A so-called hierarchy of classes of functions. 0.1.0.1 Definition. A sequence (Si)i≥0 of subsets of PR is a primitive recur- sive hierarchy provided all of the following hold: (1) Si ⊆ Si+1, for all i ≥ 0 S (2) PR = i≥0 Si. The hierarchy is proper or nontrivial iff Si 6= Si+1, for all but finitely many i. If f 2 Si then we say that its level in the hierarchy is ≤ i. If f 2 Si+1 − Si, then its level is equal to i + 1. The first hierarchy that we will define is due to Axt and Heinermann [[5] and [1]].
    [Show full text]
  • Quantum Computational Complexity Theory Is to Un- Derstand the Implications of Quantum Physics to Computational Complexity Theory
    Quantum Computational Complexity John Watrous Institute for Quantum Computing and School of Computer Science University of Waterloo, Waterloo, Ontario, Canada. Article outline I. Definition of the subject and its importance II. Introduction III. The quantum circuit model IV. Polynomial-time quantum computations V. Quantum proofs VI. Quantum interactive proof systems VII. Other selected notions in quantum complexity VIII. Future directions IX. References Glossary Quantum circuit. A quantum circuit is an acyclic network of quantum gates connected by wires: the gates represent quantum operations and the wires represent the qubits on which these operations are performed. The quantum circuit model is the most commonly studied model of quantum computation. Quantum complexity class. A quantum complexity class is a collection of computational problems that are solvable by a cho- sen quantum computational model that obeys certain resource constraints. For example, BQP is the quantum complexity class of all decision problems that can be solved in polynomial time by a arXiv:0804.3401v1 [quant-ph] 21 Apr 2008 quantum computer. Quantum proof. A quantum proof is a quantum state that plays the role of a witness or certificate to a quan- tum computer that runs a verification procedure. The quantum complexity class QMA is defined by this notion: it includes all decision problems whose yes-instances are efficiently verifiable by means of quantum proofs. Quantum interactive proof system. A quantum interactive proof system is an interaction between a verifier and one or more provers, involving the processing and exchange of quantum information, whereby the provers attempt to convince the verifier of the answer to some computational problem.
    [Show full text]
  • PR Functions Are Computable, PR Predicates) Lecture 11: March
    Theory of Formal Languages (PR Functions are computable, PR Predicates) Lecture 11: March. 30, 2021 Prof. K.R. Chowdhary : Professor of CS Disclaimer: These notes have not been subjected to the usual scrutiny reserved for formal publications. They may be distributed outside this class only with the permission of the Instructor. 11.1 PR functions are Computable We want to show that every PR function is mechanically computable. Given the general strategy we described in previous section, it is enough to show it in three statements: 1. The basic functions (Z,S,P ) are computable. 2. If f is defined by composition from computable functions g and h, then f is also computable. 3. If f is defined by primitive recursion from the computable functions g and h, then f is also computable. k The statement ‘1.’ above is trivial: the initial functions S (successor), Z (zero), and Pi (projection) are effectively computable by a simple algorithm; and statement ‘2.’ – the composition of two computable functions g and h is computable (we just feed the output from whatever algorithmic routine evaluates g as input, into the routine that evaluates h). To illustrate statement ‘3.’ above, return to factorial function, defined as: 0!=1 (Sy)! = y! × Sy The first clause gives the value of the function for the argument 0;,then we repeatedly use the second clause which is recursion, to calculate the function’s value for S0, then for SS0, SSS0, etc. The definition encapsulates an algorithm for calculating the function’s value for any number, and corresponds exactly to a certain simple kind of computer routine.
    [Show full text]
  • General Models of Computation
    General Models of Computation Introduction When thinking of the meaning of computation, we are often led to the notion of algorithm, i.e. a process or set of rules to be followed in a step-by-step manner for the purpose of producing a desired outcome. This definition may seem somewhat vague and informal, and for this reason, over the past century, mathematicians and computer scientists have formally defined several models of computation that attempt to capture the notion of algorithm. Moreover, a general model of computation (GMC), is one that purports to encompass all possible algorithms. As an example, a general programming language, such as Java, is a general model of computation, since every Java program induces a process that can be followed in a step-by-step manner by adhering to the program's control statements. However, how do we know that any algorithm can be realized by some Java program? A GMC is said to be complete provided it can realize all possible algorithms. The problem with proving that a GMC is complete lies in the fact that, again, there is no a priori formal definition of algorithm. Now, suppose A and B are two different GMC's. Then we write 1. A ≤ B iff every algorithm realizable by A can also be realized by B 2. A < B iff there is an algorithm that can be realized by B, but not by A 3. A ≡ B, read as \A is equivalent to B" iff both A ≤ B and B ≤ A. Then the best we can do is to modify our definition of completeness to mean that A is complete iff there is some complete B for which A ≡ B.
    [Show full text]
  • Hierarchies of Recursive Functions
    Leibniz Universitat¨ Hannover Institut f¨urtheoretische Informatik Bachelor Thesis Hierarchies of recursive functions Maurice Chandoo February 21, 2013 Erkl¨arung Hiermit versichere ich, dass ich diese Arbeit selbst¨andigverfasst habe und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe. i Dedicated to my dear grandmother Anna-Maria Kniejska ii Contents 1 Preface 1 2 Class of primitve recursive functions PR 2 2.1 Primitive Recursion class PR ..................2 2.2 Course-of-value Recursion class PRcov .............4 2.3 Nested Recursion class PRnes ..................5 2.4 Recursive Depth . .6 2.5 Recursive Relations . .6 2.6 Equivalence of PR and PRcov .................. 10 2.7 Equivalence of PR and PRnes .................. 12 2.8 Loop programs . 14 2.9 Grzegorczyk Hierarchy . 19 2.10 Recursive depth Hierarchy . 22 2.11 Turing Machine Simulation . 24 3 Multiple and µ-recursion 27 3.1 Multiple Recursion class MR .................. 27 3.2 µ-Recursion class µR ....................... 32 3.3 Synopsis . 34 List of literature 35 iii 1 Preface I would like to give a more or less exhaustive overview on different kinds of recursive functions and hierarchies which characterize these functions by their computational power. For instance, it will become apparent that primitve recursion is more than sufficiently powerful for expressing algorithms for the majority of known decidable ”real world” problems. This comes along with the hunch that it is quite difficult to come up with a suitable problem of which the characteristic function is not primitive recursive therefore being a possible candidate for exploiting the more powerful multiple recursion. At the end the Turing complete µ-recursion is introduced.
    [Show full text]
  • Ion-Size Effect on Superconducting Transition Temperature Tc in …Er, Dy, Gd, Eu, Sm, and Nd؍R1؊X؊Yprxcayba2cu3o7؊Z Systems „R Li-Chun Tung, J
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by National Tsing Hua University Institutional Repository PHYSICAL REVIEW B VOLUME 59, NUMBER 6 1 FEBRUARY 1999-II Ion-size effect on superconducting transition temperature Tc in R12x2yPrxCayBa2Cu3O72z systems „R5Er, Dy, Gd, Eu, Sm, and Nd… Li-Chun Tung, J. C. Chen, M. K. Wu, and Weiyan Guan Department of Physics, National Tsing Hua University, Hsinchu, 300, Taiwan, Republic of China ~Received 14 September 1998! We observed a rare-earth ion-size effect on Tc in R12x2yPrxCayBa2Cu3O72z ~R5Er, Dy, Gd, Eu, Sm, and Nd! systems which is similar to that in R12xPrxBa2Cu3O72z systems in our previous reports. For fixed Pr and 31 Ca concentration ~fixed x and y!, Tc is linearly dependent on rare-earth ion radius rR . For a fixed Pr concentration x, there exists a maximum of Tc (Tc,max)inTc vs Ca concentration y curves. Tc,max shifts to higher Ca concentration region for samples with larger R ion radius. The enhancement of Tc ~DTc,max 5Tc,max2Tc,y50 ; Tc,y50 is the transition temperature Tc without Ca doping! increases with increasing R ion 31 radius. We proposed an empirical formula for Tc (rR ,x,y) to fit our experimental data: Tc(x,y)5Tc0 2 2 2 2Ab (a/x1y/b) 2Bx. All fitting parameters in this formula, Tc0 , B, b, a/b, and Ab , are rare-earth ion-size dependent. @S0163-1829~99!01506-4# I. INTRODUCTION tration x. It suggests that Pr ions are trivalent and localize, rather than fill, the mobile holes on CuO2 planes.
    [Show full text]
  • Quantum Complexity Theory
    QQuuaannttuumm CCoommpplelexxitityy TThheeooryry IIII:: QQuuaanntutumm InInterateracctivetive ProofProof SSysystemtemss John Watrous Department of Computer Science University of Calgary CCllaasssseess ooff PPrroobblleemmss Computational problems can be classified in many different ways. Examples of classes: • problems solvable in polynomial time by some deterministic Turing machine • problems solvable by boolean circuits having a polynomial number of gates • problems solvable in polynomial space by some deterministic Turing machine • problems that can be reduced to integer factoring in polynomial time CComommmonlyonly StudStudiedied CClasseslasses P class of problems solvable in polynomial time on a deterministic Turing machine NP class of problems solvable in polynomial time on some nondeterministic Turing machine Informally: problems with efficiently checkable solutions PSPACE class of problems solvable in polynomial space on a deterministic Turing machine CComommmonlyonly StudStudiedied CClasseslasses BPP class of problems solvable in polynomial time on a probabilistic Turing machine (with “reasonable” error bounds) L class of problems solvable by some deterministic Turing machine that uses only logarithmic work space SL, RL, NL, PL, LOGCFL, NC, SC, ZPP, R, P/poly, MA, SZK, AM, PP, PH, EXP, NEXP, EXPSPACE, . ThThee lliistst ggoesoes onon…… …, #P, #L, AC, SPP, SAC, WPP, NE, AWPP, FewP, CZK, PCP(r(n),q(n)), D#P, NPO, GapL, GapP, LIN, ModP, NLIN, k-BPB, NP[log] PP P , P , PrHSPACE(s), S2P, C=P, APX, DET, DisNP, EE, ELEMENTARY, mL, NISZK,
    [Show full text]
  • Randomized Computation, Chernoff Bounds. 1 Randomized Time Complexity
    Notes on Computer Theory Last updated: November, 2015 Randomized computation, Chernoff bounds. Notes by Jonathan Katz, lightly edited by Dov Gordon. 1 Randomized Time Complexity Is deterministic polynomial-time computation the only way to define \feasible" computation? Al- lowing probabilistic algorithms, that may fail with tiny probability, seems reasonable. (In particular, consider an algorithm whose error probability is lower than the probability that there will be a hard- ware error during the computation, or the probability that the computer will be hit by a meteor during the computation.) This motivates our exploration of probabilistic complexity classes. There are two different ways to define a randomized model of computation. The first is via Tur- ing machines with a probabilistic transition function: as in the case of non-deterministic machines, we have a Turing machine with two transitions functions, and a random one is applied at each step. The second way to model randomized computation is by augmenting Turing machines with an additional (read-only) random tape. For the latter approach, one can consider either one-way or two-way random tapes; the difference between these models is unimportant for randomized time complexity classes, but (as we will see) becomes important for randomized space classes. Whichever approach we take, we denote by M(x) a random computation of M on input x, and by M(x; r) the (deterministic) computation of M on input x using random choices r (where, in the first case, the ith bit of r determines which transition function is used at the ith step, and in the second case r is the value written on M's random tape).
    [Show full text]
  • Quantum Interactive Proofs and the Complexity of Separability Testing
    THEORY OF COMPUTING www.theoryofcomputing.org Quantum interactive proofs and the complexity of separability testing Gus Gutoski∗ Patrick Hayden† Kevin Milner‡ Mark M. Wilde§ October 1, 2014 Abstract: We identify a formal connection between physical problems related to the detection of separable (unentangled) quantum states and complexity classes in theoretical computer science. In particular, we show that to nearly every quantum interactive proof complexity class (including BQP, QMA, QMA(2), and QSZK), there corresponds a natural separability testing problem that is complete for that class. Of particular interest is the fact that the problem of determining whether an isometry can be made to produce a separable state is either QMA-complete or QMA(2)-complete, depending upon whether the distance between quantum states is measured by the one-way LOCC norm or the trace norm. We obtain strong hardness results by proving that for each n-qubit maximally entangled state there exists a fixed one-way LOCC measurement that distinguishes it from any separable state with error probability that decays exponentially in n. ∗Supported by Government of Canada through Industry Canada, the Province of Ontario through the Ministry of Research and Innovation, NSERC, DTO-ARO, CIFAR, and QuantumWorks. †Supported by Canada Research Chairs program, the Perimeter Institute, CIFAR, NSERC and ONR through grant N000140811249. The Perimeter Institute is supported by the Government of Canada through Industry Canada and by the arXiv:1308.5788v2 [quant-ph] 30 Sep 2014 Province of Ontario through the Ministry of Research and Innovation. ‡Supported by NSERC. §Supported by Centre de Recherches Mathematiques.´ ACM Classification: F.1.3 AMS Classification: 68Q10, 68Q15, 68Q17, 81P68 Key words and phrases: quantum entanglement, quantum complexity theory, quantum interactive proofs, quantum statistical zero knowledge, BQP, QMA, QSZK, QIP, separability testing Gus Gutoski, Patrick Hayden, Kevin Milner, and Mark M.
    [Show full text]