Quantum Algorithm for Distribution-Free Junta Testing

TL;DR

This paper introduces a quantum algorithm for distribution-free junta testing that significantly improves complexity over classical methods, but also establishes limitations when using quantum examples instead of queries.

Contribution

It presents a quadratic complexity improvement for quantum junta testing and proves limitations for quantum example-based algorithms.

Findings

Quantum junta testing complexity is $O(k/\varepsilon)$, a quadratic improvement.

No efficient quantum algorithm exists for this problem using quantum examples.

Independent work by Bshouty achieved similar complexity results.

Abstract

Inspired by a recent classical distribution-free junta tester by Chen, Liu, Serverdio, Sheng, and Xie (STOC'18), we construct a quantum tester for the same problem with complexity $O(k/\varepsilon)$, which constitutes a quadratic improvement. We also prove that there is no efficient quantum algorithm for this problem using quantum examples as opposed to quantum membership queries. This result was obtained independently from the $\tilde O(k/\varepsilon)$ algorithm for this problem by Bshouty.

Equations

$$\frac{1}{\sqrt{2^{n}}}\sum_{x\in\{0,1\}^{n}}(-1)^{f(x)}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\stackrel{{\scriptstyle H^{\otimes n}}}{{\longmapsto}}\sum_{S\subseteq[n]}\hat{f}(S)\mathopen{}\mathclose{{}\left|S}\right>_{\mathsf{}},$$

$$\hat{f}(\varnothing )=\frac{1}{2^n}\sum _{x\in \{0,1{\}}^n}(-1{)}^{f(x)}.$$

$$S$$

$$\Pr_{x\sim\mathcal{D},\;T\subseteq[n]\setminus S}\bigl{[}f(x)\neq f(x^{T})\bigr{]}\geq\varepsilon/2,$$

$$\mathrm{Pr}[P(3k)\ge 18k]\le 1/2.$$

$$\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\frac{1}{\sqrt{2^{n}}}\sum_{x\in\{0,1\}^{n}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|f(x)}\right>_{\mathsf{}},\qquad\text{and}\qquad\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\sum_{x\in\{0,1\}^{n}}\sqrt{\mathcal{D}_{x}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|f(x)}\right>_{\mathsf{}},$$

$$f^{\prime }(x_1,\dots ,x_n,y_1,\dots ,y_k)=\{\begin{array}{ll}f(x_1,\dots ,x_n),& \text{if y=x[k];}\\ 0,& \text{otherwise}.\end{array}$$

$$\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\frac{1}{\sqrt{2^{n+k}}}\sum_{x\in\{0,1\}^{n}}\sum_{y\in\{0,1\}^{k}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|y}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}.$$

$$\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\frac{1}{\sqrt{2^{n}}}\sum_{x\in\{0,1\}^{n}}\bigl{|}x\bigr{>}_{\mathsf{}}\bigl{|}x_{[k]}\bigr{>}_{\mathsf{}}\bigl{|}\pi(x)\bigr{>}_{\mathsf{}}\bigl{|}f(x)\bigr{>}_{\mathsf{}},$$

$$\mathopen{}\mathclose{{}\left|z}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\mathopen{}\mathclose{{}\left|z}\right>_{\mathsf{}}\bigl{|}\pi^{-1}(z)\bigr{>}_{\mathsf{}}\bigl{|}f\bigl{(}\pi^{-1}(z)\bigr{)}\bigr{>}_{\mathsf{}},$$

$$z\mapsto\Bigl{(}\pi^{-1}(z),f\bigl{(}\pi^{-1}(z)\bigr{)}\Bigr{)}.$$

$$\mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\sum_{x\in\{0,1\}^{n}}\sqrt{\mathcal{D}_{x}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|\psi_{x}}\right>_{\mathsf{}},$$

Full text

We also prove that there is no efficient quantum algorithm for this problem using quantum examples as opposed to quantum membership queries.

This result was obtained independently from the $\widetilde{O}(k/\varepsilon)$ algorithm for this problem by Bshouty.

1 Introduction

The steadily growing size of data calls for algorithms that work extremely fast: with linear or, preferably, sub-linear complexity. To achieve this performance, certain assumptions must be made, usually in some sort of approximation guarantees.

Consider the problem of testing whether an object $f$ has some property $\mathcal{P}$. Typically, this task is hardest on instances $f$ that are close to the border: the ones that do not possess the property $\mathcal{P}$ but are extremely close to doing so. But often such meticulousness is not needed, as one can tolerate false positives that are close to true positives. What one usually wants is to filter out instances that are substantially far from having the property. The framework of property testing[12, 9] does exactly this: distinguishes the objects having the property $\mathcal{P}$ from the ones that are $\varepsilon$-far from $\mathcal{P}$. This is an active area of research both for classical (randomised) and quantum testers. See [11] for a survey on quantum property testing.

Junta Testing.

Let us focus on the case of testing juntas, which is the topic of this paper. A $k$-junta is a Boolean function $h\colon\{0,1\}^{n}\to\{0,1\}$ that only depends on $k$ out of its $n$ input variables. In other words, $h$ is a $k$-junta iff there exists a subset $\{a_{1},a_{2},\dots,a_{k}\}\subseteq[n]$ such that $h(x_{1},\dots,x_{n})=\hat{h}(x_{a_{1}},x_{a_{2}},\dots,x_{a_{k}})$ for some function $\hat{h}\colon\{0,1\}^{k}\to\{0,1\}$. A function $g\colon\{0,1\}^{n}\to\{0,1\}$ is $\varepsilon$-far from a $k$-junta iff $g$ differs from any $k$-junta in at least $\varepsilon 2^{n}$ points of the hypercube $\{0,1\}^{n}$. A junta tester, given access to a Boolean function $f$ and parameters $k$ and $\varepsilon$, has to distinguish between the cases when $f$ is a $k$-junta and when $f$ is $\varepsilon$-far from any $k$-junta. It is usually assumed that $n$ is much larger than $k$, and the goal is to construct a tester whose complexity does not depend on $n$, and is as optimal in terms of $k$ and $\varepsilon$ as possible.

Junta testing has interesting history with developments in classical and quantum algorithms coming hand in hand. In 2002, the problem was considered by Fischer et al. [8], and an algorithm with query complexity O\bigl{(}(k\log k)^{2}/\varepsilon\bigr{)} was constructed. In 2007, a quantum algorithm was constructed by Atıcı and Servedio [2], which uses $O(k/\varepsilon)$ quantum examples. But in 2009 classical algorithms caught up with an $O(k/\varepsilon+k\log k)$-query algorithm by Blais [3]. This is optimal due the lower bound by Sağlam [13] (see also [7]). In 2015, however, quantum complexity of the problem was improved to $O(\sqrt{k/\varepsilon}\log k)$ queries by Ambainis et al. [1]. This was shown to be almost optimal by Bun et al. [5]. Thus, query complexity of junta testing is well-understood both classically and quantumly.

Distribution-free testing.

The distribution-free property testing model was introduced by Goldreich et al. in [9]. It is similar to the usual model of property testing, but the distance to the property $\mathcal{P}$ is measured with respect to some unknown distribution $\mathcal{D}$ over the hypercube $\{0,1\}^{n}$. That is, $g$ is $\varepsilon$-far from a $k$-junta with respect to $\mathcal{D}$, iff $\Pr_{x\sim\mathcal{D}}[g(x)\neq h(x)]\geq\varepsilon$ for any $k$-junta $h$. The tester, in addition to oracle queries to $f$, can sample from $\mathcal{D}$. The tester should work for any distribution $\mathcal{D}$, and the complexity measure is the worst-case sum of the number of queries to $f$ and samples from $\mathcal{D}$. Thus, distribution-free property testing is at least as hard as usual property testing.

The motivation behind distribution-free property testing model is similar to that of the PAC learning model [14]. The uniform distribution might not be the right one to measure the distance, and it might be hard to get to know what the relevant probability distribution is. Thus, we would like to make as few assumptions on the distribution as possible. But the algorithm must have some access to the distribution in order to solve the problem, and sampling is one of the weakest modes of access.

Results.

Recently, Liu et al. [10] constructed a distribution-free randomised junta tester with complexity $\widetilde{O}(k^{2})/\varepsilon$. Our main result is a distribution-free quantum junta tester with a (slightly better than) quadratic improvement in $k$.

Theorem 1**.**

There exists an algorithm that, given quantum membership oracle access to a Boolean function $f\colon\{0,1\}^{n}\to\{0,1\}$, classical sample access to a probability distribution $\mathcal{D}$ on $\{0,1\}^{n}$, and parameters $k$ and $\varepsilon$, performs the following task. If $f$ is a $k$-junta, it accepts with probability 1. If $f$ is $\varepsilon$-far from any $k$-junta with respect to $\mathcal{D}$, it rejects with probability at least $1/2$. The algorithm uses $O(k/\varepsilon)$ queries to $f$ and samples from $\mathcal{D}$.

Up to our knowledge, this is the first distribution-free quantum property tester. We allow quantum membership queries to $f$. Additionally, we allow classical (not quantum!) sampling from $\mathcal{D}$. If one allows quantum example oracle access to $\mathcal{D}$, it is possible to get quadratic improvement in terms of $\varepsilon$ as well, see Section 5. We give additional justification to our model in Section 4, where we show that quantum example oracle is of little use to solve this problem.

Our algorithm is inspired by the algorithm by Liu et al., and it not only has smaller complexity, but is also conceptually simpler that the classical algorithm. Similarly to the tester by Atıcı and Servedio, the improvement stems from the fact that quantum algorithms can efficiently Fourier sample. Actually, the only quantum subroutine we use is the ability to Fourier sample the input function $f$ restricted to arbitrary hypercube of $\{0,1\}^{n}$.

Related Results.

During the review phase of this paper, classical complexity of the problem was improved to $\widetilde{O}(k/\varepsilon)$ queries by Bshouty [4], which is optimal up to logarithmic factors.

2 Preliminaries

We use notation $[n]=\{1,2,\dots,n\}$. For $x\in\{0,1\}^{n}$ and $T\subseteq[n]$, $x^{T}$ stands for the string $x$ with the bits in $T$ flipped. We write $x^{i}$ instead of $x^{\{i\}}$ for $i\in[n]$.

The following ways of accessing the input function $f\colon\{0,1\}^{n}\to\{0,1\}$ are used in the paper. A classical example is a pair $(x,f(x))$, where $x$ is drawn from some probability distribution (or uniformly if no distribution is specified). A classical membership oracle is a black-box that on a query $x$ returns the value of $f(x)$. A quantum example is a quantum state of the form \sum_{x\in\{0,1\}^{n}}\sqrt{\mathcal{D}_{x}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|f(x)}\right>_{\mathsf{}} for some probability distribution $\mathcal{D}$. Again, if no distribution is specified, we assume the uniform one. A quantum example oracle is a quantum subroutine that performs the transformation \mathopen{}\mathclose{{}\left|0}\right>_{\mathsf{}}\mapsto\sum_{x\in\{0,1\}^{n}}\sqrt{\mathcal{D}_{x}}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mathopen{}\mathclose{{}\left|f(x)}\right>_{\mathsf{}}. Quantum example oracles are more powerful than quantum examples: for instance, one can use quantum amplitude amplification with them. Finally, a quantum membership oracle is a quantum subroutine performing the transformation \mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}}\mapsto(-1)^{f(x)}\mathopen{}\mathclose{{}\left|x}\right>_{\mathsf{}} for all $x\in\{0,1\}^{n}$. It is the same as the usual quantum input oracle.

