Testing by Implicit Learning (survey)

by Rocco Servedio.

Oded's comments

I am fascinated by the implicit learning paradigm, which is pivoted on emulating a learning algorithms for $k$-variable functions by using $n$-bit long samples with $k$ influential variables. The emulation proceeds by randomly partitioning the variables to $O(k^2)$ sets, identifying $k$ sets that are likely to each contain a single influential variable, and converting the $n$-bit long samples to corresponding $k$-bit samples. Specifically, each $n$-bit sample is convereted by determining for each influential set whether the subset of variables labeled 1 or the subset labeled 0 is influential, and seting the corresponding bit accordingly. Once the learning algorithm outputs a hypothesis for the $k$-bit function, it is tested using adequate queries (which are again emulated correspondingly).

The original abstract

We describe a a general approach to testing classes of Boolean functions. The method extends the early observation of Goldreich, Goldwasser and Ron that any proper learning algorithm can be used as a testing algorithm. This observation by itself does not typically give rise to constant-query (independent of n, the number of input variables) testing algorithms because virtually every interesting class of n-variable functions requires a superconstant (as a function of n) number of examples for proper learning. Our "implicit learning" approach works essentially by running a proper learning algorithm over k-dimensional examples where k is a function independent of n. The learning is "implicit" because the testing algorithm never actually knows which k of the n input variables are the ones that are being used for learning; this is accomplished using ingredients from the junta test of Fischer et al.

Our approach can be used to test whether a Boolean function on n input variables has a "concise representation" in several different senses. Specifically, we obtain property testers that make poly(s/\epsilon) queries (independent of n) for Boolean function classes such as s-term DNF formulas (answering a question posed by Parnas et al.), size-s decision trees, size-s Boolean formulas, and size-s Boolean circuits. The method extends to classes of Boolean functions that have sparse Fourier representations, and also to non-Boolean classes such as s-sparse polynomials, size-s algebraic circuits, and size-s algebraic computation trees over finite fields of bounded size.

While the algorithms obtained by our approach typically have poly(s) query complexity, their running time is usually exponential in s because of a brute-force search that is used to do the learning. We have been able to achieve a better running time of poly(s) for the class of s-sparse GF(2) polynomials, using more sophisticated computationally efficient algorithms from learning theory for learning s-sparse GF(2) polynomials.

Relevant papers can be found at


Back to list of Oded's choices.