123 Views

Download Presentation
##### Upper and Lower Bounds for Recursive Fourier Sampling

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -

**Upper and Lower Bounds for Recursive Fourier Sampling**Benjamin Johnson May 9, 2008 Thesis Defense**Outline**Introduction Definition of Recursive Fourier Sampling Overview of Results in Thesis Conclusion**Introduction**• Why study the recursive Fourier sampling problem? • It is a straightforward recursive extension of a simple problem from linear algebra, with interesting features • It is important to quantum complexity theory • It is important to classical circuit complexity • Why not study this problem? • It is hard**Definition of Recursive Fourier Sampling (1/3)**• Start with the non-recursive version, FSn, the Fourier Sampling problem • Given query access to the truth tables of a pair (f,g) of n-bit Boolean functions, (i.e. f,g:{0,1}n {0,1}) • And promised that fis a linear function of the form f(x)=sx, for some “secret string” s in {0,1}n • The challenge is to determine g(s), while minimizing the number of queries • Classically, this problem requires n+1 queries; but there is a quantum algorithm for it that uses only 2 quantum queries**Definition of Recursive Fourier Sampling (2/3)**• Adding Recursion • We can amplify the hardness of the Fourier sampling problem by composing it with itself in a certain way • Instead of being able to query the individual bits of f, we must now solve a new version of FSn to get each bit**Definition of Recursive Fourier Sampling (3/3)**• Repeating the composition for h steps gives us recursive Fourier sampling with height h, which we call RFSn,h • In the thesis, we develop a comprehensive notation for this problem • Functions to be queried: g0,g1,…,gh • Secret strings witnessing promises: s1,…,sh • We also relate the new notation to recursive Fourier sampling trees**Overview of Results**Quantum Query Complexity Classical Query Complexity Polynomial Degree Circuit Size**Quantum Query Complexity**We give an explicit exact quantum algorithm for RFSn,h We recursively construct a quantum circuit that implements the algorithm**Classical Query Complexity**• Main Result: RFSn,hrequiesnΩ(h) queries, or else the answer is almost unbiased • In the thesis, we give a new proof of this lower bound with better constants • We also give complete proofs of complexity class separations relative to oracles that follow from this result • Other query complexity results for a versions of FSn in which g is a known bent function**Polynomial Degree**• For every n and h, we construct a polynomial of degree h+1 that represents RFSn,h exactly • We prove an exactly matching degree lower bound, for any polynomial weakly-representing RFSn,h • To prove this result, we define two notions: • Weak representation on a partial domain, and • Reduction relative to a partial domain**Weak Representation on a Partial Domain**Let D be a subset of {0,1}n, and let f be a partial Boolean function with domain D. A (real) polynomial P weakly 0-represents f on D if P(x)=0 whenever f(x)=0, and P restricted to D is not the constant zero polynomial Our main result for polynomials is that any polynomial weakly 0-representing (or 1-representing) RFSn,h on its domain must have degree at least h+1**Reduction Relative to a Partial Domain**• Define a partial order on polynomials with respect to a domain D • P’<P iff P’ can be obtained from P by replacing some of its variables in some of its monomials with constants • A polynomial is reduced relative to D if no smaller polynomial (under this ordering) computes the same function on D**Polynomial Degree Lower Bound Proof Sketch**• Two key lemmas allow us to obtain our main polynomial degree result through the process of factoring monomials • Reduction Lemma: If P is reduced on D, and a monomial M occurs in P, then the quotient Q of M in P is reduced on D, and there exists an X in D such that Q(X)≠0 • Invariance Lemma: If G in D, and the monomial M occurs in P, and P(G) is invariant under bit changes to G for every combination of bits specified in M, then the quotient Q of M in P satisfies Q(G)=0 • The proof of the main polynomial degree result uses induction on h with a suitably strong induction hypothesis. If P weakly represents RFSn,h on its domain, it contains some maximal monomial M containing variables of the form gh(y). We use the reduction lemma, the invariance lemma, and additional structural properties of RFSn,h to show that the factor Q of M in P weakly represents a problem on D to which our induction hypothesis applies, and hence has degree at least h. We conclude that P has degree at least h+1**Circuit Size**We construct depth two circuits for RFSn,hof size exp(nΩ(h)) We prove an exactly matching circuit size lower bound for FSn even with unrestricted depth We prove an asymptotically tight depth two circuit size lower bound for RFSn,h**Circuit Size Lower Bound for FSn**Theorem: Let G1,…,Gr be functions computable by either an AND of literals or an OR of literals over the variables of FSn, and let M:{0,1}r{0,1} be monotone. If r<2n, then there exists a valid input (f,g) to FSn such that M(G1(f,g),…,Gr(f,g)) ≠ FSn(f,g).**Proof Sketch of Theorem**The domain of FSn can be divided naturally into 2n pieces depending on which s in {0,1}n witnesses the linearity of f. We define a way to measure the effort that a collection of depth-one circuits (gates) can expend on each piece, in such a way that the effort a single gate can contribute is at most 1. If there are fewer than 2n gates, there must be a candidate for s for which the total effort expended by the set of gates is strictly less than 1. We use this condition to construct a valid input with secret string s, that forces to constant the gates containing g(s) as a positive literal, without forcing the value of g(s). We show that changing g(s) in this input, no monotone function of the output of these gates can change its answer appropriately, and thus must be incorrect.**Material Omitted from Thesis**Higher Depth Circuit Constructions Recursive Procedure Generalization Recursive Parity Problem**Conclusion**Made a substantial effort to understand a difficult problem Developed a reference to aid future study Improved previous upper and lower bounds Obtained new tight upper and lower bounds Introduced new lower bound techniques based on “Reduction” and “Effort” Left the penultimate conjecture open**The End**Questions?