Average/Worst-Case Gap of Quantum Query Complexities by On-Set Size

TL;DR

This paper investigates the quantum and randomized query complexities of Boolean functions with a fixed number of inputs where the function outputs 1, revealing a super-linear gap in quantum complexity for certain onset sizes.

Contribution

It establishes the existence of a super-linear gap between average-case and worst-case quantum query complexities for specific onset sizes, and characterizes complexities for various M ranges.

Findings

Super-linear gap between average-case and worst-case quantum complexities for certain M.

No super-linear gap between average-case and worst-case randomized complexities.

Quantum complexity is Theta(sqrt{N}) for polynomial M.

Abstract

This paper considers the query complexity of the functions in the family F_{N,M} of N-variable Boolean functions with onset size M, i.e., the number of inputs for which the function value is 1, where 1<= M <= 2^{N}/2 is assumed without loss of generality because of the symmetry of function values, 0 and 1. Our main results are as follows: (1) There is a super-linear gap between the average-case and worst-case quantum query complexities over F_{N,M} for a certain range of M. (2) There is no super-linear gap between the average-case and worst-case randomized query complexities over F_{N,M} for every M. (3) For every M bounded by a polynomial in N, any function in F_{N,M} has quantum query complexity Theta (sqrt{N}). (4) For every M=O(2^{cN}) with an arbitrary large constant c<1, any function in F_{N,M} has randomized query complexity Omega (N).

Tables

Table 1. Table 1: Query Complexities of N 𝑁 N -variable Boolean Functions with On-set Size M 𝑀 M : ( † † \dagger ) holds for every 1 ≤ M ≤ 2 N / ( log ⁡ N ) 2 + ϵ 1 𝑀 superscript 2 𝑁 superscript 𝑁 2 italic-ϵ 1\leq M\leq 2^{N/(\log{N})^{2+\epsilon}} with an arbitrary small positive constant ϵ italic-ϵ \epsilon . The other bounds hold for every 1 ≤ M ≤ 2 N / 2 1 𝑀 superscript 2 𝑁 2 1\leq M\leq 2^{N}/2 .

	Worst	Best	Average (Almost All)
Quantum	$\Theta \left(\sqrt{N\frac{\log M}{c+\log N-\log \log M}}+\sqrt{N}\right)$ ($†$)	$\Omega \left(\sqrt{N-\log M}\right)$	$\Theta \left(\frac{\log M}{c+\log N-\log \log M}+\sqrt{N}\right)$
Randomized	$\Omega \left(N\right)$	$\Omega \left(N-\log M\right)$	$\Omega \left(N\right)$

Equations

$$Q_{\mathrm{worst}}({\mathcal{F}}_{N,M})=\Theta \left(\sqrt{N\frac{\log M}{c+\log N-\log \log M}}+\sqrt{N}\right),$$

$$R_{\mathrm{worst}}({\mathcal{F}}_{N,M})=\Theta \left(N\right).$$

$$Q_{\mathrm{best}}({\mathcal{F}}_{N,M})=\Omega (\sqrt{N-\log M}),$$

$$R_{\mathrm{best}}({\mathcal{F}}_{N,M})=\Omega (N-\log M).$$

$$Q_{\mathrm{almost}}({\mathcal{F}}_{N,M})=\Theta \left(\frac{\log M}{c+\log N-\log \log M}+\sqrt{N}\right),$$

$$R_{\mathrm{almost}}({\mathcal{F}}_{N,M})=\Theta \left(N\right),$$

$${\left(\frac{eN}{d(z)}\right)}^{d(z)}\le z.$$

$$d(z)\log \frac{eN}{d(z)}$$

$$\theta \left(A,i\right)$$

$$\theta \left(B,i\right)$$

$${\upsilon }_{\mathrm{geom}}=\underset{\begin{array}{c}A\in \mathcal{A},B\in \mathcal{B},i:\\ R\left(A,B\right)>0,A\left(i\right)\ne B\left(i\right)\end{array}}{\max }\sqrt{\theta \left(A,i\right)\theta \left(B,i\right)}.$$

$${\upsilon }_{\min }=\underset{\begin{array}{c}A\in \mathcal{A},B\in \mathcal{B},i:\text{vskip}3.0ptplus1.0ptminus1.0pt\\ R\left(A,B\right)>0,A\left(i\right)\ne B\left(i\right)\end{array}}{\max }\min \left\{\theta \left(A,i\right),\theta \left(B,i\right)\right\}.$$

$$|\Gamma (A)|\ge M\log \frac{2^N}{M}.$$

$$s(f)=\underset{x}{\max }{s}_x(f)\ge \frac{1}{M}\sum _{x\in A}{s}_x(f)=\frac{1}{M}|\Gamma (A)|\ge \log \frac{2^N}{M},\text{(∵ Eq.refeq:1)}$$

$$Q_{\mathrm{best}}({\mathcal{F}}_{N,M})=\Omega (\sqrt{s(f)})=\Omega (\sqrt{N-\log M}).$$

$$\{0,1{\}}^{\lfloor \log M\rfloor }{0}^{N-\lfloor \log M\rfloor },$$

