Exact Learning of Juntas from Membership Queries

TL;DR

This paper advances the understanding of learning Juntas exactly through membership queries by establishing new bounds and algorithms, narrowing the gap between theoretical limits and practical methods.

Contribution

It introduces novel techniques for bounding and algorithms, improving the efficiency of exact learning of Juntas from membership queries.

Findings

New bounds for adaptive and non-adaptive learning of Juntas.

Deterministic and randomized algorithms with reduced query and time complexities.

Some bounds are tight, indicating fundamental limits or requiring breakthrough techniques.

Abstract

In this paper, we study adaptive and non-adaptive exact learning of Juntas from membership queries. We use new techniques to find new bounds, narrow some of the gaps between the lower bounds and upper bounds and find new deterministic and randomized algorithms with small query and time complexities. Some of the bounds are tight in the sense that finding better ones either gives a breakthrough result in some long-standing combinatorial open problem or needs a new technique that is beyond the existing ones.

Tables

Table 1. Table 1: Results for Non-adaptive Learning

	Lower Bound	Upper Bound	Time $n^{O\left(d\right)}$	Time $poly(d^d,n)$	Time $poly(2^d,n)$
Deterministic
Previous	${}_{}{}^{\text{(1) }}2_{}^d\log n$	${}_{}{}^{\text{(3) }}d{2}^d\log n$         $+d^2{2}^d$	${}_{}{}^{\text{(6) }}d_{}^2{2}^d\log n$	—	${}_{}{}^{\text{(11) }}2_{}^{d+O\left({\log }^{2}d\right)}\cdot$              ${\log }^{2}n$
Ours	—	${}_{}{}^{\text{(4) }}d{2}^d\log n$	${}_{}{}^{\text{(7) }}d{2}^d\log n$	${}_{}{}^{\text{(9) }}d_{}^3{2}^d\log n$	${}_{}{}^{\text{(12) }}2_{}^{d+O\left({\log }^{2}d\right)}\cdot$              $\log n$
Randomized
Previous	—	—	—	—	—
Ours	${}_{}{}^{\text{(2) }}2_{}^d\log n$	${}_{}{}^{\text{(5) }}d{2}^d\log n$	${}_{}{}^{\text{(8) }}d{2}^d\log n$	${}_{}{}^{\text{(10) }}d_{}^3{2}^d\log n$	${}_{}{}^{\text{(13) }}\left(\log d\right)d^2{2}^d\cdot$       $\left(\log n+\log \frac{1}{\delta }\right)$

Table 2. Table 2: Results for Adaptive Learning

	Lower Bound	Upper Bound	Time $n^{O\left(d\right)}$	Time $poly(d^d,n)$	Time $poly(2^d,n)$
Deterministic
Previous	${}_{}{}^{\text{(1) }}2_{}^d\log n$	$\underset{¯}{r=O\left(d\log n\right)}$ ${}_{}{}^{\text{(3) }}d{2}^d\log n$	$\underset{¯}{r=O\left(d\log n\right)}$ ${}_{}{}^{\text{(5) }}d{2}^d\log n$	$\underset{¯}{r=2}$ ${}_{}{}^{\text{(7) }}\left(\log d\right)d^3\cdot$        $2^d\log n$	$\underset{¯}{r=O\left(d\log n\right)}$ ${}_{}{}^{\text{(11) }}2_{}^{d+O\left({\log }^{2}d\right)}\cdot$               $\log n$
Ours	—	—	—	$\underset{¯}{r=2}$ ${}_{}{}^{\text{(8) }}d_{}^3{2}^d\log n$	—
Randomized
Previous	—	—	—	$\underset{¯}{r=2}$ ${}_{}{}^{\text{(9) }}d\log n+$        $d^2{2}^d\log \frac{1}{\delta }$	—
Ours	${}_{}{}^{\text{(2) }}d\log n+$            $2^d$	$\underset{¯}{r=O\left(d\log d\right)}$ ${}_{}{}^{\text{(4) }}d\log n+$        $2^d\log \frac{1}{\delta }$	$\underset{¯}{r=O\left(d\log d\right)}$ ${}_{}{}^{\text{(6) }}d\log n+$        $2^d\log \frac{1}{\delta }$	$\underset{¯}{r=2}$ ${}_{}{}^{\text{(10) }}d\log n+$        $d{2}^d\log \frac{1}{\delta }$	$\underset{¯}{r=O\left(d\log d\right)}$ ${}_{}{}^{\text{(12) }}d\log n+$         $2^d\log \frac{1}{\delta }$ $\underset{¯}{r=2}$ ${}_{}{}^{\text{(13) }}d\log n+$         $d^2{2}^d\log \frac{1}{\delta }$

Equations

$$U(n,d)=\Omega (2^d\log n),U(n,d)=O(d{2}^d\log n).$$

$$\displaystyle\Pr[S\mbox{\ is not $(n,d)$-US}]$$

$$O\left(\frac{d^2\log n}{\log (q/d^2)}\right)$$

$$X(\varnothing )=\sum _{d_1+d_2=d}\left(\genfrac{}{}{0ex}{}{n}{d_2{d}_2{d}_{1}n-d_1-2d_2}\right)2^{d_1}(2^{d_2+1}-1)\le (2n{)}^{2d}.$$

$$X(A\cup \{a\})\le X(A)\left(1-\frac{1}{2^{d+1}}\right).$$

$$X(A^{\prime })\le X(\varnothing ){\left(1-\frac{1}{2^{d+1}}\right)}^t\le (2n{)}^{2d}{\left(1-\frac{1}{2^{d+1}}\right)}^t<(2n{)}^{2d}{e}^{-2d\ln (2n)}=1.$$

$$\frac{1}{2^{d_1}}\frac{{\sum }_{i\ne j}{s}_i{r}_j}{2^{2d_2}}$$

$$\ge$$

$${\mathbf{E}}_a[X_{i,j,k,z}(A\cup \{a\})]\le (t-1)-\frac{t-1}{2^{d+1}}=X_{i,j,k,z}(A)\left(1-\frac{1}{2^{d+1}}\right).$$

$${\mathbf{E}}_a[X(A\cup \{a\})]\le X(A)\left(1-\frac{1}{2^{d+1}}\right).$$

$$\underset{r_i,s_i}{\max }\sum _{i=1}^t{s}_i{r}_i\le 2^{2d_2}-(t-1)2^{d_2-1}.$$

$$\underset{r_i,s_i}{\max }\sum _{i=1}^t{s}_i{r}_i$$

$$M_{i_1,\dots ,i_d}=\{(a_{i_1},\dots ,a_{i_d},f(a))|a\in A\}.$$

$$O\left(q{d}^{2}n\log n+\frac{d^2\log n}{\log (q/(d+1{)}^2)}(T(q)+Q(q)n)\right)$$

$$O\left(\frac{d^{2}Q(q)}{\log (q/(d+1{)}^2)}\log n\right)$$

$$O(2d(d+1{)}^2{d}^{2}n\log n+(d^2\log n/\log d)\cdot ((2d(d+1{)}^2{)}^{O(d)}+d{2}^d\log (2d(d+1{)}^2)n))$$

$$O(d^{2}d{2}^d\log (2d(d+1{)}^2)\log n/\log d)=O(d^3{2}^d\log n).$$

$$f(a{|}_{x_{i_j}\leftarrow {\bar{a}}_{i_j}})=g(b{|}_{x_{i_j}\leftarrow {\bar{b}}_{i_j}})\ne g(b)=f(a).$$

$$F=\{f_{\xi ,i}:=x_1^{{\xi }_1}\cdots x_{d-1}^{{\xi }_{d-1}}{x}_i|{\xi }_1,\dots ,{\xi }_{d-1}\in \{0,1\},n\ge i\ge d\}$$

$$\underset{s}{\max }{\mathbf{E}}_{U_F}[X(s,f)]\ge {\mathbf{E}}_s\left[{\mathbf{E}}_{U_F}[X(s,f)]\right]={\mathbf{E}}_{U_F}\left[{\mathbf{E}}_s[X(s,f)]\right]\ge \frac{1}{2}.$$

$$A_{s^{\prime }}(\xi )=\{a\in A_{s^{\prime }}|(a_1,\dots ,a_{d-1})=\xi \}\subseteq A_{s^{\prime }}.$$

$$m_{s^{\prime }}=|A_{s^{\prime }}|=\sum _{\xi \in \{0,1{\}}^{d-1}}|A_{s^{\prime }}(\xi )|\ge \left(\frac{1}{4}{2}^{d-1}\right)(\log (n-d+1)-3)=\Omega (2^d\log n).$$

$$\underset{b}{\mathrm{Pr}}[f(a+b)=f(a)\text{mbox}and{b}_i=1]\ge \frac{0.2}{d}$$

$$\underset{b}{\mathrm{Pr}}[f(a+b)=f(a)\text{mbox}and{b}_j=1]\le \frac{0.1}{d}.$$

$${\left(1-\frac{1}{3d}\right)}^d\frac{1}{3d}\ge \frac{0.2}{d}.$$

$$\underset{b}{\mathrm{Pr}}[f(a+b)=f(a)\text{mbox}and{b}_j=1]$$

$$O$$

$$=$$

$$O((\log d)d{2}^d\log n+(\log d)d^2{2}^d).$$

$$O((d{2}^d\log n+d^2{2}^d)\log (1/\delta )).$$

$$O((\log d)d^2{2}^d(\log n+\log (1/\delta ))).$$

Full text

Some of the bounds are tight in the sense that finding better ones either gives a breakthrough result in some long-standing combinatorial open problem or needs a new technique that is beyond the existing ones.

1 Introduction

Learning from membership queries, [1], has flourished due to its many applications in group testing, blood testing, chemical leak testing, chemical reactions, electric shorting detection, codes, multi-access channel communications, molecular biology, VLSI testing and AIDS screening. See many other applications in [2, 3, 4, 5, 6, 7]. Many of the new applications raised new models and new problems and in many of those applications the function being learned can be an arbitrary function that depends on few variables. We call this class of functions $d$-Junta, where $d$ is a bound on the number of relevant variables in the function. In some of the applications non-adaptive algorithms are most desirable, where in others adaptive algorithms with limited number of rounds are also useful. Algorithms with high number of rounds can also be useful given that the number of queries they ask is low. In all of the applications, one searches for an algorithm that runs in polynomial time and asks as few queries as possible. In some applications asking queries is very expensive, and therefore, even improving the query complexity by a small non-constant factor is interesting.

