Quantum computing promises to allow the efficient solution of certain problems believed to be intractable for classical computers, and is therefore of great practical interest. From a mathematical perspective, another important contribution of quantum computing is the rise of the “quantum method” as a proof technique. That is, often one can prove purely classical (i.e., not quantum) mathematical statements using techniques from quantum information for which no classical proof is known, or where the quantum proof is substantially simpler than its classical counterpart.111This is analogous to how it is sometimes easier to prove a statement about real numbers using complex numbers, as expressed in the following quote usually attributed to Jacques Hadamard [Kah91]: “The shortest path between two truths in the real domain passes through the complex domain”. For example, the non-existence of efficient 2-locally-decodable codes was first proven using quantum arguments [KdW03]. The closure of the classical complexity class PP under intersection was first shown using classical techniques by Beigel, Reingold, and Spielman [BRS95], but Aaronson showed it could be reproven using quantum techniques in a simpler way [Aar05]. The survey by Drucker and de Wolf provides more examples of this proof technique [DW11].
In this work, we apply the quantum method to resolve several composition questions for classical complexity measures in query complexity and communication complexity. A quintessential example of this type of question is the -composition question, which asks the following: Given a function , how hard is it to compute the function , the of copies of ? One particular strategy for computing is to compose the best algorithms for and in the given model of computation. For many complexity measures (including all the measures studied in this paper), the product of the complexities of and will yield an upper bound on the complexity of . Typically, we conjecture that this upper bound is optimal, but it is not obvious that this must be the case, and hence establishing such a lower bound is usually difficult (or possibly even false for some complexity measures). For example, it is known that this upper bound is optimal for deterministic [Tal13, Mon14] and quantum query complexity [Rei11, LMR11], but was only recently established for randomized query complexity [GJPW17].
In this paper we show an optimal -composition result for approximate degree, a complexity measure in query complexity first studied by Nisan and Szegedy [NS94], which lower bounds quantum query complexity [BBC01], and a nearly optimal -composition theorem for approximate rank (or approximate -norm or generalized discrepancy), a measure in communication complexity which lower bounds quantum communication complexity [BdW01, LS09a].
Our results significantly generalize previous -composition results for these measures. For instance, -composition for approximate degree was open for close to 20 years just for the special case that is the function! After several incremental improvements (see Table 1) by Shi [Shi02], Ambainis [Amb05], and Sherstov [She13b], the problem was recently resolved by Sherstov [She13a] and Bun and Thaler [BT13]
using a linear programming characterization of approximate degree.
In contrast, we show a tight -composition theorem for approximate degree for arbitrary functions , generalizing these works and newer results on constant-depth compositions of the and functions [BT15]. (In fact, we also provide an optimal lower bound on the approximate degree of the of possibly different functions .)
In communication complexity, to the best of our knowledge no -composition result was known for approximate rank. Indeed, such a result would directly imply Razborov’s celebrated lower bound on the quantum communication complexity of the disjointness function [Raz03]. To highlight the power of our techniques, we provide a short proof of the lower bound for disjointness. We also provide a more direct proof of the recent lower bound on the quantum information complexity of disjointness [BGK15].
Symmetric function composition.
We then generalize our -composition results to hold for compositions with arbitrary symmetric functions, which are functions that only depend on the Hamming weight of the input. Other than , compositions with symmetric functions like parity and majority have been studied in complexity theory. For instance, the question of how difficult it is to compute was already studied in 1982 in Yao’s seminal paper on the lemma [Yao82] (see [O’D04] for a general composition theorem for in this setting.). Since the class of symmetric functions includes the function, proving composition theorems for arbitrary symmetric functions is even harder. Such composition theorems are known for deterministic [Tal13, Mon14] and quantum query complexity [Rei11, LMR11]. But it remains open to show a similar theorem for randomized query complexity, where only partial results are known [GLS18, San18].
Although the final results for approximate degree and approximate rank are purely classical, our proofs use quantum algorithms in a crucial way, and there is no known classical proof of these results. We therefore believe this to be a powerful example of the “quantum method” [DW11]. However, we only use quantum algorithms in a black-box manner and the reader is not required to be familiar with quantum query complexity. We only use its relationship with polynomials due to Beals et al. [BBC01] and the existence of a quantum algorithm for the combinatorial group testing problem due to Belovs [Bel15].
Another salient feature of our proofs is that our lower bounds on various measures like approximate degree are proven using the existence of very fast quantum algorithms for related problems. This is part of a recent trend in complexity theory, sometimes called “ironic complexity theory” [Aar16], in which lower bounds are proven using upper bounds. For instance, Williams’ celebrated circuit lower bound for uses this approach [Wil14].
Our approach of using a fast quantum algorithm (by Belovs [Bel15]) to prove lower bounds is inspired by the recent work of Hoza [Hoz17], who showed that fast quantum algorithms for certain query problems imply lower bounds in communication complexity. Hoza’s work was, in turn, inspired by work of Cleve, van Dam, Nielsen, and Tapp [CvDNT13], who used the Bernstein–Vazirani algorithm [BV97] to prove the first lower bound on the quantum communication complexity (with unlimited shared entanglement) of the inner product function. Similar proof techniques were also used by Buhrman and de Wolf [BdW98] to show a lower bound on the quantum query complexity of searching a sorted list by a reduction to the hardness of computing parity.
1.1 Our results
We now describe our results in more detail.
1.1.1 Approximate degree
For any Boolean function , the approximate degree of , denoted , is the minimum degree of any real polynomial over the variables , such that for all . Note that for all Boolean functions since any Boolean function can be represented exactly with a polynomial of degree . Also note that negating the output of a function does not change its approximate degree, and neither does negating input bits. Hence and results for one function carry over to the others.
Approximate degree was first studied by Nisan and Szegedy [NS94]. Since then, it has been used to prove oracle separations, design learning algorithms, and show lower bounds on quantum query complexity, formulas size, and communication complexity. (See [She13a, She13c, BT13] and the references therein for more information.) It can be used to prove lower bounds on quantum query complexity because for all (total or partial) functions , we have [BBC01], where denotes the bounded-error quantum query complexity of .
Although approximate degree has a simple definition in terms of polynomials, several simple questions about this measure remain open. Surprisingly, even the approximate degree of the depth-2 AND-OR tree remained open for close to 20 years! In 2013, after several incremental improvements (described in Table 1), Sherstov [She13a] and Bun and Thaler [BT13] showed that
which is optimal [HMdW03]. These lower bounds were proved using a linear programming formulation of approximate degree, and exploited certain properties of the dual polynomial for the function. In contrast to these approaches using dual polynomials, our -composition result for approximate degree uses completely different techniques and is more general:
For any Boolean function , we have
This lower bound is tight due to a matching upper bound of Sherstov [She13c]. This resolves the -composition question for approximate degree. As an example, this now allows us to show the optimal bound , where is the majority function. Prior to our work, the best lower bound that could be proved with known techniques was .
After characterizing the approximate degree of the depth-2 - tree, Bun and Thaler [BT15] also proved that the approximate degree of the depth- - tree on inputs is . Theorem 1 straightforwardly implies the optimal bound of .
We then generalize Theorem 1 to a composition theorem for arbitrary symmetric functions . Our -composition theorem plays a central role in the proof of our symmetric-function composition theorem, which we discuss in Section 1.2.
For any symmetric Boolean function and any Boolean function , we have
This lower bound is also tight up to log factors due to a matching upper bound of Sherstov [She13c]. This resolves the symmetric-composition question for approximate degree.
1.1.2 Approximate rank or norm
In communication complexity, we have two players Alice and Bob, who hold inputs and respectively. Their goal is to compute a function on their inputs while minimizing the communication between them. One of the most studied functions in communication complexity is the set disjointness problem , defined as for all .
The quantum communication complexity of the disjointness problem was one of the early open problems in quantum communication complexity. Let denote the bounded-error quantum communication complexity of a function with unlimited preshared entanglement. Then it follows from Grover’s algorithm [Gro96] and the query-to-communication simulation algorithm of Buhrman, Cleve, and Wigderson [BCW98] that , which was later improved to [AA03]. However the lower bound remained open until a breakthrough by Razborov [Raz03], who showed that .
Razborov’s result actually lower bounds a smaller complexity measure. With any communication problem , we can associate a matrix, called the sign matrix of , whose entry is . Informally, the approximate rank of , denoted is the least rank of any matrix that is entry-wise close to the sign matrix of . (See Section 3 for a more precise definition.) Another measure that is essentially equivalent to approximate rank is the approximate -norm of the sign matrix of , which we denote , also defined in Section 3. For any function , lower bounds its quantum communication complexity, and Razborov’s result proves the stronger statement that .
We first show that our techniques yield a new proof of Razborov’s celebrated lower bound for disjointness.
Let be the set disjointness function defined as for all . Then
Note that this lower bound is tight due to the matching quantum algorithm of Aaronson and Ambainis [AA03]. Building on this, we generalize our result to an -composition theorem.222An astute reader may worry that an -composition theorem cannot possibly hold in communication complexity because some functions do not become harder as we take the of many copies of the function. For example, the function , defined as if and only if , can be solved with communication using a randomized or quantum protocol. Taking the of many copies of only yields a larger instance of , which is no harder than before. However, Theorem 4 still holds because .
For any function , we have .
We then generalize this proof to show a nearly optimal composition theorem for an arbitrary symmetric function and an arbitrary communication problem .
For any Boolean function , and any symmetric function , we have
Note that these lower bounds are also essentially tight, as a matching upper bound of can be proved by composing a polynomial for with a matrix for . (For example, this can be done using the construction in Lemma 30).
1.1.3 Further Extensions
We also prove two further extensions of our result. In Section 4.1, we generalize our tight -composition theorem for to the case of different functions . We show a tight lower bound on the approximate degree of the of possibly different functions (which may possibly even have different input sizes). This completely characterizes the approximate degree of this function, and furthermore implies that the approximate degree of any constant-depth read-once formula is . This lower bound is optimal, since an upper bound of is known for the approximate degree of arbitrary read-once formulas (not just constant-depth) via the upper bound on quantum query complexity [Rei11] and it is an interesting open question if this upper bound is tight for arbitrary read-once formulas.
is a information relaxation of quantum communication complexity, in the same sense that information complexity is a relaxation of communication complexity. Intuitively, instead of charging for the number of bits (or qubits) of communication if a protocol, information complexity only charges for the information transmitted by these bits (or qubits). We use our techniques to reprove thelower bound on the quantum information complexity of disjointness [BGK15] up to log factors. This lower bound is already known, but the known proof uses an alternate characterization of quantum information complexity as amortized quantum communication complexity. In contrast, our proof is more direct and works with the information theoretic definition of quantum information complexity.
1.2 High-level overview of techniques
While we prove several different lower bounds against measures in query and communication complexity, our proofs share several common techniques. In particular, all our proofs use Belovs’ algorithm for the combinatorial group testing problem [Bel15], which we now describe. Combinatorial group testing has a long history originating in the testing of World War II draftees for Syphilis [DHH00], where the goal was to minimize the number of tests used to screen recruits. The basic idea was to pool multiple blood samples together before testing them; the blood test then reveals if anyone in the pool has the disease. In other words the test reveals the of the draftee’s disease statuses within the group. One can easily see that if only one person has the disease, then one can use binary search to use only tests to identify which of people has the disease; similarly one can show that if people have the disease then tests suffice.
More formally, in this problem there is a hidden string . One is allowed to query any subset , and querying a subset returns the of the bits of in the subset, i.e., . The goal is to use these subset queries to learn all of the bits of . Clearly this can be achieved with queries in almost any reasonable measure of query complexity, by querying each bit of the input separately, i.e., by querying the subsets . And as previously mentioned, for sparse inputs one can use fewer than queries. But for worst-case inputs this trivial query algorithm is optimal for classical (deterministic or randomized) query complexity. This is because if the string contains a single , then this problem reduces to search. Therefore even a quantum algorithm for this query problem would require queries by the lower bound for Grover search [BBBV97]. Surprisingly, Belovs [Bel15] showed that the quantum query complexity of this problem is at most as well. This algorithm will play a key role in our proofs.
Approximate degree -composition.
We first describe the ideas required to lower bound the approximate degree of functions of the form , making note of the parts of the proof that fail in communication complexity.
Suppose by way of contradiction that , where is smaller than expected. This means we can compute the of copies of a function more easily than expected. But this also implies we can compute the of any subset of these copies of , since we can apply this algorithm to any subset of our choice. (This argument already does not work in communication complexity when only one player knows the subset , since that player would have to communicate to the other player.)
Now we view the outputs to the functions as the hidden string in the combinatorial group testing problem. In the combinatorial group testing problem, we assume we have the ability to query the of any subset of the bits, which is exactly what the assumed polynomial for gives us. From Belovs’ quantum algorithm, we can construct an approximating polynomial for combinatorial group testing using the results of Beals et al. [BBC01]. More precisely, since combinatorial group testing has an -bit output, which is the hidden string , we use a decision version of this problem that simply outputs the parity of all the bits. We would now like to compose this polynomial with the assumed polynomials that allow us to compute the of a subset of the functions . However, since the polynomials we wish to compose are approximating polynomials, they do not straightforwardly compose as expected, and to make this work, we use Sherstov’s robust polynomial construction [She13c]. Finally, by composing these polynomials of degree and degree , we get a polynomial of degree for computing the parity of all the functions , i.e., we have shown that .
Computing the parity of copies of a function is usually times as hard as computing in most models of computation. Such a result is known for all the measures considered in this paper. The argument is now completed by combining the fact that [She12] and . Combining these gives us , as desired.
Our results in communication complexity and the extension to arbitrary symmetric functions build on the ideas presented here. The flowchart in Figure 1 describes the flow of ideas as well as the dependencies between various sections.
composition in communication complexity.
The general strategy outlined above also works in communication complexity for the measures approximate rank and approximate gamma 2 norm, but we need to make additional arguments to make some steps work.
First, as noted above if one player knows a subset of the shared input, but the other does not, it is not in general possible for them to run a communication protocol on that subset of their shared input. Thus our communication results have some overhead for dealing with this situation. Naively it would seem this overhead is too expensive, since Alice would need to communicate the entire subset to Bob, which might be more expensive than the rest of the protocol. However, a recursive argument based on self-reducibility of the function allows the conversion of the additive loss into a multiplicative polylogarithmic loss.
The other technically challenging part of porting this argument to communication complexity is in composing approximating polynomials with approximating matrices. This composition does not work as cleanly as in query complexity, and in some cases leads to an additional log factor loss.
Approximate degree -composition.
To lower bound the approximate degree of functions of the form , where is a symmetric Boolean function, we first show an intermediate lower bound which will play a key role in our symmetric composition theorem. In particular we consider the Promise-OR function, denoted . The function is the same as the function with the additional promise that the input has Hamming weight either 0 or 1. We first extend our lower bound on the approximate degree of to the partial function . (For partial functions, we require that an approximating polynomial be close to the function on inputs in the domain, and be bounded in on all inputs including those outside the domain.)
The main insight that allows us to extend our lower bounds from to is that Belovs’ algorithm actually solves a more general problem than combinatorial group testing, or more precisely, assumes a weaker access model to the input. In particular Belovs’ algorithm only requires that the queries that are supposed to return the of a subset , i.e., the value , return the correct answer when . The queries may return incorrect answers on those subsets for which .
While this is the key conceptual step needed for the generalization, working with partial functions presents several technical challenges. One of the main challenges corresponds to the robustness of polynomials, for which we used Sherstov’s robust polynomial construction [She13c] previously.
Recall that our proof strategy is to compose the polynomial induced by Belovs’ algorithm with a too-good-to-be-true (approximating) polynomial for . This requires Belovs’ polynomial to be robust, i.e. handle noisy inputs, which it may not be. For composition, we applied Sherstov’s construction to obtain a robust version of Belovs’ polynomial, which tolerates noise in the input bits. However, Sherstov’s robust polynomial construction has a downside—it constructs polynomials that are not multilinear and whose value may blow up when an input variable is not close to being Boolean. This is exactly what can happen when we plug in an approximating polynomial for a partial function.
For this reason we use a different strategy for composing polynomials without using Shertov’s technique. In particular we prove that the polynomials constructed from quantum algorithms are already mildly robust, i.e., they can handle noise in the inputs, where is the query complexity of the quantum algorithm. Since the polynomials induced by quantum algorithms are multilinear (and hence they are bounded whenever the inputs are in ), this allows us to extend our composition framework to the setting of partial functions (at the expense of losing a logarithmic factor).
We note we are not the first to prove intrinsic robustness of polynomials derived from quantum algorithms. For instance, Buhrman et al. [BNRdW07] show that the polynomials derived from a quantum algorithm computing a total function can tolerate noise in the inputs, where is the certificate complexity of . However this result is insufficient for our application as we are applying it to a partial function. It is also not hard to show that all multilinear polynomials are robust to noise, where is the number of input bits. However, this does not suffice for our application either because the number of input bits for is exponentially larger than its quantum query complexity. To the best of our knowledge this particular robustness property of polynomials derived from quantum algorithms was not known before and might be of independent interest.
Approximate degree composition for symmetric functions.
We now describe how an approximate degree lower bound for can be used to lower bound the approximate degree of , where is a symmetric function. By a result of Paturi [Pat92], it is known that the approximate degree of a symmetric -bit function is completely determined by the Hamming weight closest to where the function changes value. This implies that it suffices to prove the composition theorem for the case when the outer function is which is defined as follows:
Now the elementary, but crucial, observation is that is a sub-function of . Hence we can obtain an approximate degree lower bound for using our composition theorem for , and a prior composition theorem of Sherstov that works for . (Sherstov’s result yields optimal composition theorems whenever the outer function has linear approximate degree [She12]). This yields the composition theorem for arbitrary symmetric functions.
1.3 Open problems
We end with a discussion of main open problems left open by our work. The foremost open problem is whether the following conjecture is true.
For all Boolean functions and , we have .
Our result resolves this (up to log factors) when is symmetric and is arbitrary. A related question is whether any of our results can be reproved using the dual polynomials framework that has been used to show recent lower bounds for approximate degree [She13a, BT13, BT15]. In particular, is there a way to convert a dual witness for into a dual witness for ?
A more open ended question is whether this technique can be generalized to functions other than by developing new quantum algorithms. Belovs’ algorithm used -queries to a hidden string to learn all of . What other quantum algorithms of this form exist? Are there nontrivial quantum algorithms that use -queries to learn for some function ? Are there nontrivial quantum algorithms that use -queries to compute some other function of the input? This motivates the study of a whole class of quantum algorithms, which to the best of our knowledge has not been systematically studied other than in the work of Belovs [Bel15].
2 Approximate degree
In this section we prove our composition theorems for approximate degree. We start with some definitions and known results in Section 2.1. In Section 2.2 we prove the -composition theorem (Theorem 1), which is the starting point for the more general results proved in this paper. Section 2.3 generalizes the composition theorem to a partial function related to , and then Section 2.4 proves the final result with arbitrary symmetric functions.
In this section we collect some basic definition and known results about partial functions, approximate degree, and quantum query complexity. Partial functions will play a key role in our proofs, even though the main results are about total Boolean functions. Hence it is necessary to formally define partial functions and extend the definitions of approximate degree and quantum query complexity to partial functions.
A partial Boolean function on bits is a function that is only defined on a subset of . There are two common ways to talk about partial functions. We can either view it as a function from to , where , or as a function , where the function evaluates to outside . We will mostly use the second definition and refer to the subset of with as the “promise” and denote it . We can now define the composition of two partial functions more formally.
Let and be partial Boolean functions. Then we define to be the partial function on those inputs for which all and . The function evaluates to on all other inputs.
Most algorithmic models are easily generalized to partial functions. A (classical or quantum) algorithm for a partial function is only required to be correct on inputs in and can have arbitrary behavior on inputs outside . Extending the definition of approximate degree to partial functions is more subtle, and we motivate it by using an example of a partial function.
Recall that the function on bits is defined as if and if , where denotes the Hamming weight of or the number of s in . Let us define a partial function related to , which we call PromiseOR, as follows. is the function with the additional promise that the input has Hamming weight or . In other words,
Intuitively contains the hardest instances of the function, and hence lower bounds for the function should hold against the function as well. For example, the quantum query complexity of is still , and the deterministic and randomized query complexities of are .
The approximate degree of is also as one might expect, as long as we define approximate degree for partial functions appropriately. For a partial function we clearly want the polynomial to approximate the function value on inputs in the promise. But we additionally want the polynomial to be bounded. We say a polynomial on variables is bounded if for all , .
We use the following standard generalization of approximate degree to partial functions that is sometimes called “bounded approximate degree” in the literature [BKT18].
Definition 7 (Bounded approximate degree).
For any partial Boolean function , the bounded approximate degree of , denoted , is the minimum degree of any real polynomial over the variables , such that
( is bounded) for all , , and
( approximates ) for all , .
With this generalization of approximate degree, it is indeed true that , as expected. Note that if we did not require that the polynomial be bounded on all inputs in the domain, then there would be a degree- polynomial that exactly represents the function, which is the polynomial .
Finally, we define what it means for a polynomial approximating a Boolean function to be -robust to input noise. Informally it means the polynomial continues to approximate the Boolean function even if the input bits are -far from being Boolean.
Definition 8 (-robustness to input noise).
Let be a partial Boolean function, and let be a polynomial. We say that approximately computes with robustness if for any and any , we have .
We now collect some facts about bounded polynomials and bounded approximate degree that we need to prove our results.
The first result we use is Sherstov’s result on making polynomials robust to noise [She13c, Theorem 1.1]. This result states that any polynomial can be made -robust to input noise by only increasing the degree of the polynomial by a constant factor.
Theorem 9 (Sherstov).
Let be a given polynomial. Then there exists a polynomial of degree such that
for all and .
We will also need a result of Sherstov that establishes the hardness of computing the parity of copies of a function , or more generally of different functions . We denote the parity of these functions . Sherstov shows that the approximate degree of the parity of functions is at least the sum of their approximate degrees [She12, Theorem 5.9].
Theorem 10 (Sherstov).
For any partial Boolean functions , we have
In particular, for any partial Boolean function , we have .
Finally, we also need the following result of Sherstov [She12, Theorem 6.6] that proves a composition theorem for bounded approximate degree when the outer function has high degree.
Theorem 11 (Sherstov).
Let and be partial Boolean functions. Then .
We now formally state the connection between quantum algorithms and approximating polynomials. Beals et al. [BBC01]
showed that the acceptance probability of a quantum query algorithm that makes few queries can be expressed as a low degree polynomial.
Theorem 12 (Beals et al.).
Let be a quantum query quantum algorithm that makes queries to an oracle string and outputs with probability . Then there exists a real polynomial of degree over the variables such that for all , .
By choosing to be a quantum algorithm that computes a partial function to bounded error, we get the following corollary.
For any partial Boolean function , .
In this section we prove our first main result, Theorem 1. We start by formally defining the combinatorial group testing problem, whose quantum query complexity was first studied by Ambainis and Montanaro [AM14].
Combinatorial group testing problem.
Let be the following problem. There is a hidden -bit string , which we have to determine using -queries to . In an -query, we query the oracle with a subset and the oracle outputs if there exists an such that . In other words, the oracle’s output is the function . Formally, combinatorial group testing is a partial function
where the input is a -bit string corresponding to the s of all possible subsets of , and the promise is that all bits are indeed the of some string . When the promise is satisfied the desired output is the hidden string . In other words, is in if there exists an such that for all , . For such a , . Note that for any , the string is uniquely defined by .
Note that although the problem has an input size of bits, the problem is easily solved with queries as we can simply query all the singleton subsets for to learn all the bits of . Surprisingly, Belovs showed that the quantum query complexity of this problem is quadratically better than this [Bel15, Theorem 3.1].
Theorem 14 (Belovs).
The bounded-error quantum query complexity of is .
Decision problem associated with .
Since we want to work with polynomials (and Boolean matrices in Section 3), it will be more convenient to consider a decision problem corresponding to combinatorial group testing. To do so, we define the problem
which computes the parity of all the output bits of the function.
In other words, , which is the of all the bits of , the hidden string in the problem. Of course, any quantum algorithm that solves and outputs can instead output the parity of all the bits of .
We can now construct a polynomial that approximates this Boolean function. Using Theorem 12 and Theorem 14, we can get a polynomial of degree that approximates on all inputs in the promise and is bounded in outside the promise.
For our application we need a more robust version of this polynomial. We need a polynomial that also works when the input variables are close to being Boolean. Combining this polynomial with Theorem 9, we get the following.
There is a real polynomial of degree acting on variables such that for any input with , and any ,
and for all , .
We start with Theorem 14 which gives us a quantum algorithm that makes queries and approximates to bounded error. Given a quantum algorithm computing a function with probability at least , we can always boost the success probability to any constant in by repeating the quantum algorithm and taking the majority vote of the outcomes. This only increases the quantum query complexity by a constant factor. Hence we can assume the quantum algorithm of Theorem 14 has error at most and apply Theorem 12 to get a polynomial of degree such that for all with ,
Furthermore, because arises from a quantum algorithm, we know that even on inputs outside the promise, i.e., inputs with , . Since is bounded in , we can apply Theorem 9 to it with to obtain a new polynomial that is robust to input noise. Note that since on all inputs , including those outside the promise, for all . By rescaling and shifting the polynomial, we can map the interval to the interval . Explicitly, we map to . Since the original polynomial was in for -inputs, this rescaled and shifted polynomial lies in , and similarly for -inputs it lies in , satisfying the conditions of the theorem. ∎
Using these results we can now prove the main result of this section.
Proof. Assuming (otherwise the result is trivial), there is an input such that . Let be any such input.
Let be a polynomial of degree that approximates . Let the input variables of the copy of , for , be called . Let us also define for all , to be the output of the function .
Thus is a polynomial over the variables to that approximately computes the Boolean function . From , we can define for any , a new polynomial over the same set of variables that approximately computes the Boolean function . The polynomial is obtained from by setting all the inputs to for which equal to the special input for which . Thus the polynomial is a polynomial over the same variables as and has degree at most and approximates the function .
Now from Theorem 15, we have a real polynomial of degree acting on variables such that for any input with , and any ,
Now we define a polynomial in the variables to by taking the polynomial over variables and replacing each occurrence of the variable with the polynomial .
Then because of equation (13) and the fact that the polynomial approximates , the polynomial approximates the parity of the bits (recall ). Also note that is of degree . Thus we have
Since (Theorem 10), we get . ∎
Note that essentially the same proof yields a weak lower bound for the of different functions . The proof would follow similarly, except instead of (14), we would arrive at
Now from Theorem 10, we have that , and hence
We will use this weak result in Section 4.1 to establish an optimal bound on the approximate degree of the of different functions.
We now extend the main result of the previous section to work with the partial function introduced in Section 2.1. is just the function with the additional promise that the input has Hamming weight or . As discussed in Section 2.1, . We now generalize the result of the previous section to work for .
For any Boolean function , we have
Before proving this, we need to establish some properties of polynomials that arise from quantum algorithms using Theorem 12. Recall from Definition 8 that a polynomial approximating a Boolean function is -robust to input noise if the polynomial correctly approximates the function even if the input bits are -far from being Boolean.
We now prove that approximating polynomials for Boolean functions that are constructed via quantum algorithms (using Theorem 12) naturally possess some robustness to input noise. While it is not hard to show that all multilinear polynomials on bits are robust to input noise smaller than , this is not good enough for our applications, as the polynomials we are interested in act on exponentially many variables (see Section 1.2 for a detailed discussion). Instead, we show that polynomials that arise from quantum algorithms are much more robust to input noise if the function has small quantum query complexity.
Let be a partial Boolean function. Then there is a bounded multilinear polynomial of degree that approximately computes with robustness .
Consider the quantum query algorithm that computes to error using at most