$$\{\begin{array}{ll}{C}_M& \text{if M is a power of 2,}\\ C_M\cup \left\{y:y\in [0,\Delta M-1]\right\}10^{N-\lfloor \log M\rfloor -1}& \text{otherwise,}\end{array}$$

$$\beta =(\log M(\log \log M{)}^2\log N)/(2N).$$

$${\beta }^{\prime }=(\log M(\log \log M{)}^2\log (eN/\log M))/(2N).$$

$${\gamma }^{\prime }=\Theta \left(\frac{\log |S|}{N(\log eN-\log \log |S|)}\right).$$

$$O(\sqrt{N\log M\log (eN/\log M)}/\log (1/{\beta }^{\prime })),$$

$$D=\sum _{i=0}^k\left(\genfrac{}{}{0ex}{}{N}{i}\right)\le M\text{mbox}and\sum _{i=0}^{k+1}\left(\genfrac{}{}{0ex}{}{N}{i}\right)>M.$$

$$\sum _{i=0}^{d(M/N)}\left(\genfrac{}{}{0ex}{}{N}{i}\right)\le N\left(\genfrac{}{}{0ex}{}{N}{d(M/N)}\right)\le N{\left(\frac{eN}{d(M/N)}\right)}^{d(M/N)}\le M,$$

$$⟨{\psi }_x|{\psi }_y⟩$$

$$d\left(\frac{M^{\prime }}{(N+1{)}^2}\right)=\Omega \left(\frac{\log M}{c+\log N-\log \log M}\right).$$

$$T(N,d)$$

$$D=\sum _{i=0}^{d(z)}\left(\genfrac{}{}{0ex}{}{N}{i}\right)\le (d(z)+1){\left(\frac{eN}{d(z)}\right)}^{d(z)}\le (N+1)z\le \frac{M^{\prime }}{N},$$

$$d\left(\frac{M^{\prime }}{(N+1{)}^2}\right)$$

$$\underset{x}{\mathrm{Pr}}[\forall y\in f^{-1}(1):\mathrm{Ham}(x,y)>r]=\frac{\left(\genfrac{}{}{0ex}{}{2^N-D}{M-1}\right)}{\left(\genfrac{}{}{0ex}{}{2^N-1}{M-1}\right)},$$

$$D<2^N\exp \left(-2N{\left(\frac{1}{2}-\frac{r}{N}\right)}^2\right).$$

$$\mathrm{Pr}[\exists x,y\in f^{-1}(1):\mathrm{Ham}(x,y)\le r]$$

Full text

• •

There is a super-linear gap between the average-case and worst-case quantum query complexities over ${\cal F}_{N,M}$ for a certain range of $M$.

• •

There is no super-linear gap between the average-case and worst-case randomized query complexities over ${\cal F}_{N,M}$ for every $M$.

• •

For every $M$ bounded by a polynomial in $N$, any function in ${\cal F}_{N,M}$ has quantum query complexity $\Theta(\sqrt{N})$.

• •

For every $M=O(2^{cN})$ with an arbitrary large constant $c<1$, any function in ${\cal F}_{N,M}$ has randomized query complexity $\Omega(N)$.

1 Introduction

1.1 Background

Query complexities of Boolean functions are one of the most fundamental and popular topics in quantum computation. It is well known that a quadratic speed-up, i.e., randomized query complexity $\Omega(N)$ to quantum query complexity $O(\sqrt{N})$, is possible for several $N$-variable Boolean functions including OR, AND, AND-OR trees (e.g., Refs. [19, 22, 18, 4]). However, we can obtain only a constant-factor speed-up (i.e., $\Omega(N)$ queries are needed in both classical and quantum settings) for other Boolean functions such as PARITY [10]. Moreover, threshold functions have quantum query complexity depending on their thresholds [10]. Thus we know well about the quantum query complexity for Boolean functions for these typical cases, but much less is known for the others. Some known general results are the worst-case and average-case query complexities (including the coefficients of dominant factors) over all Boolean functions in Refs. [28] and [2], respectively. To understand more about the query complexity of all Boolean functions, this paper examines the query complexity for the set of Boolean functions with on-set size $M$, i.e., with $M$ 1’s on their truth tables, for every $M$. Our results show that the size of the on-set of a Boolean function $f$ plays a key role in the query complexity of $f$, i.e., on-set size non-trivially bounds the quantum/randomized query complexity of $f$. For instance, the quantum query complexity of every function with on-set size bounded by a polynomial in $N$ is $\Theta(\sqrt{N})$ while the randomized query complexity of the function is $\Omega(N)$, as will be described later.

The difference between average-case and worst-case complexities is one of the central topics in theoretical computer science, and it has been extensively studied for decades (e.g., Refs. [26, 9]). However, in the quantum setting, only a few results are known. (i) For a MAJORITY function, there is an almost quadratic gap between the average-case and worst-case quantum query complexities over all inputs of the function  [10, 5]. (ii) If we consider the average-case and worst-case behaviors of complexities over all Boolean functions (for the worst input of each function), only a linear gap is possible for quantum query complexity [28, 2, 25] and exact quantum communication complexity [14]. Our results imply a super-linear tight gap between the average-case and worst-case quantum query complexities over the family of Boolean functions with on-set size $M$ for every $M$ in a certain range. In contrast, the gap between the average-case and worst-case randomized query complexities is at most linear for any on-set size $M$, which is also an implication of our results.

Previous Work

The research on quantum query complexity started with the Deutcsh-Jozsa algorithm [15] and other algorithms for computing partial functions (e.g., Simon’s algorithm [27]), followed by Grover’s quantum search algorithm [19], which also computes the Boolean OR function of $N$ variables with $O(\sqrt{N})$ queries. Since then, numerous results have extensively appeared in the literature, showing that similar speed-ups are possible for many other Boolean functions. For example, if a Boolean function is given by a constant-depth balanced AND-OR trees (e.g., OR is by a single-depth tree), it can be computed in $O(\sqrt{N})$ quantum queries with the robust quantum search technique [22]. This was recently extended to any AND-OR tree with $O(N^{\frac{1}{2}+o(1)})$ quantum queries (optimal $O(\sqrt{N})$ quantum queries for nearly-balanced trees) by using the quantum walk technique [18, 4]. In general, however, the worst-case quantum query complexity is polynomially related to the worst-case randomized query complexity for any Boolean function [10]. In contrast, there is an exponential gap between the average-case randomized and quantum query complexities of a certain Boolean function for uniform distribution of inputs, and the gap can be even larger for non-uniform distribution of inputs [5]. As for the gap between the average-case and worst-case quantum query complexities, they are $O(N^{1/2+\epsilon})$ [5] and $\Omega(N)$ [10], respectively, over all inputs for MAJORITY functions. The average of complexity over all Boolean functions (for the worst input of each function) was proved to be at least $N/4-2\sqrt{N}\log N$ [2], which was improved to $N/4+\Omega(\sqrt{N})$ [25], and the worst-case complexity is at most $N/2+\sqrt{N}$ [28], respectively.

In the circuit complexity theory, it is known that the maximum circuit size over the circuits for the family of Boolean functions with on-set size $M$ is closely related to binary entropy function $H(p)$ for $p=M/2^{N}$ (e.g., Ref. [26]).

1.2 Our Results

Let $\mathcal{F}_{N,M}$ be a family of $N$-variable Boolean functions $f_{N}$ with on-set size $M$, i.e., $f_{N}$ that have value $1$ (true) for $M$ assignments in $\{0,1\}^{N}$. Without loss of generality, we assume $M\in\{1,2,\dots,2^{N}/2\}$ because of the symmetry of function values, 0 and 1. Let $Q(f_{N})$ be the bounded-error quantum query complexity of $f_{N}$, i.e., the number of quantum queries necessary to compute $f_{N}$ with bounded error for the worst-case input of $N$ bits given as an oracle. We then investigate the asymptotic behaviors of the following three functions of $N$ and $M$:

$Q_{\operatorname{worst}}({\cal F}_{N,M})\equiv\max_{f_{N}\in{\cal F}_{N,M}}Q(f_{N}).$ 2. 2.

$Q_{\operatorname{best}}({\cal F}_{N,M})\equiv\min_{f_{N}\in{\cal F}_{N,M}}Q(f_{N}).$ 3. 3.

$Q_{\operatorname{almost}}({\cal F}_{N,M})$ is an arbitrary function such that, for uniformly distributed $f_{N}$ over $\mathcal{F}_{N,M}$, $\Pr_{f_{N}\in\mathcal{F}_{N,M}}[Q(f_{N})=\Theta(Q_{\operatorname{almost}}({\cal F}_{N,M}))]\rightarrow 1$ as $N$ goes to infinity (if such a function exists).

Similarly, we also define $R_{\operatorname{worst}}({\cal F}_{N,M})$, $R_{\operatorname{best}}({\cal F}_{N,M})$ and $R_{\operatorname{almost}}({\cal F}_{N,M})$ for the randomized case. Our results are summarized in Table 1. More precise description is as follows.

(i)

For every $1\leq M\leq 2^{N/(\log{N})^{2+\epsilon}}$ with an arbitrary small positive constant $\epsilon$,

[TABLE]

where $c$ is a positive constant (Strictly speaking, the lower bound of $Q_{\operatorname{worst}}({\cal F}_{N,M})$ holds for broader range $1\leq M\leq 2^{N}/2$). For every $1\leq M\leq 2^{N-1}$,

[TABLE]

(ii)

For every $1\leq M\leq 2^{N}/2$,

[TABLE]

[TABLE]

(For every $1\leq M\leq 2^{cN}$ with an arbitrary large constant $c<1$, the bound is optimal. In the case of $M=2^{(1-o(1))N}$, the bound is optimal if $M$ is a power of 2.)

(iii)

For every $1\leq M\leq 2^{N}/2$,

[TABLE]

[TABLE]

where $c$ is a positive constant. The proof essentially implies that $Q_{\operatorname{almost}}({\cal F}_{N,M})$ is equal to the average quantum query complexity $Q_{\operatorname{avg}}({\cal F}_{N,M})$ over uniformly distributed functions in ${\cal F}_{N,M}$ up to a constant factor, since the fraction of functions whose quantum query complexity is not included by $Q_{\operatorname{almost}}({\cal F}_{N,M})$ is $o(1/N^{k})$ for some large positive constant $k$. Similarly, $R_{\operatorname{almost}}({\cal F}_{N,M})$ is essentially the same, up to a constant factor, as the average randomized query complexity $R_{\operatorname{avg}}({\cal F}_{N,M})$ over uniformly distributed functions in ${\cal F}_{N,M}$.

Implications of Our Results

• •

Results (i) and (iii): There is a super-linear gap between the worst-case and average-case quantum query complexities if $M$ is in the range that is upper-bounded by $2^{o(N)}$ and lower-bounded by $N^{\omega(1)}$. The maximum gap is $\Theta(N^{3/4})$ versus $\Theta(\sqrt{N})$ at $M=2^{\sqrt{N}\log N}$.

• •

Results (i) and (iii): There is no super-linear gap between the average-case and worst-case randomized query complexities over ${\cal F}_{N,M}$ for every $M$.

• •

Results (i) and (ii): For every $M=O(N^{O(1)})$, any function in ${\cal F}_{N,M}$ has quantum query complexity $\Theta(\sqrt{N})$. In other words, any function in this family has the same quantum query complexity up to a constant factor as the OR function.

• •

Results (ii): For every $M=O(2^{cN})$ with an arbitrary large constant $c<1$, every function in ${\cal F}_{N,M}$ has randomized query complexity $\Omega(N)$. Hence, for instance, any graph property testing problem whose corresponding Boolean function has $O(2^{cN})$ 1’s on its truth table has randomized query complexity $\Omega(n^{2})$ for the number $n$ of vertices in the bounded-error setting.

1.3 Technical Outlines for Results (i)-(iii)

(i) For the quantum upper bound, we use an algorithm [7] for the Oracle Identification Problem (OIP), which is defined as follows: If we are given an oracle $x$ and a set $S$ of $M$ oracle candidates out of $2^{N}$ ones, determine which oracle in $S$ is identical to $x$ with the promise that $x$ is a member of $S$. More concretely, we set $S$ to the on-set of $f_{N}$, run the algorithm, and finally verify with Grover search that the output of the algorithm is equal to the given $N$ bits. To achieve the tight bound, we modify the algorithm so that it can work for a wider range of $M$. For the lower bound, we give a function with on-set size $M$ for every $M$, and prove that the lower bound of its quantum query complexity matches the upper bound by using the quantum adversary method [3]. The lower bound of the randomized query complexity of the same function can be proved to be $\Omega(N)$ by the classical adversary method [1].

(ii) The upper bound is shown by giving a function with on-set size $M$ whose quantum and randomized query complexities are $O(\sqrt{N-\log M})$ and $O(N-\log M)$, respectively. The lower bound is proved by combining the edge-isoperimetric inequality on a Boolean cube and $Q(f_{N})=\Omega(\sqrt{s(f_{N})})$ [10] and $R(f_{N})=\Omega(s(f_{N}))$ [24], where $s(f_{N})$ is the sensitivity of $f_{N}$.

(iii) For the quantum upper bound, we encode the given $N$-bit string $x\in\{0,1\}^{N}$ as a quantum state $|\psi_{x}\rangle^{\otimes m}$ for some $m$ so that, for almost all Boolean functions in $\mathcal{F}_{N,M}$, $|\psi_{x}\rangle$ and $|\psi_{y}\rangle$ have small inner product for every $x,y\in f^{-1}_{N}(1)$ with $x\neq y$. We then perform state discrimination procedure [21] using $|\psi_{x}\rangle^{\otimes m}$ to test if $x$ is in the on-set of $f_{N}$, and verify the result with Grover search. More concretely, let $|\psi_{x}\rangle=(1/\sqrt{N})\sum_{i=1}^{N}(-1)^{x_{i}}|i\rangle$ for $x\in\{0,1\}^{N}$. We prove that, for almost all Boolean functions $f_{N}\in\mathcal{F}_{N,M}$, it holds that $|\langle\psi_{x}|\psi_{y}\rangle|\leq 2\sqrt{\log{M}/{N}}$ for every two different states $|\psi_{x}\rangle$ and $|\psi_{y}\rangle$ where $x,y\in f^{-1}_{N}(1)$. Here, the number $m$ of the copies of $|\psi_{x}\rangle$ is set to $O(\frac{\log{M}}{c+\log{N}-\log\log{M}})$ [21]. For the quantum lower bound, we use the following facts. (1) The number of functions in ${\mathcal{F}}_{N,M}$ is $\binom{2^{N}}{M}$. (2) The number of Boolean functions computable with success probability more than $1/2$ with at most $d/2$ queries is at most $T(N,d)=2\sum_{i=0}^{D-1}\binom{2^{N}-1}{i}$ for $D=\sum_{i=0}^{d}\binom{N}{i}$  [23, 13]. We then calculate the largest $d$ such that $T(N,d)/\binom{2^{N}}{M}\rightarrow 0$ for $N\rightarrow\infty$. The randomized lower bound is lower-bounded by the above quantum lower bound and the randomized lower bound in (ii), from which the bound follows.

1.4 Organization

Section 2 defines the oracle (or black-box) model, and then gives a technical lemma and known lower bound theorems that are used in the proofs in the following sections. Sections 3, 4 and 5 prove the best-case, worst-case, and average-case complexities, respectively, over family ${\cal F}_{N,M}$. Some applications to graph property testing are described at the end of Section 4. Section 6 concludes the paper.

2 Preliminaries

We assume the oracle (or black-box) model. In this model, an input (i.e., a problem instance) is given as an oracle. For any input $x=(x_{1},\ldots,x_{N})\in\{0,1\}^{N}$, we can get $x_{i}$ by making a query with index $i$ to the oracle. The randomized query complexity of a problem $P$ whose input is given as an $N$-bit string is defined as the number of queries needed to solve $P$ with bounded-error, i.e., with success probability at least $1/2+c$ for a constant $c>0$. In the quantum setting, we can get a superposition of answers by making a query with the same superposition of indices. More formally, a unitary operator $O$, corresponding to a single query to an oracle, maps $|i\rangle|b\rangle|w\rangle$ to $|i\rangle|b\oplus x_{i}\rangle|w\rangle$ for each $i\in[N]=\{1,2,\ldots,N\}$ and $b\in\{0,1\}$, where $w$ denotes workspace. A quantum computation of the oracle model (first formulated in [10]) is a sequence of unitary transformations $U_{0}\to O\to U_{1}\to O\to\cdots\to O\to U_{t}$, where $U_{j}$ is a unitary transformation that does not depend on the input. The above computation sequence involves $t$ oracle calls, which is our measure of the complexity: The quantum query complexity $Q(P)$ of a problem $P$ whose input is given as an $N$-bit string is defined as the number of quantum queries needed to solve $P$ with bounded-error.

This paper considers the problem of evaluating the value ([math] or $1$) of a Boolean function $f(x_{1},\ldots,x_{N})$ over $N$ variables, assuming that the truth table of $f$ is known. The on-set of $f$ is the set of assignments $(x_{1},\ldots,x_{N})$ with $f(x_{1},\ldots,x_{N})=1$. We denote by ${\cal F}_{N,M}$ the family of all $N$-variable Boolean functions whose on-set sizes are $M$.

In the following, we present a technical lemma for precise analysis, and a standard lower bound theorem, the adversary method. The technical lemma, together with well-known inequality $\binom{N}{k}\leq\left(\frac{eN}{k}\right)^{k}$, essentially gives a precise upper bound of $k$ that satisfies $\binom{N}{k}\leq M$. The lemma will be used in the worst- and average-case analyses (i.e., Sections 4 and 5). We assume hereafter that the base of the logarithm is $2$ when we do not explicitly write the base.

Lemma 1

For $1<z\leq 2^{N}$, let $d(z)=\frac{\log{z}}{4\left(\log{eN}-\log\log{z}\right)}$, where $e$ is the base of the natural logarithm. Then, it holds that $d(z)$ is monotone non-decreasing, and

[TABLE]

*Proof * The monotone non-decreasing property can be easily checked since for any $1<z\leq z^{\prime}\leq 2^{N}$, $d(z)\leq d(z^{\prime})$. The rest of the proof follows from the formula below: by taking the log of both sides of Eq. 1,

[TABLE]

for $y=\log{(eN)}-\log\log{z}$, where the last inequality is due to $\log{y}/y\leq 1$ for $y\geq 1$. $\blacksquare$

The adversary method is originally given in  [3] (the next statement is a reformulation due to  [1]).

Theorem 1** (Quantum adversary method [3])**

Let $\mathcal{A}$ $\subseteq f^{-1}\left(0\right)$ and $\mathcal{B}\subseteq f^{-1}\left(1\right)$ be sets of inputs to a Boolean function $f$. Let $R\left(A,B\right)\geq 0$ be a real-valued function, and for $A\in\mathcal{A}$, $B\in\mathcal{B}$, and index $i$, let

[TABLE]

where $A(i)$ and $B(i)$ denote the value of the $i$th variable for $A$ and $B$, respectively, the denominators are all nonzero. Then the number of quantum queries needed to evaluate $f$ with probability at least $9/10$ is $\Omega\left(1/\upsilon_{\operatorname*{geom}}\right)$, where

[TABLE]

A different function of $\theta(A,i)$ and $\theta(B,i)$ gives a randomized lower bound.

Theorem 2** (Classical adversary method [1])**

Let $\mathcal{A},\mathcal{B},R,\theta$ be the same as in Theorem 1. Then the number of randomized queries needed to evaluate $f$ with probability at least $9/10$ is $\Omega\left(1/\upsilon_{\min}\right)$, where

[TABLE]

3 Best-Case Analysis

This section gives the lowest query complexity of those of all Boolean functions in ${\cal F}_{N,M}$.

Theorem 3** (Quantum Lower Bound of Any $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N-1},$ any $f\in{\cal F}_{N,M}$ has quantum query complexity $\Omega(\sqrt{N-\log M})$.

*Proof * We use the sensitivity argument. Recall that the sensitivity $s_{x}(f)$ of a Boolean function $f$ on $x\in\{0,1\}^{N}$ is the number of variables $x_{i}$ such that $f(x)\neq f(x^{i})$, where $x^{i}$ is the string obtained from $x$ by flipping the value of $x_{i}$. The sensitivity $s(f)$ of $f$ is the maximum of $s_{x}(f)$ over all $x$. The results of Beals et al. [10] implies $Q(f)=\Omega(\sqrt{s(f)})$. We shall prove $s(f)\geq N-\log M$ for any $f$ in ${\cal F}_{N,M}$, from which the theorem follows.

Let $A$ be the on-set of $f$ (note that $|A|=M$). Let $\Gamma(A)$ be the set of edges between $A$ and $\{0,1\}^{N}\setminus A$ of the Boolean cube $\{0,1\}^{N}$. The results in [11, 20] on the edge-isoperimetric problem on a Boolean cube states $|\Gamma(A)|$ is minimized when $A$ is as close to a subcube as possible; each element of $A$ that minimizes $|\Gamma(A)|$ has about $\log\frac{2^{N}}{M}$ neighbors in $\{0,1\}^{N}\setminus A$. More formally, it is known that:

[TABLE]

Then,

[TABLE]

where we use $\sum_{x\in A}s_{x}(f)=|\Gamma(A)|$. Therefore,

[TABLE]

This completes the proof. $\blacksquare$

Since $R(f)=\Omega(s(f))$ [24], we obtain a randomized lower bound with a similar argument.

Theorem 4** (Randomized Lower Bound of Any $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N-1},$ any $f\in{\cal F}_{N,M}$ has randomized query complexity $\Omega(N-\log M)$.

The next theorem shows the tightness of the above lower bounds (note that, for $M=2^{cN}$ with any constant $c<1$, the randomized lower bound in Theorem 4 is obviously tight).

Theorem 5** (Tightness of Lower Bounds)**

For every $1\leq M\leq 2^{cN}$ with an arbitrary large constant $c<1$, there is a function whose quantum query complexity is $O(\sqrt{N})$. For $M=2^{(1-o(1))N}$, there is a function whose quantum and randomized query complexities are $O(\sqrt{N-\log M})$ and $O(N-\log M)$, respectively, if $M$ is a power of 2.

*Proof * Let $C_{M}$ be the set of $N$-bit strings

[TABLE]

a maximal Boolean cube of size at most $M$. Consider the function whose onset is

[TABLE]

where $\Delta M\equiv M-2^{\lfloor\log M\rfloor}$ and $y$ is a ${\lfloor\log M\rfloor}$-bit string.

Suppose $M$ is a power of 2. To evaluate this function, we first test if string “$x_{\lfloor\log M\rfloor+1}\dots x_{N}$” is $0^{N-\lfloor\log M\rfloor}$ with Grover’s search algorithm. If the test is passed, output $f=1$; otherwise output $f=0$. Clearly, the quantum query complexity of this test is $O(\sqrt{N-\log M})$.

Suppose $M$ is not a power of 2. We perform another test if the above test is not passed. The additional test is to check if string “$x_{\lfloor\log M\rfloor+1}\dots x_{N}$” is “$10^{N-\lfloor\log M\rfloor-1}$” and if the integer represented by $x_{1}\dots x_{\lfloor\log M\rfloor}$ is at most $M-2^{\lfloor\log M\rfloor}-1$. We claim that this test can be done with $O(\sqrt{N-\log M}+\sqrt{\log M})$ quantum query complexity. Therefore, the overall quantum query complexity is $O(\sqrt{N-\log M}+\sqrt{\log M})=O(\sqrt{N})$.

We now prove the claim. The checking if $w:=x_{\lfloor\log M\rfloor+1}\dots x_{N}$ is “$10^{N-\lfloor\log M\rfloor-1}$” can be done with Grover search over $w\oplus 10^{N-\lfloor\log M\rfloor-1}$, where $\oplus$ is bit-wise XOR, which needs $O(\sqrt{N-\log M})$ quantum queries. For checking if the integer represented by $z:=x_{1}\dots x_{\lfloor\log M\rfloor}$ is at most $M-2^{\lfloor\log M\rfloor}-1$, we just need to search the bit $x_{i}$ with the largest index $i$ such that $x_{i}$ does not agree to the $i$th bit of $(M-2^{\lfloor\log M\rfloor}-1)_{2}$, where $(k)_{2}$ is the $(\lfloor\log M\rfloor)$-bit binary expression of integer $k$. To do this, we perform binary search over $z$ with Grover search. Namely, let $\tilde{z}:=z\oplus(M-2^{\lfloor\log M\rfloor}-1)_{2}$, and run Grover search over the first half of $\tilde{z}$. If no “1” is found, then run Grover search over the first half of the rest; otherwise the first quarter of $\tilde{z}$. This procedure is recursively performed until the size of search space is at most some constant. To bound the total error probability by some constant, we repeat the $k$th search $O(k)$ times. Then the sum of error probability of each recursion is a geometric series; it is bounded by some constant. Since the $k$th search space is of size $|\tilde{z}|/2^{k}$, the query complexity of the $k$th search is bounded by $O(k\sqrt{|\tilde{z}|/2^{k}})$. Therefore the quantum query complexity of the search over $\tilde{z}$ is the sum of $O(k\sqrt{|\tilde{z}|/2^{k}})$ over all $k$, i.e., $O(\sqrt{|\tilde{z}|})=O(\sqrt{\log M})$.

The randomized upper bound is obtained by a similar argument except that sequential classical queries are used instead of Grover search. $\blacksquare$

4 Worst-Case Analysis

In this section, we consider the highest quantum query complexities over all Boolean functions in ${\cal F}_{N,M}$.

To prove the upper bound, we reduce the problem to Oracle Identification Problem (OIP)  [6, 7] defined as follows: Given an oracle $x$ and a set $S$ of $M$ oracle candidates out of $2^{N}$ ones, determine which oracle in $S$ is identical to $x$ with the promise that $x$ is a member of $S$. OIP can be solved with a constant success probability by making $O(\sqrt{N(1+\frac{\log{M}}{\log{N}})})$ quantum queries to the given oracle if $1\leq M\leq 2^{N^{d}}$ for some constant $d$ $(0<d<1)$  [7]. In the proof below, we improve the previous algorithm [7] so that it can optimally work for a wider range of $M$, and apply it.

Now, we give an upper bound for the query complexities of all Boolean functions in ${\cal F}_{N,M}$.

Theorem 6** (Quantum Upper Bound of Any $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N/(\log{N})^{2+\epsilon}}$ for an arbitrary small positive constant $\epsilon$, any Boolean function $f\in{\cal F}_{N,M}$ has quantum query complexity $O\left(\sqrt{N\frac{\log{M}}{\log{N}-\log\log{M}}}+\sqrt{N}\right)$.

*Proof * We set candidate set $S$ of OIP to the on-set of $f$, which can be constructed from the known truth table of $f$. Note that $|S|=M$ since $f\in{\cal F}_{N,M}$. We then invoke the OIP algorithm [7] with $S$ to find the hidden oracle with $O(\sqrt{N(1+\frac{\log{M}}{\log{N}})})$ queries, assuming the promise that the current oracle $x$ is in $S$ (actually, the promise does not hold if $f(x)=0$). Let $z\in\{0,1\}^{N}$ be the string that the OIP algorithm outputs.

If $f(x)=1$, the promise of the above OIP is indeed satisfied; $z$ is equal to $x$ with high probability.

If $f(x)=0$, the promise does not hold; the OIP algorithm outputs some answer $z\in S$ (note that $z\neq x$). To recognize this case, it suffices to check whether $z$ is equal to $x$ by using Grover search with $O(\sqrt{N})(\in O(\sqrt{N(1+\frac{\log{M}}{\log{N}})}))$ queries. This completes the proof for $1\leq M\leq 2^{N^{d}}$ for some constant $k$ and any constant $0<d<1$.

For bigger $M$, we cannot use the original OIP algorithm [7]. Very roughly speaking, the OIP algorithm recursively repeats the following procedure. Suppose that the given candidate set is represented by an $M$-by-$N$ matrix, in which each row corresponds to a candidate. First collect the set $T$ of columns each of which covers (i.e., has 1 at the positions of) a disjoint fraction that is at least $\beta$ and at most some constant, of the current rows (candidate) set $S$, and then apply Grover search to the oracle restricted to set $T$ to find 1; if 1 is found, we can reduce the row set into the fraction. For small $\beta$, we may reduce the candidates into a small set of rows, but the Grover search may cost too much since the cardinality of $T$ can be roughly $1/\beta$; $\beta$ must be set to an appropriate value [7]:

[TABLE]

If the Grover search fails, the rows covered by $T$ are excluded from the matrix, and the remaining matrix is sparse. To further reduce the set rows of the sparse matrix, multi-target Grover search [12] is used with promise that the fraction of 1 over $N$ bits in the oracle is $\gamma<1/2$. The proof in [7] shows that if $\gamma$ is adjusted to $\Theta({\log{|S|}}/{(N\log{N})})$ so that the number of $N$ bit strings with Hamming weight at most $\gamma N$ is about the square root of $|S|$, the total query complexity is $O(\sqrt{N\log{M}\log{N}}/\log{(1/\beta)})$, which gives $O(\sqrt{N\log{M}/\log{N}})$ for $M\leq 2^{N^{d}}$.

To expand the range of $M$ for which the algorithm can work, we slightly decrease the value of $\beta$ to handle large $M$:

[TABLE]

To meet $\beta^{\prime}<1$, it is required that $M\leq 2^{N/(\log{N})^{2+\epsilon}}$. Note that $\beta^{\prime}=\Theta(\beta)$ for the original range of $M$, $M\leq 2^{N^{d}}$. We can also set $\gamma$ to a more precise value satisfying $\sum_{k=0}^{\gamma N}\binom{N}{k}\leq|S|^{1/2}$ by virtue of Lemma 1, namely,

[TABLE]

These changes of parameter values yield the total query complexity of

[TABLE]

which gives the complexity in the statement. The details of the proof are the same with those in the original algorithm [7]. $\blacksquare$

The following corollary is immediate.

Corollary 1

For every $M=O(N^{O(1)})$, any function $f\in{\cal F}_{N,M}$ has quantum query complexity $O(\sqrt{N})$.

The following theorem shows the bound in Theorem 6 is tight.

Theorem 7** (Tightness of the Upper Bound)**

For every $1\leq M\leq 2^{N-1}$, there is a function $f\in{\cal{F}}_{M}$ whose quantum and randomized query complexities are $\Omega\left(\sqrt{N\frac{\log{M}}{c+\log{N}-\log\log{M}}}+\sqrt{N}\right)$ for a positive constant $c$ and $\Omega(N)$, respectively.

*Proof *If $1\leq M\leq N^{2}$, the upper bound $O(\sqrt{N})$ given in Theorem 6 matches the lower bound given in Theorem 3. This implies that there exists a function with query complexity $\Omega\left(\sqrt{N\frac{\log{M}}{c+\log{N}-\log\log{M}}}+\sqrt{N}\right)=\Omega(\sqrt{N})$.

Suppose that $N^{2}\leq M\leq 2^{N-1}$. Let $k$ be the integer that satisfies

[TABLE]

Consider a Boolean function $f$ such that $f(x)=1$ for all $x$ with $\mbox{Ham}(x)\leq k$ and for $M-D$ assignments $x$ with $\mbox{Ham}(x)\geq k+2$, and $f(x)=0$ for all the remaining assignments. Here, $\mbox{Ham}(x)$ denotes the Hamming weight of $x$. We claim that the quantum query complexity of $f$ is $\Omega(\sqrt{Nk})$, which is proved later. To complete the proof, it suffices to show that $k=\Omega(d(M/N))$ for the function $d(\cdot)$ defined in Lemma 1, since $\Omega(d(M/N))=\Omega(\log{M}/(\log{eN}-\log\log{N}))$: by simple algebra, it holds that (by assuming $d(M/N)$ is an integer for simplicity):

[TABLE]

where the last inequality is due to Lemma 1.

Now we prove the claim. Let ${\cal A}\subseteq f^{-1}(0)$ and ${\cal B}\subseteq f^{-1}(1)$ be defined as the sets of $x$’s with $\mbox{Ham}(x)=k+1$ and $\mbox{Ham}(x)=k$, respectively. For any $A\in{\cal A}$ and $B\in{\cal B}$, let us define the relation $R$ in Theorem 1 as $R(A,B)=1$ if $A$ and $B$ differ in exactly one position and $R(A,B)=0$ otherwise. Then, it can be shown that $\theta(A,i)=1/(k+1)$, and $\theta(B,i)=1/(N-k)$ by the definition of $A$ and $B$. Hence we obtain the lower bound $\Omega(\sqrt{Nk})$ by Theorem 1.

The randomized lower bound is obtained by applying Theorem 2 with a similar argument. $\blacksquare$

Remark 1

The proof of Theorem 6 shows that computing $f\in{\cal F}_{N,M}$ is reducible to OIP with $M$ candidates and Grover search. Since Grover search has query complexity $O(\sqrt{N})$, Theorem 7 implies $\Omega\left(\sqrt{N\frac{\log{M}}{c+\log{N}-\log\log{M}}}\right)$ is also a lower bound of OIP for every $N^{\omega(1)}<M\leq 2^{N}/2$. (The query complexity of OIP is $\Omega(N)$ for every $2^{N}/2<M\leq 2^{N}$, since OIP with $M$ candidates is reducible to OIP with $M^{\prime}\ (>M)$ candidates.) This is an improvement over the lower bound of OIP in [7] for large $M$.

Applications

As an application of Theorem 6, we consider the problem of graph property testing, i.e., the problem of testing if $G$ has a certain property for a given graph $G$. More precisely, an $n$-vertex graph is given as $n(n-1)/2$ Boolean variables, $x_{i}$ for $i\in\{1,\dots,n(n-1)/2\}$, representing the existence of the $i$th possible edge $e_{i}$, i.e., $x_{i}=1$ if and only if $e_{i}$ exists. In this setting, graph property testing is just the problem of evaluating a Boolean function $f$ depending on the $n(n-1)/2$ variables such that $f(x_{1},\dots,x_{n(n-1)/2})=1$ if and only if the graph has a certain property. An interpretation of graph property testing according to Theorem 6 is to decide if $G$ is a member of $\mathcal{F}$ for the family $\mathcal{F}$ of all graphs with certain properties. Thus, Theorem 6 directly gives the next lemma with $M=|\mathcal{F}|$ and $N=n(n-1)/2$.

Lemma 2

Any graph property $P$ can be tested with $O\left(\sqrt{n^{2}\frac{\log|\mathcal{F}|}{c+\log n-\log\log|\mathcal{F}|}}+n\right)$ quantum queries for a positive constant $c$, where $\mathcal{F}$ is the family of all graphs having property $P$, if $1\leq|\mathcal{F}|\leq 2^{\binom{n}{2}/{(\log\binom{n}{2})^{2+\epsilon}}}$ for an arbitrary small positive constant $\epsilon$.

An interesting special case is graph isomorphism testing against a fixed graph, the problem of deciding if a given graph $G$ is isomorphic to an arbitrary fixed graph $G^{\prime}$.

Theorem 8** (Graph Isomorphism Testing against a Fixed Graph)**

Graph isomorphism testing against a fixed graph has $O(n^{1.5})$ quantum query complexity and $\Omega(n^{2})$ randomized query complexity.

*Proof * The number of graphs isomorphic to $G^{\prime}$ is at most the number of permutations over the vertex set, i.e., $n!=2^{O(n\log n)}$, from which together with Lemma 2 the quantum upper bound follows. The randomized lower bound follows from Theorem 4. $\blacksquare$

This upper bound is optimal in the worst case over all possible $G^{\prime}$, since the lower bound $\Omega(n^{1.5})$ of connectivity testing problem in Ref. [17] is essentially the lower bound of deciding whether a given graph is isomorphic to one cycle or two cycles.

Another interesting special case is graph genus testing, the problem of testing if a given graph is a connected graph with genus $g$. Informally, the genus of a connected graph $G$ is the minimum number of handles that need to be added to the plane so that the graph can be drawn without edge crossing (see, e.g., [16]). Note that for $g=0$, graph genus testing is planarity testing, i.e., determining if a given graph is planar.

Theorem 9** (Graph Genus Testing)**

For $g=\left\{\binom{n}{2}\right\}^{c}=O(n^{2c})$ for an arbitrary large constant $0\leq c<1$, graph genus testing has $O(n\sqrt{n+g})$ quantum query complexity and $\Omega(n^{2})$ randomized query complexity.

*Proof * For any connected graph embedded on a surface of genus $g$, Euler’s equation (see, e.g.,  [16]) says $n-m+f=2-2g$, where $n\geq 3$, $m$ and $f$ are the numbers of vertices, edges and faces. Every face is adjacent to at least three edges and every edge is adjacent to at most two faces, from which we have $f\leq 2m/3$. Hence, $m\leq 3({n-2+2g})$, and then $|{\cal F}|\leq\sum_{i=0}^{m}\binom{n^{2}}{i}\leq(m+1)n^{2m}=2^{O(m\log n)}=2^{O((n+g)\log n)}.$ Since $g=\left\{\binom{n}{2}\right\}^{c}$ for constant $0\leq c<1$, $|{\cal F}|\leq 2^{O((n+g)\log n)}<2^{\binom{n}{2}/{(\log\binom{n}{2})^{2+\epsilon}}}$ for sufficiently large $n$. Therefore, we can apply Lemma 2 to obtain the quantum upper bound. The randomized lower bound is due to Theorem 4. $\blacksquare$

5 Average-Case Analysis

This section considers the upper and lower bounds for the quantum query complexities of almost all functions in ${\cal F}_{N,M}$. To prove the upper bound, we need the following lemmas. The first one bounds the inner product of two quantum states associated with two different oracles. The second one is a result of quantum state discrimination.

Lemma 3

Let $|\psi_{x}\rangle=\frac{1}{\sqrt{N}}\sum_{i=1}^{N}(-1)^{x_{i}}|i\rangle$ for $x=(x_{1},\dots,x_{N})\in\{0,1\}^{N}$. For any $f$ in at least $(1-2/M^{0.88})$ fraction of ${\cal F}_{N,M}$ with $N\leq M\leq 2^{N-1}$, it holds that $|\langle\psi_{x}|\psi_{y}\rangle|\leq 2\sqrt{\frac{\log{M}}{{N}}}$ for every two different states $|\psi_{x}\rangle$ and $|\psi_{y}\rangle$ where $x,y\in f^{-1}(1)$.

*Proof * Since $|\langle\psi_{x}|\psi_{y}\rangle|\leq 1$ obviously holds for every two quantum states, we will only show the lemma when $N\leq M\leq 2^{N/4}$. Notice that by the definition,

[TABLE]

where $\mathrm{Ham}(x,y)$ is the Hamming distance of $x$ and $y$.

We can prove the following claim (The proof can be found in Appendix).

Claim 1

If $f$ is uniformly distributed over ${\cal F}_{N,M}$ with $M\leq 2^{N/4}$, then $\mathrm{Ham}(x,y)\geq N\left(\frac{1}{2}-\sqrt{\frac{(2+\epsilon)}{\log e}\frac{\log M}{2N}}\right)$ holds for every pair of different $x,y\in f^{-1}(1)$ with probability $1-2/M^{\epsilon}$, where $\epsilon$ is an any positive constant.

The lemma then follows from the claim by setting $\epsilon=2\log e-2>0.88$. $\blacksquare$

Lemma 4** ([21])**

Suppose that a set of $M$ quantum states, $\{|\phi_{x}\rangle\}_{x\in S}$, is known, where $S$ is an index set of cardinality $M$, and that $|\langle\phi_{x}|\phi_{y}\rangle|^{2}\leq F<1$ for any pair of different $x,y\in S$. If $m=O(\log{M}/\log{(1/F)})$ copies of unknown $|\phi_{x}\rangle$, i.e., $|\phi_{x}\rangle^{\otimes m}$, are given, it is possible to identify index $x$ with probability at least $2/3$.

Now, we are ready to show an upper bound for the quantum query complexities of almost all functions in ${\cal F}_{N,M}$.

Theorem 10** (Quantum Upper Bound for Almost All $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N-1}$, any Boolean function in at least $(1-1/N^{k})$ fraction of ${\cal F}_{N,M}$ has quantum query complexity $O(\frac{\log{M}}{c+\log{N}-\log\log{M}}+\sqrt{N})$, where $k\geq 1$ is an arbitrary constant and $c$ is a certain positive constant.

*Proof * If $1\leq M\leq N^{d}$ for an arbitrary constant $d\geq 2$, all functions in ${\cal F}_{N,M}$ has query complexity $\Theta(\sqrt{N})$ by Corollary 1; the theorem holds. If $M>2^{N/5}$, we will prove the lower bound is $\Omega(N)$ in Theorem 11.

Suppose $N^{d}<M\leq 2^{N/5}$. We give an algorithm for computing $f$ based on Lemma 4. Set $S:=f^{-1}(1)$. We then create $m$ copies of quantum state $|\psi_{x}\rangle$, each of which requires only one query, where $x$ is the $N$-bit string in the given oracle. Lemma 3 says that $|\langle\psi_{x}|\psi_{y}\rangle|\leq 2\sqrt{\frac{\log{M}}{{N}}}$ for any $f$ in at least $(1-2/N^{0.88d})$ fraction of ${\cal F}_{N,M}$. Suppose $f$ is in the fraction. By setting $F=4\frac{\log{M}}{{N}}$, Lemma 4 says that we can identify $x$ with only $m=O(\log{M}/(c+\log{N}-\log\log{M}))$ copies, i.e., with only $m$ queries with probability at least 2/3, if $x\in S$.

If $x\not\in S$, the output may be some $y\in S$ (obviously, $x\neq y$). This case can be detected by running Grover search over $x\oplus y$, where $\oplus$ is bit-wise XOR.

In summary, our algorithm first performs the quantum state discrimination procedure to identify $x$, and then runs Grover search to test if the output of the above procedure is equal to $x$. The total quantum query complexity is $O(\frac{\log{M}}{c+\log{N}-\log\log{M}}+\sqrt{N})$. We can set $d\ (\geq 2)$ such that $2/N^{0.88d}\leq 1/N^{k}$ for every $k\geq 1$. Therefore, the theorem follows. $\blacksquare$

We can show the optimality of Theorem 10 as follows.

Theorem 11** (Quantum Lower Bound for Almost All $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N-1}$, at least $1-1/2^{N}$ fraction of ${\cal{F}}_{N,M}$ have quantum query complexity $\Omega(\frac{\log{M}}{c+\log{N}-\log\log{M}}+\sqrt{N})$, where $c>0$ is a certain constant.

*Proof * If $1\leq M\leq 2^{\sqrt{N}}$, the query complexity of all Boolean functions in ${\cal F}_{N,M}$ is $\Omega(\sqrt{N})$ by Theorem 3; the theorem holds. Thus, we shall prove the theorem for $2^{\sqrt{N}}<M\leq 2^{N-1}$

We shall bound the number of quantum queries by the monotone non-decreasing function $d(z)$ in Lemma 1. First, notice that the number of functions in ${\cal{F}}_{N,M}$ is $\binom{2^{N}}{M}$, which is at least $\left(\frac{2^{N}}{M}\right)^{M}=2^{M^{\prime}}$ for $M^{\prime}=M(N-\log{M})$. Secondly, notice that the number of Boolean functions computable with success probability more than $1/2$ with at most $d/2$ queries is at most $T(N,d)=2\sum_{i=0}^{D-1}\binom{2^{N}-1}{i}$ for $D=\sum_{i=0}^{d}\binom{N}{i}$. This bound is derived from the following two properties of a sign-representing polynomial $p$, a real-valued polynomial with properties that $p(x)$ is positive whenever $f(x)=0$ and $p(x)$ is negative whenever $f(x)=1$: (i) The unbounded-error quantum query complexity of a Boolean function $f$, where the success probability is only guaranteed to be more than $1/2$, is exactly half of the minimum degree of its sign-representing polynomial [23, 13]. (ii) The number of Boolean functions whose minimum degrees of sign-representing polynomials are at most $d$ is $T(N,d)$ [8].

We shall complete the proof of the theorem by the following three claims. Claims 2 and 3 show that, for $z=\frac{M^{\prime}}{(N+1)^{2}}$, the value of $T(N,d(z))$ (or, the number of functions computable with quantum queries at most $d(z)/2$) is very small compared to $2^{M^{\prime}}$, i.e., $T(N,d(z))/|{\cal{F}}_{N,M}|\leq 1/2^{N}$. Claim 4 proves the number of queries in the theorem.

Claim 2

For large $N$, $T(N,d(z))\leq\frac{1}{2^{N}}2^{ND}$.

Claim 3

For $z=\frac{M^{\prime}}{(N+1)^{2}}$, it holds that $ND\leq M^{\prime}$.

The theorem follows since, by Claims 2 and 3, $T(N,d)/|{\cal{F}}_{N,M}|\leq\frac{1}{2^{N}}2^{ND-M^{\prime}}\leq\frac{1}{2^{N}}$, for the number of queries $d\left(\frac{M^{\prime}}{(N+1)^{2}}\right)$ whose lower bound is proved by the following claim.

Claim 4

[TABLE]

Below are the proofs of the claims.

*Proof *[Claim 2] By definition of $T(N,d)$, we have

[TABLE]

where the last inequality is due to $2^{1+\log{D}+D\log{e}-D\log{(D-1)}}\leq 2^{2D-D\log{(D-1)}}\leq 1/2^{D}\leq{1}/{2^{N}}$ for large $N$. $\blacksquare$

*Proof *[Claim 3] By approximating the sum of binomials, we have, for $z=\frac{M^{\prime}}{(N+1)^{2}}\leq\frac{M^{\prime}}{N(N+1)}$,

[TABLE]

where the second last inequality is due to Lemma 1 and $d(z)\leq N$. $\blacksquare$

*Proof *[Claim 4] Recall that $d(z)$ is a monotone non-decreasing function, and therefore, because $M^{\prime}=M(N-\log{M})\geq M$, we have

[TABLE]

$\blacksquare$

This completes the proof of Theorem 11. $\blacksquare$

The above results essentially give the average quantum query complexity of uniformly distributed functions over ${\cal F}_{N,M}$.

Corollary 2

For every $1\leq M\leq 2^{N-1}$, the average quantum query complexities over uniformly distributed Boolean functions in ${\cal F}_{N,M}$ is $\Theta(\frac{\log{M}}{c+\log{N}-\log\log{M}}+\sqrt{N})$, where $c>0$ is a certain constant.

*Proof * By Theorems 10 and 11, at least $1-(1/N^{2}+1/N^{2})=1-2/N^{2}$ fraction of ${\cal F}_{N,M}$ has query complexity $\Theta(\frac{\log{M}}{c+\log{N}-\log\log{M}}+\sqrt{N})$. Since the remaining fraction contributes to the average by at most $N\cdot(2/N^{2})<1$, the corollary follows. $\blacksquare$

In the randomized setting, almost all functions in ${\cal F}_{N,M}$ are hard to compute for every $M$.

Theorem 12** (Randomized Lower Bound for Almost All $f$ in ${\cal F}_{N,M}$)**

For every $1\leq M\leq 2^{N-1}$, at least $1-1/2^{N}$ fraction of ${\cal{F}}_{N,M}$ has randomized complexity $\Omega(N)$.

*Proof * If $M\leq 2^{\epsilon N}$ for any constant $0<\epsilon<1$, Theorem 4 gives $\Omega(N)$ lower bound. Suppose that $M=2^{(1-o(1))N}$. Since, for every function, the randomized query complexity is at least the quantum query complexity, Theorem 11 implies that a lower bound of randomized query complexity is also $\Omega(\frac{\log{M}}{c+\log{N}-\log\log{M}})$ for at least $1-1/2^{N}$ fraction of ${\cal F}_{N,M}$. For $M=2^{(1-o(1))N}$, this bound is $\Omega(N)$. This completes the proof. $\blacksquare$

6 Conclusion

We gave the tight bounds of the worst-case, average-case, and best-case query complexities over family ${\cal F}_{N,M}$ for every on-set size $M$ except the upper bound of the worst-case quantum query complexity $Q_{\operatorname{worst}}({\cal F}_{N,M})$. The upper bound was proved for $1\leq M\leq 2^{N/(\log{N})^{2+\epsilon}}$ with any small positive constant $\epsilon$ and it matches the lower bound for this range of $M$. Since we know $Q_{\operatorname{worst}}({\cal F}_{N,M})=\Omega(N)$ only for $M=\Omega(2^{cn})$ for any constant $0<c<1$, there is still a gap between the upper and lower bounds of $Q_{\operatorname{worst}}({\cal F}_{N,M})$ for $2^{N/(\log{N})^{2+\epsilon}}<M<2^{cn}$. It is an open problem to close this gap.

We showed an application of the worst-case and best-case complexity bounds to some graph property testing problems. However, our bounds cannot give a good bound for all graph property testing problems. It would be interesting to find more problems to which our results can give a tight bound.

Acknowledgments

The authors are grateful to Kazuyuki Amano and Mario Szegedy for valuable comments.

Appendix

*Proof of Claim 1

The probability that an element $x\in f^{-1}(1)$ has Hamming distance larger than $r$ from every $y$ $(\neq x)$ in $f^{-1}(1)$ is

[TABLE]

where $D=\sum_{i=0}^{r}\binom{N}{i}$. Note that $D$ has the following upper bound as a consequence of Chernoff’s inequality;

[TABLE]

By the union bound, the probability that there is at least one $x\in f^{-1}(1)$ which has a neighbor $y\in f^{-1}(1)$ within the Hamming distance $r$ is

[TABLE]

We show that this probability is $o(1)$ for some $r=r^{*}$, implying that with probability $1-o(1)$, any $x,y\in f^{-1}(1)$ have Hamming distance at least $r^{*}$, as follows. Here, let $n^{\underline{m}}=\frac{m!}{(n-m)!}$.

[TABLE]

Thus, for any positive constant $\epsilon$, if we let

[TABLE]

then we have

[TABLE]

$\blacksquare$