In this paper we study adaptive and non-adaptive exact learning of Juntas from membership queries. This problem was studied in [8, 9, 10, 4]. In this paper, we find new bounds, tighten some of the gaps between some lower bounds and upper bounds111The term upper bound refers to learning with unlimited computational power. and find new algorithms with better query and time complexities both for the deterministic and the randomized case.

Since learning one term of size $d$ (which is a function in $d$-Junta) requires at least $2^{d}$ queries and asking one query requires time $O(n)$, we cannot expect to learn the class $d$-Junta in time less than $\Omega(2^{d}+n).$ We say that the class $d$-Junta is polynomial time learnable if there is an algorithm that learns $d$-Junta in time $poly(2^{d},n)$. In this paper we also consider algorithms that run in time $n^{O(d)}$, which is polynomial time for constant $d$, and algorithms that run in time $poly(d^{d},n)$, which is polynomial time for $d=O(\log n/\log\log n)$.

1.1 Results for Non-adaptive Learning

A set $S\subseteq\{0,1\}^{n}$ is called an $(n,d)$-universal set if for every $1\leq i_{1}<i_{2}<\cdots<i_{d}\leq n$ and $\sigma\in\{0,1\}^{d}$ there is an $s\in S$ such that $s_{i_{j}}=\sigma_{j}$ for all $j=1,\ldots,d$. Damaschke, [8], shows that any set of assignments that learns $d$-Junta must be an $(n,d)$-universal set. This, along with the lower bound in [11, 12], gives result (1) in Table 1 for the deterministic case. It is not clear that this lower bound is also true for the randomized case. We use the minimax technique, [13], to show that randomization cannot help reducing the lower bound. See (2) in the table.

Damaschke introduces a graph-theoretic characterization of non-adaptive learning families, called $d$-wise bipartite connected families, [8]. He shows that for an $(n,d)$-universal set of assignments $S$, it can non-adaptively learn $d$-Junta if and only if $S$ is a $d$-wise bipartite connected family. He then shows, with a non-constructive probabilistic method, that there exists such a family of size $O(d2^{d}\log n+d^{2}2^{d})$. See (3) in the table. Then, he shows that a $d$-wise bipartite connected family of size $O(d^{2}2^{d}\log n)$ can be constructed in $n^{O(d)}$ time, [8]. This, along with his deterministic learning algorithm presented in [8] gives result (6) in the table. We further investigate the $d$-wise bipartite connected families and show that there exists one of size $O(d2^{d}\log n)$. We then use the technique in [14] to construct one of such size in time $n^{O(d)}$. This gives results (4), (5), (7) and (8), where the results for the randomized algorithms follow from the corresponding deterministic algorithms. We then use the reduction of Abasi et. al in [15] to give a non-adaptive algorithm that runs in $poly(d^{d},n)$ time and asks $O(d^{3}2^{d}\log n)$ queries. This is result (9) in the table. Then, result (10) for the randomized case follows.

We also introduce a new simple non-adaptive learning algorithm and apply the same reduction to this algorithm to get result (12) in the table. This reduces the quadratic factor of $\log^{2}{n}$ in the query complexity of result (11) to a linear factor of $\log{n}$. Result (11) follows from a polynomial time learning algorithm for $d$-Junta given by Damaschke in [9], which asks $2^{d+O(\log^{2}d)}\log^{2}n$ queries. Finally, we give a new Monte Carlo randomized polynomial time algorithm that learns $d$-Junta with $O(d2^{d}(\log d+\log(1/\delta))\log n+d2^{d}(d+\log(1/\delta))(\log d+\log(1/\delta)))$ queries. Then we present a new reduction for randomized non-adaptive algorithms and apply it to this algorithm to get result (13) in the table. In addition, for $\delta\leq 1/d$, we give a Monte Carlo randomized polynomial time algorithm that asks $O((d2^{d}\log n+d^{2}2^{d})\log(1/\delta))$ queries. This algorithm is based on the previous one before the reduction. For values of $\delta$ small enough, the result in (13) is better.

The significant improvements over the previous results (see the table) are results (2), (4), (9), (12) and (13).

1.2 Results for Adaptive Learning

As stated above, Damaschke shows in [8] that any deterministic learning algorithm for $d$-Junta must ask a set of queries that is an $(n,d)$-universal set. This applies both for non-adaptive and adaptive learning. Therefore, applying the lower bound from [11, 12] gives result (1) in Table 2. A lower bound for the randomized case follows from a general lower bound presented in [16]. See result (2). Damaschke, [8], shows that functions from $d$-Junta can be adaptively learned by asking a set of queries that is an $(n,d)$-universal set followed by $O(d\log{n})$ queries. This, along with the upper bound from the probabilistic method on the size of $(n,d)$-universal sets gives result (3) in the table. Furthermore, Damaschke’s algorithm runs in time $T+poly(2^{d},n)$, where $T$ is the construction time of the ${(n,d)}$-universal set. An ${(n,d)}$-universal set of size ${O(d2^{d}\log{n})}$ can be constructed deterministically by the derandomization method in $n^{O(d)}$ time as stated in [14]. This gives us an algorithm for adaptive learning that runs in ${n^{O(d)}}$ time and asks $O(d2^{d}\log{n})$ queries. See result (5). The polynomial time construction of an ${(n,d)}$-universal set in [14] gives result (11) in the table.

Let $H$ be a family of functions ${h:[n]\rightarrow[q]}$, and let be ${d\leq q}$. We say that $H$ is an $(n,q,d)$-perfect hash family ($(n,q,d)$-PHF) if for every subset ${S\subseteq[n]}$ of size ${|S|=d}$ there is a hash function ${h\in H}$ such that ${|h(S)|=d}$. In [9] Damaschke gives a two round algorithm that learns $d$-Junta in ${poly(d^{d},n)}$ time using an $(n,d^{2},d)$-PHF. This is result (7) in the table. We improve this algorithm by using another construction of PHF based on a lemma from [17]. We can further improve the query complexity of this algorithm and get result (8) in the table based on a non-adaptive algorithm of ours. A two round Monte Carlo randomized algorithm that runs in ${poly(d^{d},n)}$ time is introduced in [9, 10]. If we modify its analysis slightly to make it applicable for a general failure probability $\delta$, we get the result in (9). In the paper we show how we can improve this query complexity and get result (10) in the table.

Results (4), (6) and (12) in the table are based on a new Monte Carlo randomized algorithm that we present in the paper. Result (13) follows also from a new Monte Carlo randomized algorithms that we introduce in this paper.

We note here that the results in (4), (6), (10), (12) and (13) are for values of the failure probability $\delta$ that are at most $1/d$. For $\delta>1/d$, these three algorithms run in different query complexities as stated in Theorems 11, 12 and 13 in this paper. We present here the results only for $\delta\leq 1/d$ because we are generally interested in values of $\delta$ that are small.

To conclude, our new results for adaptive learning are the results in (2), (8), (10), (12) and (13). We note also that for the deterministic case, our non-adaptive results are as good as the adaptive ones presented here. Therefore, the deterministic adaptive algorithms don’t offer us better results compared with the results of the deterministic non-adaptive algorithms. We still present these algorithms because they are useful for analyzing the randomized adaptive algorithms.

2 Definitions and Preliminary Results

In this section we give some definitions and preliminary results that will be used throughout the paper.

Let $n$ be an integer. We denote $[n]=\{1,\ldots,n\}$. Consider the set of assignments, also called membership queries or queries, $\{0,1\}^{n}$. A function $f$ is said to be a boolean function on $n$ variables $x=(x_{1},\ldots,x_{n})$ if $f:\{0,1\}^{n}\to\{0,1\}$. For an assignment $a\in\{0,1\}^{n}$, $i\in[n]$ and $\xi\in\{0,1\}$ we denote by $a|_{x_{i}\leftarrow\xi}$ the assignment $(a_{1},\ldots,a_{i-1},$ $\xi,a_{i+1},\ldots,a_{n})$. We say that the variable $x_{i}$ is relevant in $f$ if there is an assignment $a=(a_{1},\ldots,a_{n})$ such that $f(a|_{x_{i}\leftarrow 0})\not=f(a|_{x_{i}\leftarrow 1})$. We say that the variable $x_{i}$ is irrelevant in $f$ if it is not relevant in $f$.

Given a boolean function $f$ on $n$ variables $x=\{x_{1},\ldots,x_{n}\}$ and an assignment ${a\in\{0,1\}^{n}}$ on the variables, we say that ${x_{i}}$, for $1\leq i\leq n$, is sensitive in $f$ w.r.t. $a$ if $f({a|_{{x_{i}}\leftarrow 0}})\neq$ $f({a|_{{x_{i}}\leftarrow 1}})$.

For a boolean function on $n$ variables $f$, a variable $x_{i}$ and a value $\xi\in\{0,1\}$ we denote by $f|_{x_{i}\leftarrow\xi}$ the boolean function on $n$ variables $g(x_{1},\ldots,x_{n})=f(x_{1},\ldots,x_{i-1},\xi,x_{i+1},$ $\ldots,x_{n})$. In addition, for a boolean variable $x\in\{0,1\}$ we denote $x^{1}:=x$ and $x^{0}:=\bar{x}$, where $\bar{x}$ is the negation of $x$.

For a class of boolean functions $C$ we say that a set of assignments $A\subseteq\{0,1\}^{n}$ is an equivalent set for $C$ if for every two distinct functions $f,g\in C$ there is an $a\in A$ such that $f(a)\neq g(a)$. Obviously, an equivalent set $A$ for $C$ can be used to non-adaptively learn $C$. Just ask all the the queries in $A$ and find the function $f\in C$ that is consistent with all the answers. By the definition of equivalent set this function is unique.

For integers $n$ and $d\leq n$ we define the set $d$-Junta as the set of all functions $f:\{0,1\}^{n}\to\{0,1\}$ with at most $d$ relevant variables.

A set $S\subseteq\{0,1\}^{n}$ is called a $d$-wise independent set if for every $1\leq i_{1}<i_{2}<\cdots<i_{d}\leq n$ and every $\xi_{1},\ldots,\xi_{d}\in\{0,1\}$, for a random uniform $x=(x_{1},\ldots,x_{n})\in S$ we have $\Pr[x_{i_{1}}=\xi_{1},\ldots,x_{i_{d}}=\xi_{d}]=1/2^{d}.$ Alon et. al. show

Lemma 1**.**

[18]** There is a construction of a $d$-wise independent set of size $O((2n)^{\lfloor d/2\rfloor})$ that runs in $n^{O(d)}$ time.

2.1 Universal Sets, $d$-wise Bipartite Connected Families and Perfect Hash Families

