In the query model of multi-variate function computation, the values of the variables are queried sequentially, in an order that may depend on previously revealed values, until the function's value can be determined. The function's computation query complexity is the lowest expected number of queries required by any query order. Instead of computation, it is often easier to consider verification, where the value of the function is given and the queries aim to verify it. The lowest expected number of queries necessary is the function's verification query complexity. We show that for all symmetric functions of independent binary random variables, the computation and verification complexities coincide. This provides a simple method for finding the query complexity and the optimal query order for computing many functions. We also show that if the symmetry condition is removed, there are functions whose verification complexity is strictly lower than their computation complexity, and mention that the same holds when the independence or binary conditions are removed.
We study the quantum query complexity of computing a semigroup product x1⋯xn, when one query reveals one input element and the multiplication table is given. For a finite aperiodic semigroup of size N−1, the argument of Aaronson, Grier, and Schaeffer gives an upper bound of n(Nlog(nN+2))O(N) queries.
To obtain query bounds that reflect algebraic structure, we study the product breadth β: the smallest bound such that every input word has a subsequence of at most β letters with the same product.
For nontrivial finite commutative aperiodic monoids, the bounded-error quantum query complexity is Θ(min{n,nβ}), and is thus characterized by product breadth. We further show that if such a monoid M has aperiodicity index k (the least positive integer satisfying xk=xk+1 for every x∈M), then β=O(klog(∣M∣+1)loglog(∣M∣+2)).
For monoids with a stable partial order in which the identity is the minimum element, we prove that the bounded-error quantum query complexity is at most n+1((β+2)log(n+2))O(log(β+2)).
For arbitrary finite aperiodic semigroups of order N−1, we improve the bound of Aaronson, Grier, and Schaeffer, obtaining a bounded-error quantum query complexity of at most min{n,nlogO((Nlog(N+2))1/3)(n+2)}. The dependence on semigroup size is nearly tight: the bounded-depth Dyck lower bound of Ambainis et al. yields aperiodic monoids requiring n2Ω(N1/3) quantum queries in the relevant parameter range.
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}\, ),wheren$ is the order of the group. The analogous algorithm for non-abelian groups comes within a~logn 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}\, ),wherem$ 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~logm multiplicative factor increase in the query complexity.