We study the problem of testing isomorphism (equivalence up to relabelling of the variables) of two Boolean functions f, g: {0, 1} n → {0, 1}. Our main focus is on the most studied case, where one of the functions is given (explicitly) and the other function may be queried. We prove that for every k ≤ n, the worst-case query complexity of testing isomorphism to a given k-junta is Ω(k) and O(k log k). Consequently, the query complexity of testing function isomorphism is e Θ(n). Prior to this work, only lower bounds of Ω(log k) queries were known, for limited ranges of k, proved by Fischer et al. (FOCS 2002), Blais and O’Donnell (CCC 2010), and recently by Alon and Blais (RANDOM 2010). The nearly tight O(k log k) upper bound improves on the e O(k 4) upper bound from Fischer et al. (FOCS 2002). Extending the lower bound proof, we also show polynomial query-complexity lower bounds for the problems of testing whether a function can be computed by a circuit of size ≤ s, and testing whether the Fourier degree of a function is ≤ d. This answers questions posed by Diakonikolas et al. (FOCS 2007). We also address two closely related problems – 1. Testing isomorphism to a k-junta with one-sided error: we prove that for any 1 < k < n − 1, the query complexity is Ω(log ` ´ n), which is almost optimal. This

Abstract. In property testing a small, random sample of an object is taken and one wishes to distinguish with high probability between the case where it has a desired property and the case where it is far from having the property. Much of the recent work has focused on graphs. In the present paper three generalized models for testing relational structures are introduced and relationships between these variations are shown. Furthermore, the logical classification problem for testability is considered and, as the main result, it is shown that Ackermann’s class with equality is testable. Key words: property testing, logic 1

We initiate the study of the tradeoff between the length of a probabilistically checkable proof of proximity (PCPP) and the maximal soundness that can be guaranteed by a 3-query verifier with oracle access to the proof. Our main observation is that a verifier limited to querying a short proof cannot obtain the same soundness as that obtained by a verifier querying a long proof. Moreover, we quantify the soundness deficiency as a function of the proof-length and show that any verifier obtaining “best possible” soundness must query an exponentially long proof. In terms of techniques, we focus on the special class of inspective verifiers that read at most 2 proof-bits per invocation. For such verifiers we prove exponential length-soundness tradeoffs that are later on used to imply our main results for the case of general (i.e., not necessarily inspective) verifiers. To prove the exponential tradeoff for inspective verifiers we show a connection between PCPP proof length and property-testing query complexity, that may be of independent interest. The connection is that any linear property that can be verified with proofs of length ℓ by linear inspective verifiers must be testable with query complexity ≈ log ℓ.

ABSTRACT. 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 f: [n] → [m]. Here the probability P f (j) of an outcome j ∈ [m] is the fraction of its domain that f maps to j. We give quantum algorithms for testing whether two such distributions are identical or ɛ-far in L1-norm. Recently, Bravyi, Hassidim, and Harrow [11] showed that if P f and Pg are both unknown (i.e., given by oracles f and g), then this testing can be done in roughly √ m quantum queries to the functions. We consider the case where the second distribution is known, and show that testing can be done with roughly m 1/3 quantum queries, which we prove to be essentially optimal. In contrast, it is known that classical testing algorithms need about m 2/3 queries in the unknown-unknown case and about √ m 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 [30]. This provides an alternative to a recent constant-vs-polynomial speed-up due to Aaronson [1].

One of the motivations for property testing of boolean functions is the idea that testing can serve as a preprocessing step before learning. However, in most machine learning applications, the ability to query functions at arbitrary points in the input space is considered highly unrealistic. Instead, the dominant query paradigm in applied machine learning has been that of active learning, where the algorithm may ask for examples to be labeled, but only from among those that exist in nature. That is, the algorithm may make a polynomial number of draws from the underlying distribution D and then query for labels, but only of points in its sample. In this work, we bring this well-studied model in learning to the domain of testing. We show that for a number of important properties for learning, testing can still yield substantial benefits in this setting. This includes testing whether data satisfies the “cluster assumption”, testing linear separators, testing the large-margin assumption in low-dimensional spaces, and testing unions of intervals. In most of these cases, we show active testing requires substantially fewer label requests than passive testing (where the algorithm must pay for labels on every example drawn from D), or active or passive learning. For example, testing the cluster assumption can be done with O(1) label requests using active testing, but requires Ω ( √ N) labeled examples for passive testing and Ω(N) for learning, where N is the number of clusters; a similar pattern holds for unions of