22,832 research outputs found

    Quantum Algorithms for Learning and Testing Juntas

    Full text link
    In this article we develop quantum algorithms for learning and testing juntas, i.e. Boolean functions which depend only on an unknown set of k out of n input variables. Our aim is to develop efficient algorithms: - whose sample complexity has no dependence on n, the dimension of the domain the Boolean functions are defined over; - with no access to any classical or quantum membership ("black-box") queries. Instead, our algorithms use only classical examples generated uniformly at random and fixed quantum superpositions of such classical examples; - which require only a few quantum examples but possibly many classical random examples (which are considered quite "cheap" relative to quantum examples). Our quantum algorithms are based on a subroutine FS which enables sampling according to the Fourier spectrum of f; the FS subroutine was used in earlier work of Bshouty and Jackson on quantum learning. Our results are as follows: - We give an algorithm for testing k-juntas to accuracy ϵ\epsilon that uses O(k/ϵ)O(k/\epsilon) quantum examples. This improves on the number of examples used by the best known classical algorithm. - We establish the following lower bound: any FS-based k-junta testing algorithm requires Ω(k)\Omega(\sqrt{k}) queries. - We give an algorithm for learning kk-juntas to accuracy ϵ\epsilon that uses O(ϵ1klogk)O(\epsilon^{-1} k\log k) quantum examples and O(2klog(1/ϵ))O(2^k \log(1/\epsilon)) random examples. We show that this learning algorithms is close to optimal by giving a related lower bound.Comment: 15 pages, 1 figure. Uses synttree package. To appear in Quantum Information Processin

    Testing and Learning Quantum Juntas Nearly Optimally

    Full text link
    We consider the problem of testing and learning quantum kk-juntas: nn-qubit unitary matrices which act non-trivially on just kk of the nn qubits and as the identity on the rest. As our main algorithmic results, we give (a) a O~(k)\widetilde{O}(\sqrt{k})-query quantum algorithm that can distinguish quantum kk-juntas from unitary matrices that are "far" from every quantum kk-junta; and (b) a O(4k)O(4^k)-query algorithm to learn quantum kk-juntas. We complement our upper bounds for testing quantum kk-juntas and learning quantum kk-juntas with near-matching lower bounds of Ω(k)\Omega(\sqrt{k}) and Ω(4kk)\Omega(\frac{4^k}{k}), respectively. Our techniques are Fourier-analytic and make use of a notion of influence of qubits on unitaries

    Adaptivity Helps for Testing Juntas

    Get PDF
    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

    Partially Symmetric Functions are Efficiently Isomorphism-Testable

    Full text link
    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

    Property testing of unitary operators

    Full text link
    In this paper, we systematically study property testing of unitary operators. We first introduce a distance measure that reflects the average difference between unitary operators. Then we show that, with respect to this distance measure, the orthogonal group, quantum juntas (i.e. unitary operators that only nontrivially act on a few qubits of the system) and Clifford group can be all efficiently tested. In fact, their testing algorithms have query complexities independent of the system's size and have only one-sided error. Then we give an algorithm that tests any finite subset of the unitary group, and demonstrate an application of this algorithm to the permutation group. This algorithm also has one-sided error and polynomial query complexity, but it is unknown whether it can be efficiently implemented in general

    On active and passive testing

    Full text link
    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

    New Lower Bounds for Adaptive Tolerant Junta Testing

    Full text link
    We prove a kΩ(log(ε2ε1))k^{-\Omega(\log(\varepsilon_2 - \varepsilon_1))} lower bound for adaptively testing whether a Boolean function is ε1\varepsilon_1-close to or ε2\varepsilon_2-far from kk-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 ε1\varepsilon_1-close to a kk-junta or ε2\varepsilon_2-far from (k+o(k))(k + o(k))-juntas cannot be done with poly(k,(ε2ε1)1)\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 poly(k,(ε2ε1)1)\textsf{poly} (k, (\varepsilon_2 - \varepsilon_1)^{-1}) queries to test whether a function is ε1\varepsilon_1-close to a kk-junta or ε2\varepsilon_2-far from O(k/(ε2ε1)2)O(k/(\varepsilon_2-\varepsilon_1)^2)-juntas.Comment: 22 page

    Junta Distance Approximation with Sub-Exponential Queries

    Get PDF
    Leveraging tools of De, Mossel, and Neeman [FOCS, 2019], we show two different results pertaining to the \emph{tolerant testing} of juntas. Given black-box access to a Boolean function f:{±1}n{±1}f:\{\pm1\}^{n} \to \{\pm1\}, we give a poly(k,1ε)poly(k, \frac{1}{\varepsilon}) query algorithm that distinguishes between functions that are γ\gamma-close to kk-juntas and (γ+ε)(\gamma+\varepsilon)-far from kk'-juntas, where k=O(kε2)k' = O(\frac{k}{\varepsilon^2}). In the non-relaxed setting, we extend our ideas to give a 2O~(k/ε)2^{\tilde{O}(\sqrt{k/\varepsilon})} (adaptive) query algorithm that distinguishes between functions that are γ\gamma-close to kk-juntas and (γ+ε)(\gamma+\varepsilon)-far from kk-juntas. To the best of our knowledge, this is the first subexponential-in-kk query algorithm for approximating the distance of ff to being a kk-junta (previous results of Blais, Canonne, Eden, Levi, and Ron [SODA, 2018] and De, Mossel, and Neeman [FOCS, 2019] required exponentially many queries in kk). Our techniques are Fourier analytical and make use of the notion of "normalized influences" that was introduced by Talagrand [AoP, 1994].Comment: To appear in CCC 202
    corecore