In order to distinguish quantum example and membership oracles, we use terms quantum sample and query, respectively, for their execution. Classically, we use terms “sample” and “example” as synonymous. For each quantum oracle, we also assume access to its inverse.

The main technical tool we use is Fourier sampling. The Fourier transform (also known as the Walsh-Hadamard transform) of a Boolean function $f$ is the linear mapping

[TABLE]

where $\hat{f}(z)$ are the Fourier coefficients of $f$. Here the subset $S$ on the right-hand side can be identified with its characteristic string.

The Fourier transformation can be efficiently implemented on a quantum computer: it only requires $n$ Hadamard gates $H=\frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\ 1&-1\end{pmatrix}$. If the state on the right-hand side of (1) is measured, the outcome $S$ is obtained with probability $\hat{f}(S)^{2}$. This is known as Fourier sampling. The sum of $\hat{f}(S)^{2}$ equals 1 since $H^{\otimes n}$ is a unitary transformation.

We only use the following two properties of the Fourier transform. First, if $\hat{f}(S)\neq 0$, then $f$ depends on all variables in $S$. Second,

[TABLE]

3 The Algorithm

In this section we describe our algorithm and prove Theorem 1. Before we proceed with this task, let us introduce some notation. Everywhere in this section we assume that an input function $f\colon\{0,1\}^{n}\to\{0,1\}$ is fixed.

