On active and passive testing

Given a property of Boolean functions, what is the minimum number of queries required to determine with high probability if an input function satisfies this property or is "far" from satisfying it? This is a fundamental question in Property Testing, where traditionally the testing algorithm is allowed to pick its queries among the entire set of inputs. Balcan, Blais, Blum and Yang have recently suggested to restrict the tester to take its queries from a smaller random subset of polynomial size of the inputs. This model is called active testing, and in the extreme case when the size of the set we can query from is exactly the number of queries performed it is known as passive testing. We prove that passive or active testing of k-linear functions (that is, sums of k variables among n over Z_2) requires Theta(k*log n) queries, assuming k is not too large. This extends the case k=1, (that is, dictator functions), analyzed by Balcan et. al. We also consider other classes of functions including low degree polynomials, juntas, and partially symmetric functions. Our methods combine algebraic, combinatorial, and probabilistic techniques, including the Talagrand concentration inequality and the Erdos--Rado theorem on Delta-systems.Comment: 16 page

Adaptivity Helps for Testing Juntas

We give a new lower bound on the query complexity of any non-adaptive algorithm for testing whether an unknown Boolean function is a k-junta versus epsilon-far from every k-junta. Our lower bound is that any non-adaptive algorithm must make Omega(( k * log*(k)) / ( epsilon^c * log(log(k)/epsilon^c))) queries for this testing problem, where c is any absolute constant <1. For suitable values of epsilon this is asymptotically larger than the O(k * log(k) + k/epsilon) query complexity of the best known adaptive algorithm [Blais,STOC\u2709] for testing juntas, and thus the new lower bound shows that adaptive algorithms are more powerful than non-adaptive algorithms for the junta testing problem

New Lower Bounds for Adaptive Tolerant Junta Testing

We prove a $k^{-\Omega(\log(\varepsilon_2 - \varepsilon_1))}$ lower bound for adaptively testing whether a Boolean function is $\varepsilon_1$-close to or $\varepsilon_2$-far from $k$-juntas. Our results provide the first superpolynomial separation between tolerant and non-tolerant testing for a natural property of boolean functions under the adaptive setting. Furthermore, our techniques generalize to show that adaptively testing whether a function is $\varepsilon_1$-close to a $k$-junta or $\varepsilon_2$-far from $(k + o(k))$-juntas cannot be done with $\textsf{poly} (k, (\varepsilon_2 - \varepsilon_1)^{-1})$ queries. This is in contrast to an algorithm by Iyer, Tal and Whitmeyer [CCC 2021] which uses $\textsf{poly} (k, (\varepsilon_2 - \varepsilon_1)^{-1})$ queries to test whether a function is $\varepsilon_1$-close to a $k$-junta or $\varepsilon_2$-far from $O(k/(\varepsilon_2-\varepsilon_1)^2)$-juntas.Comment: 22 page

Lower Bounds for Tolerant Junta and Unateness Testing via Rejection Sampling of Graphs

We introduce a new model for testing graph properties which we call the rejection sampling model. We show that testing bipartiteness of n-nodes graphs using rejection sampling queries requires complexity Omega~(n^2). Via reductions from the rejection sampling model, we give three new lower bounds for tolerant testing of Boolean functions of the form f : {0,1}^n -> {0,1}: - Tolerant k-junta testing with non-adaptive queries requires Omega~(k^2) queries. - Tolerant unateness testing requires Omega~(n) queries. - Tolerant unateness testing with non-adaptive queries requires Omega~(n^{3/2}) queries. Given the O~(k^{3/2})-query non-adaptive junta tester of Blais [Eric Blais, 2008], we conclude that non-adaptive tolerant junta testing requires more queries than non-tolerant junta testing. In addition, given the O~(n^{3/4})-query unateness tester of Chen, Waingarten, and Xie [Xi Chen et al., 2017] and the O~(n)-query non-adaptive unateness tester of Baleshzar, Chakrabarty, Pallavoor, Raskhodnikova, and Seshadhri [Roksana Baleshzar et al., 2017], we conclude that tolerant unateness testing requires more queries than non-tolerant unateness testing, in both adaptive and non-adaptive settings. These lower bounds provide the first separation between tolerant and non-tolerant testing for a natural property of Boolean functions

On the Composition of Randomized Query Complexity and Approximate Degree

