Deterministic Query Complexity Research Articles

Lower bounds for the query complexity of equilibria in Lipschitz games

Nearly a decade ago, Azrieli and Shmaya introduced the class of λ-Lipschitz games in which every player's payoff function is λ-Lipschitz with respect to the actions of the other players. They showed that such games admit ϵ-approximate pure Nash equilibria for certain settings of ϵ and λ. They left open, however, the question of how hard it is to find such an equilibrium. In this work, we develop a query-efficient reduction from more general games to Lipschitz games. We use this reduction to show a query lower bound for any randomized algorithm finding ϵ-approximate pure Nash equilibria of n-player, binary-action, λ-Lipschitz games that is exponential in nλ/ϵ. In addition, we introduce “Multi-Lipschitz games,” a generalization involving player-specific Lipschitz values, and provide a reduction from finding equilibria of these games to finding equilibria of Lipschitz games, showing that the value of interest is the average of the individual Lipschitz parameters. Finally, we provide an exponential lower bound on the deterministic query complexity of finding ϵ-approximate Nash equilibria of n-player, m-action, λ-Lipschitz games for strong values of ϵ, motivating the consideration of explicitly randomized algorithms in the above results.

Deterministic algorithms for the hidden subgroup problem

We present deterministic algorithms for the Hidden Subgroup Problem. The first algorithm, for abelian groups, achieves the same asymptotic worst-case query complexity as the optimal randomized algorithm, namely~$ \Order(\sqrt{ n}\, )$, where~$n$ is the order of the group. The analogous algorithm for non-abelian groups comes within a~$\sqrt{ \log n}$ factor of the optimal randomized query complexity. The best known randomized algorithm for the Hidden Subgroup Problem has \emph{expected\/} query complexity that is sensitive to the input, namely~$ \Order(\sqrt{ n/m}\, )$, where~$m$ is the order of the hidden subgroup. In the first version of this article~\cite[Sec.~5]{Nayak21-hsp-classical}, we asked if there is a deterministic algorithm whose query complexity has a similar dependence on the order of the hidden subgroup. Prompted by this question, Ye and Li~\cite{YL21-hsp-classical} present deterministic algorithms for \emph{abelian\/} groups which solve the problem with~$ \Order(\sqrt{ n/m }\, )$ queries, and find the hidden subgroup with~$ \Order( \sqrt{ n (\log m) / m} + \log m ) $ queries. Moreover, they exhibit instances which show that in general, the deterministic query complexity of the problem may be~$\order(\sqrt{ n/m } \,)$, and that of \emph{finding\/} the entire subgroup may also be~$\order(\sqrt{ n/m } \,)$ or even~$\upomega(\sqrt{ n/m } \,) $.}We present a different deterministic algorithm for the Hidden Subgroup Problem that also has query complexity~$ \Order(\sqrt{ n/m }\, )$ for abelian groups. The algorithm is arguably simpler. Moreover, it works for non-abelian groups, and has query complexity~$ \Order(\sqrt{ (n/m) \log (n/m) }\,) $ for a large class of instances, such as those over supersolvable groups. We build on this to design deterministic algorithms to find the hidden subgroup for all abelian and some non-abelian instances, at the cost of a~$\log m$ multiplicative factor increase in the query complexity.

Testing Boolean Functions Properties

The goal in the area of functions property testing is to determine whether a given black-box Boolean function has a particular given property or is ɛ-far from having that property. We investigate here several types of properties testing for Boolean functions (identity, correlations and balancedness) using the Deutsch-Jozsa algorithm (for the Deutsch-Jozsa (D-J) problem) and also the amplitude amplification technique. At first, we study here a particular testing problem: namely whether a given Boolean function f, of n variables, is identical with a given function g or is ɛ-far from g, where ɛ is the parameter. We present a one-sided error quantum algorithm to deal with this problem that has the query complexity O(1ε). Moreover, we show that our quantum algorithm is optimal. Afterwards we show that the classical randomized query complexity of this problem is Θ(1ε). Secondly, we consider the D-J problem from the perspective of functional correlations and let C(f, g) denote the correlation of f and g. We propose an exact quantum algorithm for making distinction between |C(f, g)| = ɛ and |C(f, g)| = 1 using six queries, while the classical deterministic query complexity for this problem is Θ(2n) queries. Finally, we propose a one-sided error quantum query algorithm for testing whether one Boolean function is balanced versus ɛ-far balanced using O(1ε) queries. We also prove here that our quantum algorithm for balancedness testing is optimal. At the same time, for this balancedness testing problem we present a classical randomized algorithm with query complexity of O(1/ɛ2). Also this randomized algorithm is optimal. Besides, we link the problems considered here together and generalize them to the general case.

Query complexity of generalized Simon's problem