A variable $i\in[n]$ is called relevant if there exists an input $x\in\{0,1\}^{n}$ such that $f(x)\neq f(x^{i})$. Note that a function $f$ is a $k$-junta if and only if it has at most $k$ relevant variables.

A cube $B=(x,y)$ is a subcube of the hypercube $\{0,1\}^{n}$ and is specified by its two opposite vertices $x$ and $y$. That is, $B$ is the set of all bit-strings in $\{0,1\}^{n}$ that agree to either $x$ or $y$ in each position. Let $I(B)$ be the set of variables where $x$ and $y$ disagree. A cube $B=(x,y)$ is called relevant if $f(x)\neq f(y)$. Note that if a cube $B$ is relevant, then at least one variable in $I(B)$ is relevant.

A formal description of the tester is given in Algorithm 1, and it depends on two subroutines: GenerateCube and FourierSample given in Algorithms 2 and 3, respectively. The subroutine GenerateCube($S$) finds a cube $B$ such that $I(B)$ does not intersect $S$. The subroutine FourierSample($B$) performs Fourier sampling from the function $f$ restricted to the subcube $B$.

The algorithm maintains a subset of variables $S\subseteq[n]$ and a collection of cubes $\mathcal{B}$. The following invariants are maintained throughout the algorithm:

[TABLE]

Claim 2**.**

The invariants in (3) are maintained throughout the algorithm.

Proof.

Clearly, the invariants are satisfied at the beginning of the algorithm when both $S$ and $\mathcal{B}$ are empty. Consider all the steps of Algorithm 1 where $S$ or $\mathcal{B}$ change. In 2(a), $B$ is a relevant cube and $I(B)$ does not intersect $S$ by the requirement on the subroutine GenerateCube. In 2(c), the set $T$ returned by FourierSample has non-zero Fourier coefficient in $f$ restricted to $B$. This means that all the variables in $T$ are relevant. Also $T\subseteq I(B)$, hence, the new $S$ does not intersect any of the remaining cubes in $\mathcal{B}$. In 2(e), we have $f(z)\neq f(x)$ and $f(t)\neq f(x)$, hence the two new cubes are relevant. Also note that $t=x^{I(B)\setminus T}$. Hence, $I(x,z)$ and $I(x,t)$ are disjoint and do not intersect $S$ nor the remaining cubes in $\mathcal{B}$. The case 2(f) is similar. ∎

Concerning the terminating condition in Steps 2 and 3 of Algorithm 1, we have the following result.

Proposition 3**.**

If $S$ and $\mathcal{B}$ satisfy the conditions in (3) and $|S|+|\mathcal{B}|>k$, then $f$ is not a $k$-junta.

Proof.

Each cube $B\in\mathcal{B}$ contains a relevant variable. By the second condition in (3), all these variables are distinct and different from the variables in $S$. Thus, together with the variables in $S$, $f$ has more than $k$ relevant variables. This means that $f$ is not a $k$-junta. ∎

Concerning the GenerateCube subroutine, we have the following lemma from [10].

Lemma 4** ([10], Lemma 3.2. arXiv version).**

Assume $f\colon\{0,1\}^{n}\to\{0,1\}$ is $\varepsilon$-far from any $k$-junta with respect to $\mathcal{D}$, and $S$ is a subset of $[n]$ of size at most $k$. Then,

[TABLE]

where $x$ is sampled from $\mathcal{D}$, and $T$ is a uniformly random subset of $[n]\setminus S$.

Corollary 5**.**

In the assumptions of Lemma 4, the probability that the GenerateCube($S$) subroutine returns ‘fail’ is at most $1/2$.

Proof.

By Lemma 4, the probability that the subroutine returns ‘fail’ is at most $(1-\varepsilon/2)^{2/\varepsilon}<1/\mathsf{e}<1/2$. ∎