A set $S\subseteq\{0,1\}^{n}$ is called an $(n,d)$-universal set if for every $1\leq i_{1}<i_{2}<\cdots<i_{d}\leq n$ and $\sigma\in\{0,1\}^{d}$ there is an $s\in S$ such that $s_{i_{j}}=\sigma_{j}$ for all $j=1,\ldots,d$. Denote by $U(n,d)$ the minimum size of an $(n,d)$-universal set. It is known, [12, 11], that

[TABLE]

The following result is a folklore result. We give the proof for completeness.

Lemma 2**.**

Let be $m=O(2^{d}(d\log n+\log(1/\delta)))$. Let be $S=\{s^{(1)},\ldots,s^{(m)}\}$ where each $s^{(i)}$ is uniformly independently chosen from $\{0,1\}^{n}$. With probability at least $1-\delta$ the set $S$ is an $(n,d)$-universal set.

Proof.

By the union bound and since $s^{(i)}$ are chosen uniformly independently,

[TABLE]

∎

This also implies the upper bound of $O(d2^{d}\log n)$ in (1). Different deterministic constructions for $(n,d)$-universal sets are useful, especially for adaptive learning. The best known constructions are stated in the following.

Lemma 3**.**

[14, 17]** There is a deterministic construction for an $(n,d)$-universal set of size $s$ that runs in time $T$ where

$T=poly(2^{d},n)$* and $s=2^{d+O(\log^{2}d)}\log n$.* 2. 2.

$T=poly(d^{d},n)$* and $s=O(d^{3}2^{d}\log n)$. In particular, $T=poly(n)$ for $d=O(\log n/$ $\log\log n)$.* 3. 3.

$T=n^{O(d)}$* and $s=O(d2^{d}\log n)$. In particular, $T=poly(n)$ for $d=O(1)$.*

Let $A\subseteq\{0,1\}^{n}$ be a set of assignments. For non-negative integers $d_{1}$, $d_{2}$ such that $d=d_{1}+d_{2}$ and for $i=(i_{1},\ldots,i_{d_{2}}),j=(j_{1},\ldots,j_{d_{1}}),k=(k_{1},\ldots,k_{d_{2}})$, with entries that are distinct elements in $[n]$ and $z\in\{0,1\}^{d_{1}}$, we define a bipartite graph $B:=B(i,j,k,z,A)$ as follows. The set of vertices of the left side of the graph is $V_{L}(B):=\{0,1\}^{d_{2}}\times\{L\}$ and the set of vertices of the right side of the graph is $V_{R}(B):=\{0,1\}^{d_{2}}\times\{R\}$. For $a^{\prime},a^{\prime\prime}\in\{0,1\}^{d_{2}}$, $\{(a^{\prime},L),(a^{\prime\prime},R)\}$ is an edge in $B$ if and only if there is an assignment $a\in A$ such that $(a_{i_{1}},\ldots,a_{i_{d_{2}}})=a^{\prime}$, $(a_{k_{1}},\ldots,a_{k_{d_{2}}})=a^{\prime\prime}$ and $(a_{j_{1}},\ldots,a_{j_{d_{1}}})=z$.

We say that $A$ is a $d$-wise bipartite connected family if for all $d_{1}$, $d_{2}$ such that $d=d_{1}+d_{2}$, and for all $i=(i_{1},\ldots,i_{d_{2}})$, $j=(j_{1},\ldots,j_{d_{1}})$, $k=(k_{1},\ldots,k_{d_{2}})$ and $z\in\{0,1\}^{d_{1}}$ as described above, the graph $B(i,j,k,z,A)$ is connected. That is, there is a path from any vertex in the graph to any other vertex. Obviously, any $d$-wise bipartite connected family is an $(n,d)$-universal set. Just take $d_{1}=0$ and $d_{2}=d$.

In [8], Damaschke proves

Lemma 4**.**

[8]** A set $A$ is an equivalent set for $d$-Junta if and only if $A$ is a $d$-wise bipartite connected family.

Let $H$ be a family of functions ${h:[n]\rightarrow[q]}$, and let be ${d\leq q}$. We say that $H$ is an $(n,q,d)$-perfect hash family ($(n,q,d)$-PHF) if for every subset ${S\subseteq[n]}$ of size ${|S|=d}$ there is a hash function ${h\in H}$ such that ${|h(S)|=d}$.

In [17] Bshouty shows

Lemma 5**.**

[17*]**

Let $q\geq 2d^{2}$. There is an $(n,q,d)$-PHF of size*

[TABLE]

that can be constructed in time $O(qd^{2}n\log{n}/\log{(q/{d^{2}})})$.

In particular, from Lemma 5, for $q=d^{2}$ and $q=d^{3}$ we have

Corollary 1**.**

There is a construction of an $(n,d^{2},d)$-PHF of size $O(d^{2}\log{n})$ that runs in $poly(n)$ time. 2. 2.

There is a construction of an $(n,d^{3},d)$-PHF of size $O(d^{2}\log{n}/\log{d})$ that runs in $poly(n)$ time.

3 Deterministic Non-adaptive Algorithms

In this section we study deterministic non-adaptive learning of $d$-Junta.

3.1 Lower and Upper Bound

For completeness sake, we give a sketch of the proof of the lower bound of $\Omega(2^{d}\log n)$ on the number of queries in any deterministic adaptive algorithm. This implies the same lower bound for any deterministic non-adaptive algorithm.

The idea of the lower bound is very simple. If the set of asked assignments $A$ is not an $(n,d)$-universal set and the adversary answers [math] for all the membership queries in $A$, the learner can’t learn the function. This is because, if $A$ is not an $(n,d)$-universal set, then there are $1\leq i_{1}<i_{2}<\cdots<i_{d}\leq n$ and $\xi_{1},\ldots,\xi_{d}$ such that no assignment $a\in A$ satisfies $(a_{i_{1}},\ldots,a_{i_{d}})=(\xi_{1},\ldots,\xi_{d})$. Then, the learner can’t distinguish between the zero function and the term $x_{i_{1}}^{\xi_{1}}\cdots x_{i_{d}}^{\xi_{d}}$. This is because $x_{i_{1}}^{\xi_{1}}\cdots x_{i_{d}}^{\xi_{d}}$ is also zero on all the assignments of $A$. Therefore, the learner must ask at least $U(n,d)$ queries which is $\Omega(2^{d}\log n)$ by (1).

As for the upper bound, Damaschke shows in [8] that a $d$-wise bipartite connected family is an equivalent set for $d$-Junta and therefore this family is enough for non-adaptive learning. He then shows that there exists a $d$-wise bipartite connected family of size ${O(d2^{d}\log{n}+d^{2}2^{d})}$. In this section we construct such one of size $O(d2^{d}\log n)$. In particular, we have

Theorem 1**.**

There is a deterministic non-adaptive algorithm that learns $d$-Junta with $O(d2^{d}\log n)$ queries.

Proof.

We give an algorithmic construction of a $d$-wise bipartite connected family of size $O(d2^{d}\log n)$. To prove the result we start with a definition.

For every $d_{1}$ and $d_{2}$ where $d=d_{1}+d_{2}$ and every $i=(i_{1},\ldots,i_{d_{2}})$, $j=(j_{1},\ldots,j_{d_{1}})$, $k=(k_{1},\ldots,k_{d_{2}})$, with entries that are distinct elements in $[n]$, every $z\in\{0,1\}^{d_{1}}$ and every set of assignments $A\subseteq\{0,1\}^{n}$, we define the function $X_{i,j,k,z}$ at $A$ as follows. $X_{i,j,k,z}(A)=t-1$ where $t$ is the number of connected components in $B(i,j,k,z,A)$. Obviously, if $X_{i,j,k,z}(A)=0$ then $B(i,j,k,z,A)$ is connected. Consider the function $X(A)=\sum_{i,j,k,z}X_{i,j,k,z}(A).$ The sum here is over all possible $d_{1}$, $d_{2}$, $i,j,k$ and $z$ as described above. Notice that if $X(A)=0$ then $A$ is a $d$-wise bipartite connected family.

We construct $A$ iteratively. At the beginning $A=\varnothing$ and each $B(i,j,k,z,A)$ has $2^{d_{2}+1}$ connected components. Therefore, we first have

[TABLE]

We show that for every $A\subset\{0,1\}^{n}$ there is an assignment $a\in\{0,1\}^{n}$ such that

[TABLE]

This implies that there is a set $A^{\prime}$ of size $t=2d2^{d+1}\ln(2n)$ such that

[TABLE]

Since $X(A^{\prime})$ is an integer number we get $X(A^{\prime})=0$, which implies that $A^{\prime}$ is a $d$-wise bipartite connected family of size $t=O(d2^{d}\log n)$.

We now prove (2). Consider some $i,j,k,z,A$. Suppose that the number of connected components in $B:=B(i,j,k,z,A)$ is $t$ and therefore $X_{i,j,k,z}(A)=t-1$. Let $C_{1},C_{2},\ldots,C_{t}$ be the connected components of $B$ and let $s_{i}$ and $r_{i}$ be the number of vertices of the component $C_{i}$ in $V_{L}(B)$ and $V_{R}(B)$ respectively. Consider a random uniform assignment $a\in\{0,1\}^{n}$. If $(a_{j_{1}},\ldots,a_{j_{d_{1}}})=z$ then $B(i,j,k,z,A\cup\{a\})$ is the bipartite graph $B(i,j,k,z,A)$ with an addition of a uniform random edge. Therefore the probability that after adding $a$ to $A$ the number of connected components in $B$ reduces by $1$ is equal to the probability that $(a_{j_{1}},\ldots,a_{j_{d_{1}}})=z$ and a uniform random edge in $B$ connects two distinct connected components. This probability is equal to

[TABLE]

Equality (3) is true because $\sum_{i}s_{i}=\sum_{i}r_{i}=2^{d_{2}}$. The inequality (4) is proved later.

Therefore

[TABLE]

Since the expectation of a sum is the sum of the expectations, we have

[TABLE]

Therefore, for every set $A$ there exists an $a$ such that $X(A\cup\{a\})\leq X(A)\left(1-1/2^{d+1}\right).$

It remains to prove (4). That is,

[TABLE]

