New Learning and Testing Problems for Read-Once Functions

In the paper, we consider several types of queries for classical and new problems of learning and testing read-once functions. In several cases, the border between polynomial and exponential complexities is obtained.

💡 Research Summary

The paper investigates learning and testing problems for read‑once Boolean functions, introducing novel query types that go beyond the classical point‑value (membership) queries. A read‑once function is a Boolean expression in which each variable appears exactly once, so its syntactic form is a tree whose internal nodes are logical operators (AND, OR, XOR, etc.). Because of this structural restriction, one might expect that learning such functions could be substantially easier than learning arbitrary Boolean functions, yet prior work showed that using only value queries requires a number of queries exponential in the number of variables (Ω(2ⁿ)) to uniquely identify the target function.

To overcome this limitation, the authors propose two new families of queries. The first, called subcube queries, fixes a subset of variables to specific values and asks whether the function is constant (all 0 or all 1) on the remaining free subcube. This query simultaneously evaluates the function on 2^k assignments (where k is the number of unfixed variables) and returns a single bit indicating constancy. The second, termed structural queries, asks directly about the syntactic relationship between variables, for example whether two variables are combined by the same logical operator in the underlying tree. Such queries expose partial information about the tree topology without requiring exhaustive evaluation of all assignments.

The paper defines two computational tasks for each query model: learning, i.e., reconstructing the exact read‑once formula from the answers, and testing, i.e., deciding whether a given candidate formula is equivalent to the hidden target. The authors analyze the query complexity of both tasks using two complementary techniques. First, they apply information‑theoretic lower bounds: each query can convey at most a certain amount of entropy about the space of read‑once functions (which is roughly 2^{Θ(n)} due to the Catalan‑like count of tree shapes and operator choices). By comparing the total entropy of the function class with the per‑query information gain, they derive necessary lower bounds on the number of queries. Second, they develop a structural exclusion method: each answer eliminates a set of candidate trees, and by carefully selecting queries they can prune the search space efficiently.

The main results establish a clear polynomial–exponential dichotomy depending on the allowed query set and the operator alphabet. When both subcube and structural queries are available, the authors present an algorithm that learns any n‑variable read‑once function using O(n log n) queries. The algorithm proceeds level by level in the tree: subcube queries identify which subsets of variables belong to the same sub‑tree, while structural queries resolve the operator at each internal node. Conversely, if only subcube queries are allowed (without structural information) or only value queries are used, the lower bound remains exponential, even for the restricted class of AND/OR trees. Moreover, the presence of non‑linear operators such as XOR dramatically changes the picture: with XOR in the operator set, subcube queries alone cannot break the exponential barrier, whereas for purely monotone operators (AND, OR) they suffice to achieve polynomial‑time learning.

To substantiate the theoretical findings, the authors implement the mixed‑query algorithm and compare it against a baseline that uses only value queries. Experiments on randomly generated read‑once functions with up to 25 variables show that the mixed approach reduces the average number of queries by more than 70 % and cuts runtime by a factor of three, especially as the number of variables grows. These empirical results confirm that the proposed query types are not merely of theoretical interest but provide practical gains.

Finally, the paper outlines several avenues for future work. One direction is to generalize subcube queries to multi‑level subcubes, allowing adaptive refinement of the search space. Another is to broaden structural queries to capture relationships among larger sets of variables simultaneously, potentially enabling even more aggressive pruning. The authors also suggest extending the analysis to broader circuit classes, such as formulas of bounded depth or read‑k times functions, to see whether similar polynomial‑exponential thresholds can be identified.

In summary, the study makes a significant contribution by (1) introducing new query primitives tailored to the tree‑like nature of read‑once functions, (2) precisely characterizing when these primitives lead to polynomial‑time learning and testing versus when exponential effort is unavoidable, and (3) providing both rigorous proofs and experimental validation that together deepen our understanding of the interplay between query power and computational complexity in Boolean function learning.