The number of iterations of the loop in Step 2 of Algorithm 1 is based on the following lemma.

Lemma 6**.**

Assume $f$ is $\varepsilon$-far from a $k$-junta relative to $\mathcal{D}$, and consider one iteration of the loop in Step 2 of Algorithm 1. Let $S$ and $\mathcal{B}$ be the values of these variables before the iteration, and $S^{\prime}$ and $\mathcal{B}^{\prime}$ after the iteration. If $|S|\leq k$, then, with probability at least 1/3, we have $2|S^{\prime}|+|\mathcal{B}^{\prime}|\geq 2|S|+|\mathcal{B}|+1$.

Proof.

Assume first $\mathcal{B}=\emptyset$. Then by Corollary 5, with probability at least $1/2$, the GenerateCube subroutine does not fail and the size of $\mathcal{B}$ becomes 1, which gives $2|S^{\prime}|+|\mathcal{B}^{\prime}|=2|S|+|\mathcal{B}|+1$.

Now consider the case when $\mathcal{B}$ is not empty, and let $B$ be the cube selected on step 2(b). Denote by $f|_{B}$ the function $f$ restricted to the inputs in the subcube $B$. There are two cases: $f|_{B}$ is $1/3$-far from a constant function, or $f|_{B}$ is $1/3$-close to a constant function relative to the uniform distribution on $B$.

In the first case, by (2), the absolute value of the Fourier coefficient of $\emptyset$ is at most $2/3-1/3=1/3$. Hence, with probability $8/9$, the set $T$ in 2(c) is non-empty. In this case, the size of $\mathcal{B}$ is reduced by 1, but the size of $S$ grows by at least 1, which gives $2|S^{\prime}|+|\mathcal{B}^{\prime}|\geq 2|S|+|\mathcal{B}|+1$.

In the second case, when $f$ is $1/3$-close to a constant function, the probability that $f(z)=f(t)$ is at least $1/3$. In this case, the size of $S$ does not change, but the size of $\mathcal{B}$ grows by 1, which gives $2|S^{\prime}|+|\mathcal{B}^{\prime}|=2|S|+|\mathcal{B}|+1$. ∎

Proof of Theorem 1.

Now we can prove the theorem. If $f$ is a $k$-junta, Algorithm 1 always accepts due to Proposition 3. Let us prove that if $f$ is $\varepsilon$-far from a $k$-junta relative to $\mathcal{D}$, then the algorithm rejects with probability at least $1/2$.

Assume for a moment there is no upper bound of $18k$ on the number of iterations of the loop in Step 2 of the algorithm. Let $P(i)$ denote the number of iterations of the loop after which it holds that $2|S|+|\mathcal{B}|\geq i$ or $|S|+|\mathcal{B}|>k$. By Lemma 6, we have that $\mathbb{E}[P(i+1)-P(i)]\leq 3$. As $P(0)=0$, by linearity of expectation, we have that $\mathbb{E}[P(3k)]\leq 9k$. By Markov’s inequality,

[TABLE]

Note that $2|S|+|\mathcal{B}|\geq 3k$ implies $|S|+|\mathcal{B}|>k$. Thus, (4) means that Algorithm 1 rejects with probability at least $1/2$.

The complexity of the algorithm is $O(k/\varepsilon)$, as it performs $O(k)$ iterations of the loop, and each iteration costs at most $O(1/\varepsilon)$. ∎

4 Uselessness of Quantum Examples

One interesting feature of the quantum junta tester by Atıcı and Servedio [2] is that it only uses quantum examples and not quantum or classical membership queries. This constitutes an exponential improvement since exponentially many classical examples are required to solve the problem (see Lemma 8 below). Also, this is still the best known quantum algorithm that only uses quantum examples, as the algorithm by Ambainis et al. [1] uses quantum membership queries.

Our algorithm in Section 3 uses quantum membership queries, and a natural question arises whether it is possible to attain similar complexity using only quantum examples. We show that this is impossible: contrary to the uniform case, in the distribution-free case, exponentially many quantum examples are required. As it is unclear whether quantum examples should come from the uniform distribution or from $\mathcal{D}$, we show that neither of them works.

Theorem 7**.**