First notice that since the graph $B$ is a bipartite graph we have that $s_{i}r_{i}=0$ if and only if either $s_{i}=0$ and $r_{i}=1$ or $s_{i}=1$ and $r_{i}=0$. We first claim that the maximum value in (5) occurs when $r_{i}s_{i}=0$ for all $i$ except for one. If, on the contrary, the maximum value occurs where $s_{i_{1}}r_{i_{1}}\not=0$ and $s_{i_{2}}r_{i_{2}}\not=0$ for some $i_{1}\not=i_{2}$ then by replacing $s_{i_{1}},r_{i_{1}}$ by $0,1$ and $s_{i_{2}},r_{i_{2}}$ by $s_{i_{1}}+s_{i_{2}},r_{i_{1}}+r_{i_{2}}-1$ we get a larger or equal value and therefore we get a contradiction. Therefore we may assume w.l.o.g. that $s_{i}r_{i}=0$ for all $i=1,\ldots,t-1$, $r_{t}=2^{d_{2}}-t_{1}$ and $s_{t}=2^{d_{2}}-t_{2}$ for some $t_{1}+t_{2}=t-1$. Then, since $t\leq 2^{d_{2}+1}$,

[TABLE]

∎

3.2 Polynomial Time Algorithms

In this section we give three polynomial time algorithms for non-adaptive learning of $d$-Junta. The first algorithm asks $O(d2^{d}\log n)$ queries and runs in time $n^{O(d)}$ which is polynomial for constant $d$. This improves the query complexity $O(d^{2}2^{d}\log n)$ of Damaschke in [8]. The second algorithm asks $O(d^{3}2^{d}\log n)$ queries and runs in time $poly(d^{d},n)$ which is polynomial for $d=O(\log n/$ $\log\log n)$. The third algorithm asks $2^{d+O(\log^{2}d)}\log n$ queries and runs in polynomial time. This improves the query complexity $2^{d+O(\log^{2}d)}\log^{2}n$ of Damaschke in [8].

We now present the first algorithm. In the next lemma we show how to construct a $d$-wise bipartite connected family of size $O(d2^{d}\log n)$ in time $n^{O(d)}$. We construct a $d$-wise bipartite connected family $A$ and non-adaptively ask all the queries in $A$. Then, for every $d$ variables $x_{i_{1}},\ldots,x_{i_{d}}$ we construct a set

[TABLE]

We now look for a function $g\in d$-Junta that is consistent with all the answers of the queries in $A$. If $M_{i_{1},\ldots,i_{d}}$ contains two elements $(a^{\prime},0)$ and $(a^{\prime},1)$ for some $a^{\prime}\in\{0,1\}^{d}$ then no consistent function exists on those variables. Otherwise, there is a consistent function $g$ and since $A$ is an equivalent set, $g$ is unique and is the target function. After finding the target function, we can then find the set of relevant variables in $g$ from its truth table if needed. This set of relevant variables is a subset of $\{i_{1},\ldots,i_{d}\}$.

This algorithm runs in time $n^{O(d)}$. We now show that the construction time of the $d$-wise bipartite connected family $A$ is $n^{O(d)}$.

In the previous subsection we showed in Theorem 1 an algorithmic construction of a $d$-wise bipartite connected family of size $O(d2^{d}\log{n})$. We now show that this construction can be performed in $n^{O(d)}$ time.

Lemma 6**.**

There is an algorithm that runs in time $n^{O(d)}$ and constructs a $d$-wise bipartite connected family of size $O(d2^{d}\log{n})$.

Proof.

Let $X(A)$ and $X_{i,j,k,z}(A)$ be as in the proof of Theorem 1. $X_{i,j,k,z}(A)$ depends only on $2d_{2}+d_{1}$ entries of the assignments of $A$. Therefore, the proof of Theorem 1 remains true if the new assignment $a$ is chosen from a $(2d_{2}+d_{1})$-wise independent set $S$. By Lemma 1, such set exists and is of size $n^{O(2d_{2}+d_{1})}=n^{O(d)}$.

Since the number of iterations and the number of random variables $X_{i,j,k,z}(A)$ in the algorithm is at most $(2n)^{2d}$ and each $X_{i,j,k,z}(A)$ can be computed in time $poly(2^{d_{2}},|A|)=poly(2^{d}\log n)$, the result follows. ∎

Remark. We note here that instead of using a $(2d_{2}+d_{1})$-wise independent set, one can use a $(1/2^{O(d)})$-almost $(2d_{2}+d_{1})$-wise independent set of size $poly(2^{d},\log n)$, [19]. For $k=2d_{2}+d_{1}$ this is a set of assignments $S\subseteq\{0,1\}^{n}$ such that for every $1\leq i_{1}<i_{2}<\cdots<i_{k}\leq n$ and every $B\subseteq\{0,1\}^{n}$, for a random uniform $x=(x_{1},\ldots,x_{n})\in S$ we have $|B|/2^{k}-1/2^{O(k)}\leq\Pr[(x_{i_{1}},\ldots,x_{i_{k}})\in B]\leq|B|/2^{k}+1/2^{O(k)}.$ The algorithm still needs time $n^{O(d)}$ for computing $X(A)$.

Another approach is the conditional probability method [13]. It follows from the proof of Theorem 1 that for $t=d2^{d+2}\ln(2n)$ i.i.d. random uniform assignments $A=\{a^{(1)},\ldots,a^{(t)}\}$ we have ${\bf E}[X(A)]<1$. We now construct the bits of $a^{(1)},\ldots,a^{(t)}$ one at a time while maintaining the property ${\bf E}[X(A)|$ already fixed bits$]<1$. At the end all the bits are fixed, say $A=A_{0}$, and then $X(A_{0})={\bf E}[X(A)|A_{0}]<1$ which implies (you can see why in the proof of Theorem 1) that $A_{0}$ is a $d$-wise bipartite connected family of size $t=d2^{d+2}\ln(2n)$. In this approach also the algorithm still needs time $n^{O(d)}$ for computing $X(A)$.

Lemma 6 implies

Theorem 2**.**

There is a deterministic non-adaptive algorithm that learns $d$-Junta in time $n^{O(d)}$ with $O(d2^{d}\log n)$ queries.

For introducing the second algorithm, we start with presenting a result from [15]. A class of boolean functions $C$ is said to be closed under variable projection if for every $f\in C$ and every function $\phi:[n]\to[n]$ we have $f(x_{\phi(1)},\ldots,x_{\phi(n)})\in C$. Obviously, $d$-Junta is closed under variable projection.

For the second algorithm we apply the reduction described in [15] to the above algorithm. We first give the reduction.

Lemma 7**.**

[15]** Let $C$ be a class of boolean functions that is closed under variable projection. If $C$ is non-adaptively learnable in time $T(n)$ with $Q(n)$ membership queries, then $C$ is non-adaptively learnable in time

[TABLE]

with

[TABLE]

membership queries, where $d$ is an upper bound on the number of relevant variables in $f\in C$ and $q$ is any integer such that $q\geq 2(d+1)^{2}$.

We now prove

Theorem 3**.**

There is a deterministic non-adaptive algorithm that learns $d$-Junta in time $poly(d^{d},n)$ with $O(d^{3}2^{d}\log n)$ queries.

Proof.

We apply the reduction in Lemma 7 on the result from Theorem 2 with $q=2d(d+1)^{2}$, $Q(n)=O(d2^{d}\log{n})$ and $T(n)=n^{O(d)}$. The time complexity is

[TABLE]

which is $poly(d^{d},n)$, and the query complexity is

[TABLE]

∎

We now present the third algorithm. We first give a simple algorithm that runs in polynomial time and uses $2^{d+O(\log^{2}{d})}n\log{n}$ queries, and then we use the reduction in Lemma 7.

The algorithm first constructs an $(n,d)$-universal set $U$. Then, the algorithm replaces each assignment $a\in U$ by a block of ${n+1}$ assignments in the following way: it keeps the original assignment. In addition, for each index ${1\leq i\leq n}$, it adds the assignment ${a|_{{x_{i}}\leftarrow{\bar{{a_{i}}}}}}$ where $x_{i}$ is the $i$-th variable of the target function. Denote the new set of assignments by $U^{\prime}$. After asking $U^{\prime}$, we can find the set of relevant variables by comparing the value of the target function $f$ on the first assignment in each block with the value of $f$ on each one of the other assignments in the block. Since $U$ is a universal set, we can now find the function.

Now, we use a polynomial time construction of an $(n,d)$-universal set of size

$2^{d+O(\log^{2}{d})}\log{n}$, as described in Lemma 3, and apply the reduction in Lemma 7 to this algorithm for $q=2(d+1)^{2}$. We get a new non-adaptive algorithm that runs in polynomial time and asks $2^{d+O(\log^{2}{d})}\log{n}$ queries.

We now give a formal proof.

Theorem 4**.**

There is a deterministic non-adaptive algorithm that learns $d$-Junta in polynomial time with $2^{d+O(\log^{2}{d})}\log n$ queries.

Proof.

Consider the above algorithm. Let $f$ be the target function and let $x_{i_{1}},\ldots,x_{i_{d^{\prime}}}$, $d^{\prime}\leq d$ be the relevant variables. Then, we can write $f=g(x_{i_{1}},\ldots,x_{i_{d^{\prime}}})$. For any $1\leq j\leq d^{\prime}$, since $x_{i_{j}}$ is a relevant variable, there is an assignment $b\in\{0,1\}^{d^{\prime}}$ such that $g(b)\not=g(b|_{x_{i_{j}}\leftarrow\bar{b}_{i_{j}}})$. Since $U$ is an $(n,d)$-universal set, there is an assignment $a\in U$ such that $(a_{i_{1}},\ldots,a_{i_{d^{\prime}}})=(b_{i_{1}},\ldots,b_{i_{d^{\prime}}})$. Therefore

[TABLE]

This shows that the above algorithm can discover all the relevant variables after asking the set of assignments $U^{\prime}$.

Since $U$ is an $(n,d)$-universal set, by looking at the entries of the relevant variables in $U$ we can find all the possible assignments for $x_{i_{1}},\ldots,x_{i_{d^{\prime}}}$. Therefore, $g$, and consequently $f$, can be uniquely determined.

This algorithm asks $2^{d+O(\log^{2}{d})}n\log{n}$ queries and runs in polynomial time. Finally, we use the reduction in Lemma 7 with $q=2(d+1)^{2}$, $Q(n)=2^{d+O(\log^{2}{d})}n\log{n}$ and $T(n)=poly(2^{d},n)$, and this completes the proof. ∎

4 Randomized Non-adaptive Algorithms

In this section we study randomized non-adaptive learning of $d$-Junta.

4.1 Lower Bound

The lower bound for deterministic algorithms does not imply the same lower bound for randomized algorithms. To prove a lower bound for randomized non-adaptive algorithms we use the minimax technique. We prove

Theorem 5**.**

Let $d<n/2$. Any Monte Carlo randomized non-adaptive algorithm for learning $d$-Junta must ask at least $\Omega(2^{d}\log n)$ membership queries.

