10 research outputs found
Local Correction of Juntas
A Boolean function f over n variables is said to be q-locally correctable if,
given a black-box access to a function g which is "close" to an isomorphism
f_sigma of f, we can compute f_sigma(x) for any x in Z_2^n with good
probability using q queries to g.
We observe that any k-junta, that is, any function which depends only on k of
its input variables, is O(2^k)-locally correctable. Moreover, we show that
there are examples where this is essentially best possible, and locally
correcting some k-juntas requires a number of queries which is exponential in
k. These examples, however, are far from being typical, and indeed we prove
that for almost every k-junta, O(k log k) queries suffice.Comment: 6 page
Partially Symmetric Functions are Efficiently Isomorphism-Testable
Given a function f: {0,1}^n \to {0,1}, the f-isomorphism testing problem
requires a randomized algorithm to distinguish functions that are identical to
f up to relabeling of the input variables from functions that are far from
being so. An important open question in property testing is to determine for
which functions f we can test f-isomorphism with a constant number of queries.
Despite much recent attention to this question, essentially only two classes of
functions were known to be efficiently isomorphism testable: symmetric
functions and juntas.
We unify and extend these results by showing that all partially symmetric
functions---functions invariant to the reordering of all but a constant number
of their variables---are efficiently isomorphism-testable. This class of
functions, first introduced by Shannon, includes symmetric functions, juntas,
and many other functions as well. We conjecture that these functions are
essentially the only functions efficiently isomorphism-testable.
To prove our main result, we also show that partial symmetry is efficiently
testable. In turn, to prove this result we had to revisit the junta testing
problem. We provide a new proof of correctness of the nearly-optimal junta
tester. Our new proof replaces the Fourier machinery of the original proof with
a purely combinatorial argument that exploits the connection between sets of
variables with low influence and intersecting families.
Another important ingredient in our proofs is a new notion of symmetric
influence. We use this measure of influence to prove that partial symmetry is
efficiently testable and also to construct an efficient sample extractor for
partially symmetric functions. We then combine the sample extractor with the
testing-by-implicit-learning approach to complete the proof that partially
symmetric functions are efficiently isomorphism-testable.Comment: 22 page
Partially Symmetric Functions Are Efficiently Isomorphism Testable
Given a Boolean function f, the f-isomorphism testing problem requires a randomized algorithm to distinguish functions that are identical to f up to relabeling of the input variables from functions that are far from being so. An important open question in property testing is to determine for which functions f we can test f-isomorphism with a constant number of queries. Despite much recent attention to this question, essentially only two classes of functions were known to be efficiently isomorphism testable: symmetric functions and juntas. We unify and extend these results by showing that all partially symmetric functions---functions invariant to the reordering of all but a constant number of their variables---are efficiently isomorphism testable. This class of functions, first introduced by Shannon, includes symmetric functions, juntas, and many other functions as well. We conjecture that these functions are essentially the only functions efficiently isomorphism-testable. To prove our main result, we also show that partial symmetry is efficiently testable. In turn, to prove this result we had to revisit the junta testing problem. We provide a new proof of correctness of the nearly optimal junta tester. Our new proof replaces the Fourier machinery of the original proof with a purely combinatorial argument that exploits the connection between sets of variables with low influence and intersecting families. Another important ingredient in our proofs is a new notion of symmetric influence. We use this measure of influence to prove that partial symmetry is efficiently testable and also to construct an efficient sample extractor for partially symmetric functions. We then combine the sample extractor with the testing-by-implicit-learning approach to complete the proof that partially symmetric functions are efficiently isomorphism testable.Simons Foundation (Postdoctoral Fellowship
A characterization of testable hypergraph properties
We provide a combinatorial characterization of all testable properties of
-graphs (i.e. -uniform hypergraphs). Here, a -graph property
is testable if there is a randomized algorithm which makes a
bounded number of edge queries and distinguishes with probability between
-graphs that satisfy and those that are far from satisfying
. For the -graph case, such a combinatorial characterization was
obtained by Alon, Fischer, Newman and Shapira. Our results for the -graph
setting are in contrast to those of Austin and Tao, who showed that for the
somewhat stronger concept of local repairability, the testability results for
graphs do not extend to the -graph setting.Comment: 82 pages; extended abstract of this paper appears in FOCS 201
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{-junta} (i.e., being dependent on at most 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 -juntas and functions that are far from -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 , there exists a property \calP_\ell such that \calP_\ell can be tested in queries, but any tolerant tester for \calP_\ell is required to make at least queries (where denote the 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
Testing Boolean Function Isomorphism
Abstract. Two boolean functions f, g: {0, 1} n → {0, 1} are isomorphic if they are identical up to relabeling of the input variables. We consider the problem of testing whether two functions are isomorphic or far from being isomorphic with as few queries as possible. In the setting where one of the functions is known in advance, we show that the non-adaptive query complexity of the isomorphism testing problem is ˜ Θ(n). In fact, we show that the lower bound of Ω(n) queries for testing isomorphism to g holds for almost all functions g. In the setting where both functions are unknown to the testing algorithm, we show that the query complexity of the isomorphism testing problem is ˜ Θ(2 n/2). The bound in this result holds for both adaptive and nonadaptive testing algorithms.