Separations in Query Complexity Based on Pointer Functions (1506.04719v3)

Abstract: In 1986, Saks and Wigderson conjectured that the largest separation between deterministic and zero-error randomized query complexity for a total boolean function is given by the function $f$ on $n=2^k$ bits defined by a complete binary tree of NAND gates of depth $k$, which achieves $R_0(f) = O(D(f)^{0.7537\ldots})$. We show this is false by giving an example of a total boolean function $f$ on $n$ bits whose deterministic query complexity is $\Omega(n/\log(n))$ while its zero-error randomized query complexity is $\tilde O(\sqrt{n})$. We further show that the quantum query complexity of the same function is $\tilde O(n^{1/4})$, giving the first example of a total function with a super-quadratic gap between its quantum and deterministic query complexities. We also construct a total boolean function $g$ on $n$ variables that has zero-error randomized query complexity $\Omega(n/\log(n))$ and bounded-error randomized query complexity $R(g) = \tilde O(\sqrt{n})$. This is the first super-linear separation between these two complexity measures. The exact quantum query complexity of the same function is $Q_E(g) = \tilde O(\sqrt{n})$. These two functions show that the relations $D(f) = O(R_1(f)^2)$ and $R_0(f) = \tilde O(R(f)^2)$ are optimal, up to poly-logarithmic factors. Further variations of these functions give additional separations between other query complexity measures: a cubic separation between $Q$ and $R_0$, a $3/2$-power separation between $Q_E$ and $R$, and a 4th power separation between approximate degree and bounded-error randomized query complexity. All of these examples are variants of a function recently introduced by \goos, Pitassi, and Watson which they used to separate the unambiguous 1-certificate complexity from deterministic query complexity and to resolve the famous Clique versus Independent Set problem in communication complexity.

• The paper introduces novel boolean functions that nearly match the conjectured upper bound between deterministic and zero-error randomized complexities.
• The paper reveals a function with quantum query complexity of O(n^(1/4)), establishing the first super-quadratic separation from deterministic models.
• The paper employs pointer functions, back pointers, and balanced trees to achieve additional super-linear separations across various query complexity measures.

Analyzing "Separations in Query Complexity Based on Pointer Functions"

The paper "Separations in Query Complexity Based on Pointer Functions" addresses significant conjectures and separations within query complexity, an area that offers insights into the computational capabilities of different models. Particularly, the authors challenge longstanding conjectures by Saks and Wigderson concerning the maximum separations between deterministic and zero-error randomized query complexities for boolean functions.

Key Contributions and Findings

The authors introduce new total boolean functions, providing novel examples of maximal separations between various query complexity measures. Here are some critical results and implications stated in the paper:

1. Separation Between Deterministic and Zero-Error Randomized Complexity: The paper refutes the conjecture by providing a function with deterministic query complexity $22^{n/\log(n)}$ and zero-error randomized query complexity $O(\sqrt{n})$. This result shows that the established upper bound of $D(f) \leq R_0(f)^2$ is tight up to poly-logarithmic factors.
2. Quantum Query Complexity: The paper introduces a function with quantum query complexity $O(n^{1/4})$, marking the first instance of a super-quadratic separation between quantum and deterministic complexities, thereby improving previous best-known quadratic separations.
3. Super-linear and Super-quadratic Separations: A function $g$ is also presented, exhibiting a super-linear separation between zero-error and bounded-error randomized query complexities. This builds on Göös, Pitassi, and Watson's work to further expand separation classifications.
4. Additional Separations: The paper discusses several additional separations between complexity measures, including cubic and $3/2$-power separations among others, highlighting the potential for vast discrepancies in computational requirements depending on the query model used.

Methodologies and Techniques

The researchers build upon the Göös-Pitassi-Watson function, enhancing it with multiple modifications such as back pointers and the use of balanced trees rather than paths. These modifications were significant in achieving the major separations reported.

1. Pointer Functions: This paper leverages pointer functions to transform a known function into one that highlights the contrasts in computational models. Pointer functions help simulate conditions where certain zeroes guide the search process, enhancing the complexity of deterministic queries while simplifying randomized and quantum queries.
2. Back Pointers and Balanced Trees: Using back pointers, the authors manage to delineate clear pathways that enable easier query resolution for specific models, and balance trees efficiently highlight the function’s inherent complexities.
3. Quantum Algorithms: Techniques such as Grover's Search and quantum amplitude amplification are applied to provide efficient quantum query solutions showing stark separations from classical computations.

Implications and Future Directions

The results from this paper have profound implications for computational complexity theory and the classification of boolean functions. The tightness of bounds between different query complexities suggests a revision of prior complexity assumptions for functions, prompting a review of computational resource efficiencies.

Theoretically, these separations advance our understanding of randomized and quantum complexities and suggest potential for developing algorithms that capitalize on these variances. Practically, the insights could refine algorithm development in fields where query complexity impacts performance, such as databases and search algorithms.

Future research may explore further refinements in how pointer functions can be used to exhibit extremal behavior in computational models, as well as identifying additional functions that demonstrate unexplored complexity separations. Additionally, extending these findings to other classes of functions and query types represents a promising direction.

In conclusion, the findings and methods developed here mark a substantial progression in the paper of query complexity, providing both critical theoretical insights and practical algorithmic frameworks for researchers and practitioners within computational complexity and related domains.