Proof.

Let ${\cal A}(s,Q_{f})$ be a Monte Carlo randomized non-adaptive algorithm that learns $d$-Junta with success probability at least $1/2$, where $s\in\{0,1\}^{*}$ is the random seed and $Q_{f}$ is the membership oracle to the target $f$. Since ${\cal A}(s,Q_{f})$ is Monte Carlo it stops after some time $T$ and therefore we may assume that $s\in\{0,1\}^{T}$. Consider the random variable $X(s,f)\in\{0,1\}$ that is equal to $1$ if and only if the algorithm ${\cal A}(s,Q_{f})$ returns $f$. Then, ${\bf E}_{s}[X(s,f)]\geq 1/2$ for all $f$.

Consider the set of functions

[TABLE]

and the uniform distribution $U_{F}$ over $F$. Then

[TABLE]

Consider any seed $s^{\prime}$ that maximizes ${\bf E}_{U_{F}}[X(s,f)]$. Then ${\bf E}_{U_{F}}[X(s^{\prime},f)]\geq 1/2$. Let $A_{s^{\prime}}=\{a^{(1)},\ldots,a^{(m_{s^{\prime}})}\}$ be the queries asked by the algorithm when it uses the seed $s^{\prime}$. Note that since the algorithm is non-adaptive, $m_{s^{\prime}}$ is independent of $f$. Since the query complexity of a Monte Carlo algorithm is the worst case complexity over all $s$ and $f$, we have that $m_{s^{\prime}}$ is a lower bound for the query complexity. So it is enough to show that $m_{s^{\prime}}=\Omega(2^{d}\log n)$.

Define for every vector $\xi=(\xi_{1},\ldots,\xi_{d-1})\in\{0,1\}^{d-1}$ the subset

[TABLE]

Notice that $\{A_{s^{\prime}}(\xi)\}_{\xi}$ are disjoint sets. Suppose that at least $3/4$ fraction of $\xi$ satisfy $|A_{s^{\prime}}(\xi)|\leq\log(n-d+1)-3$. Then, for a random uniform $f_{\xi^{\prime},i^{\prime}}\in F$ (and therefore, random uniform $\xi^{\prime}$), with probability at least $3/4$ we have $|A_{s^{\prime}}(\xi^{\prime})|\leq\log(n-d+1)-3$. For any other assignment $a\in A_{s^{\prime}}\backslash A_{s^{\prime}}(\xi^{\prime})$ we have $f_{\xi^{\prime},i^{\prime}}(a)=0$ so no information about $i^{\prime}$ can be obtained from these assignments. If $|A_{s^{\prime}}(\xi^{\prime})|\leq\log(n-d+1)-3$ then there are at most $(n-d+1)/8$ distinct values that any $f\in\{f_{\xi^{\prime},j}\}_{j}$ can take on $A_{s^{\prime}}(\xi^{\prime})$ and therefore the probability to find $i^{\prime}$ is at most $1/4$. Therefore, if at least $3/4$ fraction of $\xi$ satisfy $|A_{s^{\prime}}(\xi)|\leq\log(n-d+1)-3$, then the probability of success, ${\bf E}_{U_{F}}[X(s^{\prime},f)]$, is at most $1-(3/4)^{2}=7/16<1/2$. This gives a contradiction. Therefore for at least $1/4$ fraction of $\xi$ we have $|A_{s^{\prime}}(\xi)|>\log(n-d+1)-3$. Then

[TABLE]

∎

4.2 Upper Bound and Polynomial Time Algorithms

If randomization is allowed, for some cases the performance of our deterministic non-adaptive algorithms is satisfying when comparing with algorithms that take advantage of the randomization. This applies for $n^{O(d)}$ time algorithms, where the algorithm from Theorem 2 gives good results. This algorithm provides also the upper bound of $O(d2^{d}\log{n})$ queries for randomized non-adaptive learning. In addition, for $poly(d^{d},n)$ time algorithms, we can apply the algorithm from Theorem 3 that asks $O(d^{3}2^{d}\log{n})$ queries.

But, this is not the case for $poly(2^{d},n)$ time algorithms. In this case we can improve over the deterministic result for certain values of the failure probability $\delta$. We next present a new Monte Carlo non-adaptive algorithm that runs in $poly(2^{d},n,\log{(1/\delta)})$ time.

We first prove

Lemma 8**.**

Let be $1\leq i_{1}\leq i_{2}\leq\cdots\leq i_{d}\leq n$ and $B\subseteq\{0,1\}^{d}$. If we randomly uniformly choose $2^{d}(\ln|B|+\ln(1/\delta))$ assignments $A\subseteq\{0,1\}^{n}$, then with probability at least $1-\delta$ we have: for every $b\in B$ there is an $a\in A$ such that $(a_{i_{1}},\ldots,a_{i_{d}})=b$.

Proof.

The probability of failure is at most $|B|(1-2^{-d})^{|A|}\leq|B|e^{-|A|/2^{d}}=\delta.$ ∎

We say that the variable $x_{i}$ is sensitive in $f$ with respect to an assignment $a$ if $f(a|_{x_{i}\leftarrow 0})\not=f(a|_{x_{i}\leftarrow 1})$. Obviously, if $x_{i}$ is relevant in $f$ then there is an assignment $a$ where $x_{i}$ is sensitive in $f$ with respect to $a$. If $x_{i}$ is irrelevant then $x_{i}$ is not sensitive in $f$ with respect to any assignment.

We now prove

Lemma 9**.**

Let $f$ be a $d$-Junta function. Let $a$ be an assignment that $x_{j}$ is sensitive in $f$ with respect to, and let $x_{i}$ be an irrelevant variable in $f$. Let $b$ be a random assignment where each entry $b_{\ell}\in\{0,1\}$ is independently chosen to be $1$ with probability $1/(3d)$. Then

[TABLE]

and

[TABLE]

Proof.

If $b_{\ell}=0$ for all the relevant variables $x_{\ell}$ of $f$ then $f(a+b)=f(a)$. Therefore $\Pr_{b}[f(a+b)=f(a)\mbox{\ and \ }b_{i}=1]$ is greater or equal to the probability that $b_{\ell}=0$ for all the relevant variables $x_{\ell}$ of $f$ and $b_{i}=1$. This probability is at least

[TABLE]

If $x_{j}$ is sensitive in $f$ with respect to $a$ then the probability that $f(a+b)=f(a)$ when $b_{j}=1$ is less or equal to the probability that $b_{\ell}=1$ for some other relevant variable $x_{\ell}$ of $f$. Therefore

[TABLE]

∎

From Chernoff bound it follows that

Lemma 10**.**

Let $f$ be a $d$-Junta function. Let $a$ be any assignment. There is an algorithm that asks $O(d(\log n+\log 1/\delta))$ membership queries and with probability at least $1-\delta$ finds all the sensitive variables in $f$ with respect to $a$ (and maybe other relevant variables of $f$ as well).

Now we give the algorithm

Theorem 6**.**

$d$-Junta is non-adaptively learnable in $poly(2^{d},n,\log{1/\delta})$ time and $O((d2^{d}\log n+d^{2}2^{d})\log(1/\delta))$ queries, where $\delta$ is the failure probability and it satisfies $\delta\leq 1/d$.

Proof.

Consider the following algorithm. We first choose $t=O(2^{d}(\log d+\log(1/\delta)))$ random uniform assignments $A$. To find the relevant variables we need for each one an assignment that the variable is sensitive in $f$ with respect to it. Therefore, we need at most $d$ such assignments. By Lemma 8, with probability at least $1-(\delta/3)$, for every relevant variable in $f$ there is an assignment $a$ in $A$ such that this variable is sensitive in $f$ with respect to it. Now, by Lemma 10, for each $a\in A$ there is an algorithm that asks $O(d(\log n+\log(t/\delta)))$ membership queries and with probability at least $1-(\delta/(3t))$ finds all the variables that are sensitive to it. Therefore, there is an algorithm that asks $O(dt(\log n+\log(t/\delta)))$ membership queries and with probability at least $1-(\delta/3)$ finds every variable that is sensitive in $f$ with respect to some assignment in $A$. This gives all the relevant variables of $f$. Now again by Lemma 8, with another $O(2^{d}(d+\log(1/\delta)))$ assignments we can find, with probability at least $1-(\delta/3)$, the value of the function in all the possible assignments for the relevant variables. At the end, we can output the set of relevant variables and a representation of the target function as a truth table (with the relevant variables as entries).

This algorithm runs in time $poly(2^{d},n,\log{(1/\delta)})$ and asks

[TABLE]

membership queries. For $\delta=1/d$ we have the complexity

[TABLE]

For $m$ repetitions of the algorithm with at least one success, we can find the correct target function by the following. First, for each output function, verify that each claimed relevant variable is indeed relevant with respect to the function’s truth table. Discard functions that don’t satisfy this. Second, take the function with the maximum number of relevant variables out of the remaining functions. This is the correct target function. This can be done in $poly(n,2^{d},m)$ time.

Therefore, for $\delta\leq 1/d$, we can repeat the above algorithm $O(\log(1/\delta)/\log d)$ times (non-adaptively) to get a success probability of at least $1-\delta$ and a query complexity of

[TABLE]

∎

Notice that if $\delta=1/poly(n)$ then the query complexity becomes quadratic in $\log n$. In the next subsection we solve this problem by giving a reduction that changes the query complexity to

[TABLE]

4.3 A Reduction for Randomized Non-adaptive Algorithms

In this subsection we give a reduction for randomized non-adaptive algorithms. Using this reduction we prove

Theorem 7**.**

There is a Monte Carlo randomized non-adaptive algorithm for learning $d$-Junta in $poly(2^{d},n,\log{(1/\delta)})$ time that asks $O((\log{d})d^{2}2^{d}(\log n+\log(1/\delta)))$ membership queries.

This result improves over the result from the previous subsection for values of $\delta$ small enough.

We start with some definitions. Let $C$ be a class of functions and let $H$ be a class of representations of functions. We say that $C$ is a subclass of $H$ if for every function $f$ in $C$ there is at least one representation $h$ in $H$. We say that $C$ is non-adaptively learnable from $H$ if there is a non-adaptive learning algorithm that for every function $f\in C$ outputs a function $h\in H$ that is equivalent to the target function $f$. We say that $C$ is closed under distinct variable projection if for any function $f\in C$ and any permutation $\phi:[n]\to[n]$ we have $f(x_{\phi(1)},\ldots,x_{\phi(n)})\in C$.

We now prove

Theorem 8**.**