Assume a quantum algorithm has quantum example oracle access to a Boolean function $f$ with respect to both uniform probability distribution and $\mathcal{D}$. Then, $2^{\Omega(k)}$ executions of these oracles are required to distinguish whether $f$ is a $k$-junta or $\Omega(1)$-far away from any $k$-junta with respect to $\mathcal{D}$.

Recall that quantum example oracles with respect to the uniform distribution and $\mathcal{D}$ are quantum subroutines that perform the following transformations

[TABLE]

respectively. In the remaining part of this section, we sketch the proof of Theorem 7.

We start with proving that classical examples do not help to solve the problem even in the uniform case. Interestingly, the following result does not appear explicitly in prior publications, however, it is tacitly assumed in a number of papers. We add a simple proof of this lemma for completeness.

Lemma 8**.**

In the uniform model, $\Omega(2^{k/2})$ classical examples are required to distinguish whether a given Boolean function $f\colon\{0,1\}^{n}\to\{0,1\}$ is a $k$-junta or is $\Omega(1)$-far from any $(n-1)$-junta.

Proof.

Consider the following two probability distributions on Boolean functions $f\colon\{0,1\}^{n}\to\{0,1\}$. $\mathcal{H}$ is the uniform probability distribution on the functions $h(x_{1},\dots,x_{n})$ that only depend on the variables $x_{1},\dots,x_{k}$. $\mathcal{G}$ is the uniform probability distribution on all Boolean functions $f$. Each function in the support of $\mathcal{H}$ is a $k$-junta, while a function $g\sim\mathcal{G}$ is $\Omega(1)$-far from any $(n-1)$-junta with high probability [7, Lemma 3.1]. Hence, the tester should be able to distinguish these two probability distribution with bounded error.

Let $x^{(1)},\dots,x^{(t)}$ be the examples obtained by the tester. If $t=o(2^{k/2})$, then, with high probability, every two inputs in this sequence disagree on their first $k$ bits. But if this is the case, then the values $f(x_{1}),\dots,f(x_{t})$ form a uniformly random string in $\{0,1\}^{t}$ regardless whether $f$ is sampled from $\mathcal{H}$ or from $\mathcal{G}$. Hence, the tester cannot distinguish these two probability distributions with bounded error. ∎

Let $\mathcal{H}$ denote the set of functions that only depend on $x_{1},\dots,x_{k}$ and $\mathcal{G}$ denote the set of functions that are $\Omega(1)$-far from any $(n-1)$-junta. Lemma 8 shows that exponentially many classical examples are needed to distinguish these two classes. However, due to the algorithm by Atıcı and Servedio, it is possible to efficiently distinguish them using quantum examples. We proceed by modifying the classes $\mathcal{H}$ and $\mathcal{G}$ twice. First, we make the uniform quantum example oracle useless, and then the quantum example oracle with respect to $\mathcal{D}$.

We start with uniform quantum examples. The idea is to restrict the probability distribution $\mathcal{D}$ to a small subcube so that uniform examples do not give much information on the inputs in $\mathcal{D}$. Let $x_{[k]}$ denote the substring $(x_{1},\dots,x_{k})\in\{0,1\}^{k}$ of $x$. Define $\mathcal{H}^{\prime}$ and $\mathcal{G}^{\prime}$ as classes of Boolean functions $f^{\prime}\colon\{0,1\}^{n+k}\to\{0,1\}$ on the variables $(x,y)=(x_{1},\dots,x_{n},y_{1},\dots,y_{k})$ defined in the following way. If $f$ comes from $\mathcal{H}$ (respectively, $\mathcal{G}$), then the corresponding function $f^{\prime}$ in $\mathcal{H}^{\prime}$ (respectively, $\mathcal{G}^{\prime}$) is defined by

[TABLE]

Let $\mathcal{D}^{\prime}$ be the uniform probability distribution on the strings $(x,y)\in\{0,1\}^{n+k}$ satisfying $y=x_{[k]}$. Any function in $\mathcal{H}^{\prime}$ is a $2k$-junta, and any function from $\mathcal{G}^{\prime}$ is $\Omega(1)$-far from any $(n-1)$-junta with respect to $\mathcal{D}^{\prime}$, and, hence, $\Omega(1)$-far from any $2k$-junta if $n>2k$.