Simon's problem plays an important role in the history of quantum algorithms, as it inspired Shor to discover the celebrated quantum algorithm solving integer factorization in polynomial time. Besides, the quantum algorithm for Simon's problem has been recently applied to break symmetric cryptosystems. Generalized Simon's problem, denoted by GSP(p,n,k), is a natural extension of Simon's problem: Given a function f:Zpn→X where X is a finite set and the promise that for any x,y∈Zpn,f(x)=f(y) iff x−y∈S for a subgroup S≤Zpn of rank k<n, the goal is to find S. In this paper we consider the query complexity of the problem, that is, the minimum number of queries to f required to find S. First, it is not difficult to design a quantum algorithm solving the above problem with query complexity of O(n−k). However, so far it is not clear what is the classical query complexity of the problem, and revealing this complexity is necessary for clarifying the computational power gap between quantum and classical computing on the problem.To tackle this problem, we prove that any classical (deterministic or randomized) algorithm for GSP(p,n,k) has to query at least Ω(max⁡{k,pn−k}) values and any classical nonadaptive deterministic algorithm for GSP(p,n,k) has to query at least Ω(max⁡{k,k⋅pn−k}) values. Hence, we clearly show the classical computing model is less powerful than the quantum counterpart, in terms of query complexity for the generalized Simon's problem. Moreover, we obtain an upper bound O(max⁡{k,k⋅pn−k}) on the classical deterministic query complexity of GSP(p,n,k), by devising a subtle classical algorithm based on group theory and the divide-and-conquer approach. Therefore, we have an almost full characterization of the classical deterministic query complexity of the generalized Simon's problem.

Separations in Query Complexity Based on Pointer Functions

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… ). We show that this is false by giving an example of a total Boolean function f on n bits whose deterministic query complexity is Ω( n ) while its zero-error randomized query complexity is Õ(√ n ). We further show that the quantum query complexity of the same function is Õ( 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 Ω( n / log ( n )) and bounded-error randomized query complexity R ( g ) = Õ(√ 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 ) = Õ(√ n ). These functions show that the relations D ( f ) = O ( R 1 ( f ) 2 ) and R 0 ( f ) = Õ( R ( f ) 2 ) are optimal, up to polylogarithmic 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 Göös, 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.

Finding Approximate Nash Equilibria of Bimatrix Games via Payoff Queries

We study the deterministic and randomized query complexity of finding approximate equilibria in a k × k bimatrix game. We show that the deterministic query complexity of finding an ϵ-Nash equilibrium when ϵ &lt; ½ is Ω( k 2 ), even in zero-one constant-sum games. In combination with previous results [Fearnley et al. 2013], this provides a complete characterization of the deterministic query complexity of approximate Nash equilibria. We also study randomized querying algorithms. We give a randomized algorithm for finding a (3-√5/2 + ϵ)-Nash equilibrium using O ( k .log k /ϵ 2 ) payoff queries, which shows that the ½ barrier for deterministic algorithms can be broken by randomization. For well-supported Nash equilibria (WSNE), we first give a randomized algorithm for finding an ϵ-WSNE of a zero-sum bimatrix game using O ( k .log k /ϵ 4 ) payoff queries, and we then use this to obtain a randomized algorithm for finding a (⅔ + ϵ)-WSNE in a general bimatrix game using O ( k .log k /ϵ 4 ) payoff queries. Finally, we initiate the study of lower bounds against randomized algorithms in the context of bimatrix games, by showing that randomized algorithms require Ω( k 2 ) payoff queries in order to find an ϵ-Nash equilibrium with ϵ &lt; 1/4 k , even in zero-one constant-sum games. In particular, this rules out query-efficient randomized algorithms for finding exact Nash equilibria.

Lower Bounds on Quantum Query Complexity for Read-Once Formulas with XOR and MUX Operators

We introduce a complexity measure r for the class $\mathcal{F}$ of read-once formulas over the basis {AND, OR, NOT, XOR, MUX} and show that for any Boolean formula F in the class $\mathcal{F}$, r(F) is a lower bound on the quantum query complexity of the Boolean function that F represents. We also show that for any Boolean function f represented by a formula in $\mathcal{F}$, the deterministic query complexity of f is only quadratically larger than the quantum query complexity of f. Thus, the paper gives further evidence for the conjecture that there is an only quadratic gap for all functions.

Enhanced algorithms for Local Search

Let G = ( V , E ) be a finite graph, and f : V → N be any function. The Local Search problem consists in finding a local minimum of the function f on G, that is a vertex v such that f ( v ) is not larger than the value of f on the neighbors of v in G. In this note, we first prove a separation theorem slightly stronger than the one of Gilbert, Hutchinson and Tarjan for graphs of constant genus. This result allows us to enhance a previously known deterministic algorithm for Local Search with query complexity O ( log n ) ⋅ d + O ( g ) ⋅ n , so that we obtain a deterministic query complexity of d + O ( g ) ⋅ n , where n is the size of G, d is its maximum degree, and g is its genus. We also give a quantum version of our algorithm, whose query complexity is of O ( d ) + O ( g 4 ) ⋅ n 4 log log n . Our deterministic and quantum algorithms have query complexities respectively smaller than the algorithm Randomized Steepest Descent of Aldous and Quantum Steepest Descent of Aaronson for large classes of graphs, including graphs of bounded genus and planar graphs.