Let $C$ be a class of boolean functions that is closed under distinct variable projection. Let $d$ be an upper bound on the number of relevant variables in any $f\in C$. Let $H$ be a class of representations of boolean functions. Let $h_{1},h_{2}$ be functions in $H$ with at most $d$ relevant variables, where these relevant variables are known. Suppose there is a deterministic algorithm ${\cal B}(d,n)$ that for such input $h_{1}$ and $h_{2}$ decides whether the two functions are equivalent in time $E(d,n)$.

Let ${\cal A}(d,n,\delta)$ be a Monte Carlo non-adaptive algorithm that with failure probability at most $\delta$, learns $C$ from $H$ and finds the set of relevant variables of the input in time $T(d,n,\delta)$ with $Q(d,n,\delta)$ membership queries. Then, $C$ is Monte Carlo non-adaptively learnable from $H$ in time

[TABLE]

with

[TABLE]

membership queries, where $\delta$ is the failure probability and $q$ is any integer such that $q\geq 8d^{2}$.

Proof.

Let ${\cal A}(d,n,\delta)$ and ${\cal B}(d,n)$ be as stated in the theorem above. Let $f\in C$ be the target function and suppose the relevant variables in $f$ are $x_{i_{1}},\ldots,x_{i_{d^{\prime}}}$ where $d^{\prime}\leq d$. Let be $I=\{i_{1},\ldots,i_{d^{\prime}}\}$.

We first choose $O(\log(n/\delta))$ random hash functions $h:[n]\to[q]$ and put them in $P$. For each hash function $h\in P$ we define the following events. The event $A_{h}$ is true if $h(I):=\{h(i_{1}),\ldots,h(i_{d^{\prime}})\}$ are not distinct. The event $B_{h,j}$, $j\in[n]\backslash I$, is true if $h(j)\in h(I)$. For any $h\in P$, the probability that $A_{h}$ is true is at most

[TABLE]

For any $h\in P$ and $j\in[n]\backslash I$, the probability that $B_{h,j}$ is true is at most $d/q\leq 1/8$.

By Chernoff bound, with failure probability at most $\delta/(3n)$, we have that at least 7/8 of $\{A_{h}\}_{h\in P}$ are false. Therefore, with failure probability at most $\delta/(3n)$, at least 7/8 of $\{f_{h}:=f(x_{h(1)},\ldots,x_{h(n)})\}_{h\in P}$ are still in $C$. This is true because $C$ is closed under distinct variable projection.

Let $V_{h}$ be the set of relevant variables that ${\cal A}$ outputs when running with the input $f_{h}$. Since hashing can not raise the number of relevant variables in the function, we can now for each $h\in P$ run in parallel ${\cal A}(d,q,1/8)$ to learn $f_{h}$ and find $V_{h}$. Let $S\subseteq P$ denote the set of $h\in P$ where the corresponding processes finish after $T(d,q,1/8)$ time. For each $h\in S$, denote the output of ${\cal A}$ on $f_{h}$ by $f^{\prime}_{h}$. With failure probability at most $\delta/(3n)$, it holds that $|S|\geq 7/8|P|$. This is true because ${\cal A}(d,q,1/8)$ stops after $T(d,q,1/8)$ time for each function in $C$, and with failure probability $\delta/(3n)$ at least 7/8 of $\{f_{h}\}_{h\in P}$ are in $C$. For any other $h\in P$, we stop its process and set $f^{\prime}_{h}=0$, $V_{h}=\varnothing$. Applying Chernoff bound on $\{f^{\prime}_{h}\}_{h\in S}$ yields that for at least 6/7 of them ${\cal A}$ succeeds, with failure probability at most $\delta/(3n)$. Therefore, with failure probability at most $2\delta/(3n)\leq 2\delta/3$ we have that for at least $7/8\times 6/7=3/4$ of ${h\in P}$ it holds that $h(I)$ are distinct, $f^{\prime}_{h}=f_{h}$ and the set of relevant variables $V_{h}$ is correct.

For each $h\in P$ define the set $W_{h}=\{x_{i}\ |\ x_{h(i)}\in V_{h}\}$ and let $W$ be the set of all the variables appearing in more than 1/2 of the $\{W_{h}\}_{h\in P}$. We now find the probability that a relevant variable of $f$ is in $W_{h}$ and compare it with the probability that an irrelevant variable of $f$ is in $W_{h}$. For $1\leq k\leq d^{\prime}$, the probability that $x_{i_{k}}\not\in W_{h}$ is at most the probability that $A_{h}$ is true or that ${\cal A}$ fails. This probability is at most $1/16+1/8=3/16.$ Therefore the probability that a relevant variable is in $W_{h}$ is at least 13/16. Therefore, by Chernoff bound, the probability that $x_{i_{k}}\not\in W$ is at most $\delta/(3n)$. The probability that an irrelevant variable $x_{j}$, $j\not\in I$, is in $W_{h}$ is at most the probability that $A_{h}$ or $B_{h,j}$ is true or that ${\cal A}$ fails. This is bounded by $1/16+1/8+1/8=5/16$. Therefore, by Chernoff bound, the probability that $x_{j}\in W$ for $j\not\in I$ is at most $\delta/(3n)$.

Therefore, when running the algorithm for $O(\log(n/\delta))$ random hash functions, $W$ contains all the relevant variables of the target function $f$ and only them, with probability at least $1-\delta/3$.

Let $T$ be the set of all $h\in H$ such that for each $v_{i}\in V_{h}$ there is exactly one variable $x_{j}\in W$ for which $h(j)=i$. For each $h\in T$, let be $V_{h}=\{v_{i_{1}},\ldots,v_{i_{l_{h}}}\}$, where $l_{h}\leq d^{\prime}$, and $f^{\prime}_{h}:=f^{\prime}_{h}(v_{i_{1}},\ldots,v_{i_{l_{h}}})$. Define $g_{h}:=f^{\prime}_{h}(x_{j_{1}},\ldots,x_{j_{l_{h}}})$ where $h(j_{k})=i_{k}$. Now, with failure probability at most $2\delta/3+\delta/3=\delta$, it holds that at least 3/4 of $\{g_{h}\}_{h\in T}$ are identical to the target function $f$. Therefore, at the end we use ${\cal B}(d,q)$ to find ${\rm{Popular}}(\{g_{h}\}_{h\in T})$ and output it.

∎

Let $C$ be $d$-Junta and let $H$ be a class of representations of boolean functions as truth tables with the relevant variables of the function as entries. Let ${\cal A}$ be the algorithm described in the previous subsection with the query complexity in (4.2). This algorithm learns $d$-Junta from $H$ and outputs the set of relevant variables. Let ${\cal B}$ be the simple algorithm that given two functions in $H$ with at most $d$ relevant variables where these relevant variables are known, decides if they are identical by comparing the sets of relevant variables and the values of the two functions on the $O(2^{d})$ entries in the tables. This algorithm runs in $poly(2^{d},n)$ time. We can now apply the reduction for $q=8d^{2}$ and get the result from Theorem 7.

5 Deterministic Adaptive Algorithms

In this section we study deterministic adaptive learning of $d$-Junta.

5.1 Lower and Upper Bound

For deterministic learning, the lower bound is $\Omega(2^{d}\log{n})$. Its proof is discussed earlier in the section for non-adaptive deterministic learning. We now address the upper bound. In [8] Damaschke gives an adaptive algorithm that learns $d$-Junta with $U(n,d)+O(d\log{n})$ queries, where $U(n,d)$ denotes the minimum size of an $(n,d)$-universal set. His algorithm first fixes an $(n,d)$-universal set $A$ and then asks all the queries $a\in A$. The algorithm can then find all the relevant variables in $d^{\prime}$ search phases, where $d^{\prime}\leq d$ is the number of relevant variables. Damaschke shows that at the beginning of each phase of the algorithm, the algorithm can either determine the non-existence of further relevant variables or discover a new one in $\log{n}$ rounds, asking one query each round. Since $A$ is a universal set, after the algorithm has discovered all relevant variables, it can now find the function. This, along with the upper bound on the size of a universal set from (1), gives the upper bound of $O(d2^{d}\log{n})$ queries. The number of rounds is $O(d\log{n})$. We note here that our upper bound for deterministic non-adaptive learning achieves the same query complexity of $O(d2^{d}\log{n})$.

5.2 Polynomial Time Algorithms

To address polynomial time algorithms, we first consider the algorithm from the previous subsection. If we analyze the running time of this algorithm, we notice that apart from the construction time of the universal set, the algorithm runs in polynomial time. Therefore, for a construction of an $(n,d)$-universal set of size $S$ that runs in time $T$, this algorithm asks $S+O(d\log{n})$ queries and runs in time $T+poly(2^{d},n)$. This, along with Lemma 3, gives the following results: there is an algorithm that runs in $n^{O(d)}$ time and asks $O(d2^{d}\log{n})$ queries, and there is an algorithm that runs in $poly(2^{d},n)$ time and asks $2^{d+O(\log^{2}d)}\log n$ queries. Both algorithms run in $O(d\log{n})$ rounds.

We note here that our deterministic non-adaptive algorithms for $n^{O(d)}$ time and $poly(2^{d},n)$ time achieve the same query complexity of the above algorithms, yet run in only one round. Therefore, they might be preferable over the adaptive ones. These algorithms are described earlier in the deterministic non-adaptive section.

For $poly(d^{d},n)$ time algorithms, one option is to follow the above algorithm and use a construction of an $(n,d)$-universal set that runs in $poly(d^{d},n)$ time, as described in Lemma 3. But, we present another algorithm that will be useful in the construction of randomized algorithms in the next section. In addition, the algorithm we present uses only two rounds for learning. The algorithm is based on another one presented by Damaschke in [9]. Damaschke shows that functions from $d$-Junta can be learned in $poly(d^{d},n)$ time by a two round algorithm that asks $O((\log{d})d^{3}2^{d}\log{n})$ queries, [9]. For his algorithm, he uses an $(n,d^{2},d)$-PHF. Available $(n,d^{2},d)$-PHF constructions are of size $O(d^{2}\log{n})$, see Corollary 1. We can improve this result if we use a $poly(n)$ time construction of an $(n,d^{3},d)$-PHF of size $O(d^{2}\log{n}/\log{d})$, as stated in Corollary 1. Furthermore, as part of his algorithm, Damaschke applies an earlier non-adaptive algorithm of his. We can replace it by a more efficient non-adaptive algorithm of ours, which we described earlier in the section for deterministic non-adaptive learning.