For any Boolean functions $f$ and $g$, the question whether $R(f\circ g) = \tilde{\Theta}(R(f)R(g))$, is known as the composition question for the randomized query complexity. Similarly, the composition question for the approximate degree asks whether $\widetilde{deg}(f\circ g) = \tilde{\Theta}(\widetilde{deg}(f)\cdot\widetilde{deg}(g))$. These questions are two of the most important and well-studied problems, and yet we are far from answering them satisfactorily. It is known that the measures compose if one assumes various properties of the outer function $f$ (or inner function $g$). This paper extends the class of outer functions for which $\text{R}$ and $\widetilde{\text{deg}}$ compose. A recent landmark result (Ben-David and Blais, 2020) showed that $R(f \circ g) = \Omega(noisyR(f)\cdot R(g))$. This implies that composition holds whenever noisyR(f) = \Tilde{\Theta}(R(f)). We show two results: (1)When $R(f) = \Theta(n)$, then $noisyR(f) = \Theta(R(f))$. (2) If $\text{R}$ composes with respect to an outer function, then $\text{noisyR}$ also composes with respect to the same outer function. On the other hand, no result of the type $\widetilde{deg}(f \circ g) = \Omega(M(f) \cdot \widetilde{deg}(g))$ (for some non-trivial complexity measure $M(\cdot)$) was known to the best of our knowledge. We prove that $\widetilde{deg}(f\circ g) = \widetilde{\Omega}(\sqrt{bs(f)} \cdot \widetilde{deg}(g)),$ where $bs(f)$ is the block sensitivity of $f$. This implies that $\widetilde{\text{deg}}$ composes when $\widetilde{\text{deg}}(f)$ is asymptotically equal to $\sqrt{\text{bs}(f)}$. It is already known that both $\text{R}$ and $\widetilde{\text{deg}}$ compose when the outer function is symmetric. We also extend these results to weaker notions of symmetry with respect to the outer function

Testing Submodularity

We show that for any constants $\epsilon > 0$ and $p \ge 1$, given oracle access to an unknown function $f : \{0,1\}^n \to [0,1]$ it is possible to determine if the function is submodular or is $\epsilon$-far from every submodular function, in $\ell_p$ distance, with a \emph{constant} number of queries to the oracle. We refer to the process of determining if an unknown function has a property, or is far from every function having the property, as \emph{property testing}, and we refer to the algorithm that does that as a tester or a testing algorithm. A function $f : \{0,1\}^n \to [0,1]$ is a \emph{$k$-junta} if there is a set $J \subseteq [n]$ of cardinality $|J| \le k$ such that the value of $f$ on any input $x$ is completely determined by the values $x_i$ for $i \in J$. For any constant $\epsilon > 0$ and a set of $k$-juntas $\mathcal{F}$, we give an algorithm which determines if an unknown function $f : \{0,1\}^n \to [0,1]$ is $\frac{\epsilon}{10^6}$-close to some function in $\mathcal{F}$ or is $\epsilon$-far from every function in $\mathcal{F}$, in $\ell_2$ distance, with a constant number of queries to the unknown function. This result, combined with a recent junta theorem of Feldman and \Vondrak (2016) in which they show every submodular function is $\epsilon$-close, in $\ell_2$ distance, to another submodular function which is a $\tilde{O}(\frac{1}{\epsilon^2})$-junta, yields the constant-query testing algorithm for submodular functions. We also give constant-query testing algorithms for a variety of other natural properties of valuation functions, including fractionally additive (XOS) functions, OXS functions, unit demand functions, coverage functions, and self-bounding functions

On Tolerant Testing and Tolerant Junta Testing

Over the past few decades property testing has became an active field of study in theoretical computer science. The algorithmic task is to determine, given access to an unknown large object (e.g., function, graph, probability distribution), whether it has some fixed property, or it is far from any object having the property. The approximate nature of these algorithms allows in many cases to achieve a significant saving in running time, and obtain \emph{sublinear} running time. Nevertheless, in various settings and applications, accepting only inputs that exactly have a certain property is too restrictive, and it is more beneficial to distinguish between inputs that are close to having the property, and those that are far from it. The framework of \emph{tolerant} testing tackles this exact problem. In this thesis, we will focus on one of the most fundamental properties of Boolean functions: the property of being a \emph{$k$-junta} (i.e., being dependent on at most $k$ variables). The first chapter focuses on algorithms for tolerant junta testing. In particular, we show that there exists a \poly(k) query algorithm distinguishing functions close to $k$-juntas and functions that are far from $2k$-juntas. We also show how to obtain a trade-off between the ``tolerance" of the algorithm and its query complexity. The second chapter focuses on establishing a query lower bound for tolerant junta testing. In particular, we show that any non-adaptive tolerant junta tester, is required to make at least \Omega(k^2/\polylog k) queries. The third chapter considers tolerant testing in a more general context, and asks whether tolerant testing is strictly harder than standard testing. In particular, we show that for any constant $\ell\in \N$, there exists a property \calP_\ell such that \calP_\ell can be tested in $O(1)$ queries, but any tolerant tester for \calP_\ell is required to make at least $\Omega(n/\log^{(\ell)}n)$ queries (where $\log^{(\ell)}$ denote the $\ell$ times iterated log function). The final chapter focuses on applications. We show how to leverage the techniques developed in previous chapters to obtain results on tolerant isomorphism testing, unateness testing, and erasure resilient testing