1,743 research outputs found
New Results on Quantum Property Testing
We present several new examples of speed-ups obtainable by quantum algorithms
in the context of property testing. First, motivated by sampling algorithms, we
consider probability distributions given in the form of an oracle
. Here the probability \PP_f(j) of an outcome is the
fraction of its domain that maps to . We give quantum algorithms for
testing whether two such distributions are identical or -far in
-norm. Recently, Bravyi, Hassidim, and Harrow \cite{BHH10} showed that if
\PP_f and \PP_g are both unknown (i.e., given by oracles and ), then
this testing can be done in roughly quantum queries to the
functions. We consider the case where the second distribution is known, and
show that testing can be done with roughly quantum queries, which we
prove to be essentially optimal. In contrast, it is known that classical
testing algorithms need about queries in the unknown-unknown case and
about queries in the known-unknown case. Based on this result, we
also reduce the query complexity of graph isomorphism testers with quantum
oracle access. While those examples provide polynomial quantum speed-ups, our
third example gives a much larger improvement (constant quantum queries vs
polynomial classical queries) for the problem of testing periodicity, based on
Shor's algorithm and a modification of a classical lower bound by Lachish and
Newman \cite{lachish&newman:periodicity}. This provides an alternative to a
recent constant-vs-polynomial speed-up due to Aaronson \cite{aaronson:bqpph}.Comment: 2nd version: updated some references, in particular to Aaronson's
Fourier checking proble
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
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
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
- …