To put it in formal terms, we start with a folklore result (see for example the first observation by Blum in [20]): let $f$ be a function in $d$-Junta with a set of variables $x=\{x_{1},\ldots,x_{n}\}$. Let $a$ and $a^{\prime}$ be two assignments such that $f(a)\neq f(a^{\prime})$. Let $y\subseteq x$ be the set of variables that the values of $a$ and $a^{\prime}$ differ on. Then

Lemma 11**.**

We can in polynomial time and $O(\log{|y|})$ rounds find a relevant variable in $y$ asking $O(\log{|y|})$ queries. 2. 2.

If, furthermore, we are guaranteed that there exists exactly one relevant variable in $y$, we can find it in only one round. The time complexity remains polynomial and the query complexity remains $O(\log{|y|})$.

We give the proof for completeness.

Proof.

1. For proving the first part consider the following full adaptive algorithm that performs a simple binary search. Start with the given $a$, $a^{\prime}$ and $y$. Let $z\subseteq y$ be a subset of $y$ that contains half of the variables in $y$. At each new round, construct a new assignment $a^{\prime\prime}$ that is identical to $a$ and $a^{\prime}$ on the variables $x-y$, is equal to $a$ on $z$ and is equal to $a^{\prime}$ on $y-z$. If $f(a^{\prime\prime})\neq f(a^{\prime})$, then we know there is a relevant variable in $z$. In this case update $y\leftarrow z$ and $a\leftarrow a^{\prime\prime}$. Otherwise we have $f(a^{\prime\prime})\neq f(a)$ and we can update $y\leftarrow y-z$ and $a^{\prime}\leftarrow a^{\prime\prime}$. We start a new round as long as $|y|>1$. When $|y|=1$, we have found a relevant variable.

The number of rounds and query complexity follow immediately if we notice that at each new round the size of $y$ reduces by a factor of 2. The time complexity is immediate.

For proving the second part start by constructing a set $A$ of $\lceil\log{|y|}\rceil+1$ queries as follows. Let all the queries in $A$ be identical to $a$ and $a^{\prime}$ on the variables $x-y$. In order to describe what values these queries take on $y$, we refer to the $|A|\times n$ order matrix $M$ which the queries in $A$ form its rows. Consider the $|y|$ columns in $M$ that correspond to the set of variables $y$. Let each one of these columns take a different $\lceil\log{|y|}\rceil$ dimensional vector in the first $\lceil\log{|y|}\rceil$ rows of $M$. There remains now only the last row. Set it to the value $1$ on every column that corresponds to $y$. Now, ask $A$ non-adaptively. Let $t$, $|t|=|A|$, be the vector of answers. Let $x^{\prime}\in y$ be the relevant variable in $y$. Then, $t$ must either be equal to the column in $M$ corresponding to $x^{\prime}$ or be equal to its negation. The way $M$ is constructed guarantees there is no other column corresponding to a variable in $y$ that satisfies this. Therefore, $x^{\prime}$ is successfully detected.

The time and query complexities follow immediately.

∎

Now, we present the algorithm.

Theorem 9**.**

There is a deterministic adaptive two round algorithm that learns $d$-Junta in time $poly(d^{d},n)$ with $O(d^{3}2^{d}\log{n})$ queries.

Proof.

Let $f\in d$-Junta be the target function. First, construct an $(n,d^{3},d)$-PHF $H$ of size $O(d^{2}\log{n}/\log{d})$ in $poly(n)$ time. For each $h\in H$, we have a new function $f_{h}:\{0,1\}^{d^{3}}\to\{0,1\}$ that is defined by $f_{h}(v):=f(x_{h(1)},\ldots,x_{h(n)})$. For a variable in $f_{h}$ to be a relevant variable, a necessary condition is that at least one relevant variable of $f$ is mapped to it. Therefore, we now have $O(d^{2}\log{n}/\log{d})$ new boolean functions, each of them in $d^{3}$ variables, of which at most $d$ are relevant. For each $f_{h}$, we can learn it with our deterministic non-adaptive algorithm from Theorem 2. This algorithm runs in $n^{O(d)}$ time and asks $O(d2^{d}\log{n})$ queries for a function in $n$ variables of which at most $d$ are relevant. We apply this algorithm simultaneously to all $\{f_{h}\}_{h\in H}$. Therefore, learning all $\{f_{h}\}_{h\in H}$ is done non-adaptively in $poly(d^{d},n)$ time asking $O((d^{2}\log{n}/\log{d})\cdot d2^{d}\log{(d^{3})})=O(d^{3}2^{d}\log{n})$ queries. This is the first round of the algorithm.

Let $h^{\prime}\in H$ be the mapping that succeeded to separate the relevant variables of $f$. In the second round we find the function $f_{h^{\prime}}$. This is done by simply taking a function $f_{h^{\prime}}$ with the highest number of relevant variables. This is true because for a variable in some $f_{h}$ to be a relevant variable, a necessary condition is that at least one relevant variable of $f$ is mapped to it. Therefore in this case, each relevant variable of $f_{h^{\prime}}$ has exactly one relevant variable of $f$ mapped to it. Remember that the algorithm from Theorem 2 gives us the set of relevant variables of the target function. Now that we know $f_{h^{\prime}}$ and its relevant variables, for each relevant variable $v_{i}$ of $f_{h^{\prime}}$, we also know an assignment $a:=(a_{1},\ldots,a_{d^{3}})$ such that $f_{h^{\prime}}(a|_{v_{i}\leftarrow 0})\neq f_{h^{\prime}}(a|_{v_{i}\leftarrow 1})$. Therefore, for each relevant variable in $f_{h^{\prime}}$ we can apply the algorithm from Lemma 11 part 2 on the variables of $f$ that are mapped to it, and find the original relevant variable. This is done non-adaptively in polynomial time using $O(\log{n})$ queries. We apply this algorithm simultaneously to all the relevant variables of $f_{h^{\prime}}$. Now that we have learned $f_{h^{\prime}}$ and know all the relevant variables of $f$, we have the target function $f$. This second round runs then in polynomial time and asks $O(d\log{n})$ queries.

Therefore, this algorithm learns functions from $d$-Junta in two rounds in $poly(d^{d},n)$ time with a query complexity of $O(d^{3}2^{d}\log{n})+O(d\log{n})=O(d^{3}2^{d}\log{n}).$ ∎

If we compare the above algorithm with the corresponding deterministic non-adaptive algorithm that runs in $poly(d^{d},n)$ time, we notice that they have the same query complexity. Even so, as mentioned before, the above algorithm is going to serve us in the next section.

6 Randomized Adaptive Algorithms

When we allow both randomization and adaptiveness, new bounds and algorithms arise. We discuss the new results in the following subsections.

6.1 Lower Bound

For randomized adaptive algorithms, Abasi et. al. [15] showed that any Monte Carlo randomized algorithm for learning a class of functions $C$ must ask at least $\Omega(\log|C|)$ queries. This implies

Theorem 10**.**

Any Monte Carlo randomized adaptive algorithm for learning $d$-Junta must ask at least $\Omega(d\log{n}+2^{d})$ membership queries.

Proof.

Let $F_{=k}$ be the class of boolean functions in $k$ given variables $y_{1},\ldots,y_{k}$, where each function depends on all the $k$ variables. Let $F_{k}$ be the class of all boolean functions in $k$ given variables $y_{1},\ldots,y_{k}$. Obviously, $|F_{k}|=2^{2^{k}}$. By Bonferroni inequality we have

[TABLE]

Therefore

[TABLE]

and $\Omega(\log|\mbox{d-Junta}|)=\Omega(d\log(n/d)+2^{d})=\Omega(d\log{n}+2^{d})$. ∎

6.2 Polynomial Time Algorithms

In this subsection, for polynomial time complexity, we give three new Monte Carlo adaptive algorithms for learning $d$-Junta. We start by presenting an algorithm based on the algorithm from Theorem 9. A similar algorithm that uses $O(d\log{n}+d^{2}2^{d}\log{(1/\delta)})$ queries was presented by Damaschke in [9]. This query complexity is the result of a modification we apply to the analysis of Damaschke’s algorithm, in order to make it applicable for a general failure probability $\delta$. Now we present our result.

Theorem 11**.**

There is a two round Monte Carlo algorithm that learns $d$-Junta with $O(d\log{n}+d2^{d}\log{(1/\delta)})$ queries and runs in $poly(d^{d},n,\log{(1/\delta)})$ time, where $\delta$ is the failure probability and $\delta\leq 1/d$. For $\delta>1/d$, the query complexity of the algorithm is $O(d\log{n}+(\log{d})d2^{d})$.

Proof.

Let ${\cal A}$ be the two round deterministic algorithm from Theorem 9. Our randomized algorithm follows a similar pattern to the pattern of $\cal A$. The difference is that it does not use a deterministic PHF. Instead, in the first round, it uses $O(\log{(1/\delta)}/\log{d})$ random partitions of the variables into $d^{3}$ bins for $\delta\leq 1/d$, and simply one partition for $\delta>1/d$. Let $x=\{x_{1},\ldots,x_{n}\}$ be the set of variables of the target function $f$. Let $D$ be the set of relevant variables. Let $P$ be the set of random partitions. For each $p\in P$, let be $f_{p}:=f(x_{p(1)},\ldots,x_{p(n)})$. Learn the set of functions $\{f_{p}\}_{p\in P}$ simultaneously applying the deterministic non-adaptive algorithm from Theorem 2. This is the first round of the algorithm, it runs in time $poly(d^{d},n,\log{(1/\delta)})$. For $\delta\leq 1/d$ it asks $O(d2^{d}\log{(1/\delta)})$ queries, and for $\delta>1/d$ it asks $O((\log{d})d2^{d})$ queries.

In the second round, our algorithm takes a function $f_{p^{\prime}}$ with the highest number of relevant variables and uses it to learn the target function $f$. To this purpose, it applies exactly the same procedure that $\cal A$ uses in the second round. Therefore, the second round runs in polynomial time and asks $O(d\log{n})$ queries. In total, the algorithm runs in $poly(d^{d},n,\log{(1/\delta)})$ time and asks $O(d\log{n}+d2^{d}\log{(1/\delta)})$ queries for $\delta\leq 1/d$, and $O(d\log{n}+(\log{d})d2^{d})$ queries for $\delta>1/d$.

To compute the failure probability we notice that if at least one of the partitions in $P$ succeeds to separate $D$ in the first round, then the algorithm outputs a correct answer. This is true since in this case the algorithm chooses for the second round a function $f_{p^{\prime}}$ with a successful partition $p^{\prime}$. Therefore, the failure probability is bounded by the probability that none of the partitions in $P$ succeeds. We first compute the failure probability of a single random partition when each element of $x$ is thrown independently and equiprobably into one of the ${d^{3}}$ bins. By the union bound, since $|D|\leq d$, the failure probability is bounded by