Uniform quantum examples are useless here. Indeed, the uniform quantum example is $2^{-\Omega(k)}$-close to the quantum example corresponding to the all-0 function:

[TABLE]

Hence, we can replace the uniform quantum example oracle corresponding to a function $f^{\prime}$ in $\mathcal{H}^{\prime}\cup\mathcal{G}^{\prime}$ with (5) and it will not significantly affect the output of the algorithm unless it makes $2^{\Omega(k)}$ samples.

Our next goal is to get rid of the quantum example oracle relative to $\mathcal{D}$. The idea is to scatter the distribution $\mathcal{D}$ so that it is impossible to make use of interference, and the quantum example oracle becomes essentially equivalent to the classical example oracle. Let $\mathcal{H}^{\prime\prime}$ and $\mathcal{G}^{\prime\prime}$ be classes of Boolean functions $f^{\prime\prime}\colon\{0,1\}^{2n+k}\to\{0,1\}$ obtained from $\mathcal{H}^{\prime}$ and $\mathcal{G}^{\prime}$, respectively, by extending them with $n$ irrelevant variables $z_{1},\dots,z_{n}$. For $\pi\colon\{0,1\}^{n}\to\{0,1\}^{n}$ a permutation, we define a distribution $\mathcal{D}^{\prime\prime}_{\pi}$ as follows. The distribution $\mathcal{D}^{\prime\prime}_{\pi}$ is over strings $(x,y,z)$, where $x$ is a uniformly random string from $\{0,1\}^{n}$, $y=x_{[k]}$ and $z=\pi(x)$. Clearly, all the functions in $\mathcal{H}^{\prime\prime}$ are $(2k)$-juntas and the functions in $\mathcal{H}^{\prime\prime}$ are $\Omega(1)$-far from any $(n-1)$-junta with respect to $\mathcal{D}^{\prime\prime}_{\pi}$. The uniform quantum samples are still not useful by the same argument as above.

Let us now prove that quantum samples from $\mathcal{D}^{\prime\prime}_{\pi}$ are also useless in this situation. Consider the quantum sampler from $\mathcal{D}^{\prime\prime}_{\pi}$. It acts as follows

[TABLE]

where $f$ is from $\mathcal{H}$ or $\mathcal{G}$. But note that this state can be obtained in one query to the quantum oracle

[TABLE]

where we denoted $z=\pi(x)$ and permuted the registers. Hence, the complexity of the tester using the oracle in (6) is at least the complexity of the tester using the oracle in (7), which is the standard quantum oracle corresponding to a function

[TABLE]

Note that the problem of testing juntas using the oracle from (7) is symmetric with respect to the permutations of $z$ because the permutation $\pi$ can be arbitrary. By [6], a quantum algorithm for a symmetric function can obtain at most a cubic improvement compared to a randomised algorithm with access to the oracle. However, for a random $\pi$, access to this oracle is equivalent to uniform classical examples of the function $f$. Hence, the algorithm requires $2^{\Omega(k)}$ samples by Lemma 8.

5 Discussion

We have constructed a quantum algorithm with complexity $O(k/\varepsilon)$, which gives a quadratic improvement in terms of $k$ when compared to [10]. In the algorithm, we assume we only have classical access to $\mathcal{D}$. It is also possible to have a quantum sampler from $\mathcal{D}$, that is, an oracle of the form

[TABLE]

where $\mathcal{D}_{x}$ is the probability of $x$ in $\mathcal{D}$, and $\psi_{x}$ are some arbitrary unknown normalized quantum states. (Note that because of the unknown $\psi_{x}$, this is a weaker model of access than the quantum samplers we defined in Section 2.) In this case, it is possible to apply quantum amplitude amplification to the GenerateCube subroutine. The complexity of the subroutine becomes $O(1/\sqrt{\varepsilon})$, and the complexity of the whole algorithm becomes $O(k/\sqrt{\varepsilon})$.

So far, it is unclear whether the complexity of our quantum algorithm. In principle, it is not excluded that there exists a quantum algorithm with complexity $\widetilde{O}(\sqrt{k/\varepsilon})$.

Acknowledgements

I am thankful to Srinivasan Arunachalam and Ronald de Wolf for helpful discussions about this problem.

This research is partly supported by the ERDF grant number 1.1.1.2/VIAA/1/16/113.