[TABLE]

Therefore, one partition is enough for $\delta>1/d$. In addition, if $\delta\leq 1/d$, for $O(\log{(1/\delta)}/\log{d})$ random partitions, the probability that all of them fail is at most $\left(1/d\right)^{O(\log{(1/\delta)}/\log{d})}=\delta$. ∎

We were able to improve Damaschke’s result by, first, using a partition with a different number of bins, and second, applying our non-adaptive algorithm in the first round.

Therefore, for $poly(d^{d},n,\log{1/\delta})$ time randomized algorithms, we have two algorithms. The above algorithm and the deterministic two round algorithm from Theorem 9 that asks $O(d^{3}2^{d}\log{n})$ queries. For best performance, we can choose the algorithm with minimum query complexity based on the requested value of $\delta$.

Now, consider the following two round algorithm that runs in polynomial time. First we describe the algorithm for $\delta\leq 1/d$. In the first round this algorithm applies the same learning process as the above algorithm from Theorem 11 except for one difference. For learning the set of functions $\{f_{p}\}$, this algorithm applies the randomized polynomial time algorithm from Theorem 6. Then, the algorithm takes $\delta=1/d$ and repeats (non-adaptively) the first round $O(\log{(1/\delta)}/\log{d})$ times. Therefore, the query complexity of the first round is

[TABLE]

and the failure probability is $\delta$.

In the second round, this algorithm performs the same procedure as the above one from Theorem 11. The second round therefore runs in polynomial time and asks $O(d\log{n})$ queries.

Now, for $\delta>1/d$, we can still apply a similar algorithm with the following changes. First, one partition of the variables into $d^{3}$ bins is enough. Second, for learning the new function with $d^{3}$ variables in the first round, apply the algorithm with the query complexity from (4.2). This is the initial non-adaptive polynomial time algorithm. This gives us a polynomial time algorithm that runs in two rounds. Analyzing the query complexity of this algorithm gives the result $O(d\log{n}+(\log{d})d^{2}2^{d})$.

To conclude

Theorem 12**.**

There is a two round Monte Carlo algorithm that learns $d$-Junta in $poly(2^{d},n,\log{(1/\delta)})$ time. The algorithm asks $O(d\log{n}+d^{2}2^{d}\log{(1/\delta)})$ queries for a failure probability $\delta\leq 1/d$, and asks $O(d\log{n}+(\log{d})d^{2}2^{d})$ queries for $\delta>1/d$.

Finally, we present a polynomial time algorithm for randomized adaptive learning that achieves a query complexity that misses the lower bound of $O(d\log{n}+2^{d})$ by a factor not larger than $\log{1/\delta}$.

Theorem 13**.**

Functions from $d$-Junta can be learned in $poly(2^{d},n,\log{(1/\delta)})$ time by a Monte Carlo algorithm that asks $O(d\log{n}+2^{d}\log{(1/\delta)})$ queries, where the failure probability satisfies $\delta\leq 1/d$. For $\delta>1/d$, the query complexity is $O(d\log{n}+(\log{d})2^{d})$. The number of rounds is $O(d\log{d})$.

Proof.

We first present the algorithm for $\delta\leq 1/d$. At the end, we specify what changes should be made for the case of $\delta>1/d$.

Let $f$ be a function in $d$-Junta with a set of variables $x=\{x_{1},\ldots,x_{n}\}$. Let the set of relevant variables be $D=\{x_{i_{1}},\ldots,x_{i_{d^{\prime}}}\}$ where $d^{\prime}\leq d$. Consider the following algorithm that starts by choosing $O\left((\log{1/\delta})/(\log{d})\right)$ random partitions $P$ of the variables into $d^{3}$ bins. With probability at least $1-\delta/2$, one of the partitions, $p^{\prime}\in P$, succeeds to separate $D$. Let be $f_{p}(y):=f(x_{p(1)},\ldots,x_{p(n)})$ for each $p\in P$. Let $D_{p^{\prime}}=\{y_{t_{1}},\ldots,y_{t_{d^{\prime}}}\}$ be the relevant bins of $f_{p^{\prime}}$. For each $p\in P$ the algorithm asks a set of $2^{d}(\ln(2d)+\ln(2/\delta))$ random uniform assignments $A\in\{0,1\}^{d^{3}}$. From Lemma 8, with probability at least $1-\delta/2$ we have: for every relevant bin $y_{t_{j}}\in D_{p^{\prime}}$, $1\leq j\leq d^{\prime}$, there are two assignments $a,a^{\prime}\in A$ such that $a_{t_{k}}=a^{\prime}_{t_{k}}$ for all the relevant bins where $k\neq j$, $a_{t_{j}}=1-a^{\prime}_{t_{j}}$ and $f_{p^{\prime}}(a)=1-f_{p^{\prime}}(a^{\prime})$. That is, $y_{t_{j}}$ is sensitive in $f_{p^{\prime}}$ w.r.t. $a$ and w.r.t. $a^{\prime}$, where $a$ and $a^{\prime}$ agree on all relevant bins except for $y_{t_{j}}$. In other words, $a$ and $a^{\prime}$ are a proof that $y_{t_{j}}$ is relevant, and they will serve to make sure that $y_{t_{j}}$ is discovered as such.

After asking the set of assignments $A$ for each $p\in P$, the algorithm consists of three stages. In the first stage the algorithm performs $d$ or less phases of the following. Let $I_{p}$ be the set of discovered relevant bins of $f_{p}$ after phase $i$. At the beginning $I_{p}$ is an empty set. At phase $i+1$, the algorithm takes two assignments $b,b^{\prime}\in A$ such that $f_{p}(b)=1-f_{p}(b^{\prime})$ and $b,b^{\prime}$ agree on all the bins in $I_{p}$. Then it finds a new relevant bin in $f_{p}$ and adds it to $I_{p}$. This is done using the procedure in Lemma 11 part 1. This procedure is a polynomial time binary search that runs in $O(\log{(d^{3})})=O(\log{d})$ rounds and asks $O(\log{(d^{3})})=O(\log{d})$ queries. If there are no such $b$ and $b^{\prime}$ for some $p\in P$, then the algorithm finishes the first stage for this $p$. Notice that as long as there exists a not yet discovered relevant bin in $f_{p^{\prime}}$, the algorithm finds such $b,b^{\prime}$ and discovers a new one. This is true with success probability $1-\delta/2$. Therefore, with success probability $1-\delta$, at the end of the first stage we have a successful partition $p^{\prime}$ with $I_{p^{\prime}}=D_{p^{\prime}}$. The successful partition $p^{\prime}$ is discovered by taking a partition $p$ with maximum number of relevant bins.

This first stage is repeated non-adaptively $O\left((\log{1/\delta})/(\log{d})\right)$ times after taking $\delta=1/d$. This optimizes the query complexity while maintaining a failure probability of $\delta$.

Therefore, the number of rounds in the first stage is $O(d\log{d})$. The query complexity is

[TABLE]

and it runs in polynomial time.

The second stage is simply to learn $f_{p^{\prime}}$ in one round deterministically by asking $2^{d^{\prime}}$ queries that take all possible assignments on $I_{p^{\prime}}$.

The third and final stage consists of a one polynomial time round. For each relevant bin $y_{t_{j}}$, the algorithm uses the result of the second phase to find an assignment that $y_{t_{j}}$ is sensitive w.r.t. it. Then, the algorithm discovers the original relevant variable $x_{i_{k}}\in D$ that was mapped to $y_{t_{j}}$ using Lemma 11 part 2. This is a non-adaptive procedure that runs in polynomial time and uses $O(\log{n})$ queries. This is done in parallel for all $y_{t_{j}}\in I_{p^{\prime}}$. Then, the algorithm can output the original function. If the first stage succeeds, this is the correct target function. Therefore, the success probability of the algorithm is $1-\delta$.

In total, for $\delta\leq 1/d$, the number of rounds of this algorithm is $O(d\log{d})$, the number of queries is $O\left(d\log{n}+2^{d}\log{1/\delta}\right)$ and the time complexity is $poly(2^{d},n,\log{(1/\delta)})$.

For $\delta>1/d$, the algorithm performs basically the same three stages with the following simple two changes. In the first stage, one partition into $d^{3}$ variables is enough. In addition, the first stage is performed only one time without repetitions. The number of rounds does not change. Neither does the time complexity. Analyzing the new query complexity for $\delta>1/d$ gives

[TABLE]

∎

The results of the algorithms in Theorems 11, 12 and 13 are summarized in the introduction in Table 2 for adaptive learning. One can choose between them depending on the requested value of $\delta$ and the wanted number of rounds.

For randomized adaptive learning, we have two upper bounds. First, the above algorithm from Theorem 13. Second, the deterministic non-adaptive algorithm from Theorem 2 that asks $O(d2^{d}\log{n})$ queries. In addition, the deterministic non-adaptive algorithm from Theorem 2 along with any other algorithm presented in this section of randomized adaptive learning, they all satisfy the time complexity of $n^{O(d)}$. Therefore, in this case, the selection between them should be based on the requested value of $\delta$ and the restrictions, if exist, on the number of rounds.

7 Conclusions and Future Work

The problem of exact learning of $d$-Junta from membership queries is a fundamental problem with many applications, as discussed in the introduction. Therefore, it would be interesting to try to close or tighten the gaps between the lower and upper bounds in the different presented settings.

We though note here that any further improvement in the deterministic non-adaptive upper bound would be a breakthrough result since it would give a new upper bound result for the size of an $(n,d)$-universal set, an important combinatorial longstanding open problem. This is true since, as mentioned before, any set of assignments that learns $d$-Junta must be an $(n,d)$-universal set, and $O(d2^{d}\log{n})$ is the best known upper bound for the size of $(n,d)$-universal sets.

In addition, while using the minimax technique for this problem has resulted in a new lower bound for randomized non-adaptive learning, we believe that to improve the lower bounds presented in this paper one needs to use a new technique that is beyond the existing ones.

Improving some of the results presented in this paper would be a direct outcome of improvements on the underlying used structures. We find it in particular intriguing to try to improve the $poly(2^{d},n)$ time deterministic construction of $(n,d)$-universal sets from Lemma 3. This would give new non-adaptive and adaptive results.

Future work related to the topic of learning $d$-Junta include the study of monotone $d$-Junta. It might be fruitful to revisit the problem of monotone $d$-Junta in light of the work done in this paper. Another problem worth reexamining is the study of decision trees problem, a natural generalization of the $d$-Junta problem.