In this paper we define and examine the power of the conditional-sampling oracle in the context of distribution-property testing. The conditional-sampling oracle for a discrete distribution $\mu$ takes as input a subset $S \subset [n]$ of the domain, and outputs a random sample $i \in S$ drawn according to $\mu$, conditioned on $S$ (and independently of all prior samples). The conditional-sampling oracle is a natural generalization of the ordinary sampling oracle, in which $S$ always equals $[n]$. We show that with the conditional-sampling oracle, testing uniformity, testing identity to a known distribution, and testing any label-invariant property of distributions is easier than with the ordinary sampling oracle. On the other hand, we also show that for some distribution properties the sample-complexity remains near-maximal even with conditional sampling.

In this paper we define and examine the power of the conditional sampling oracle in the context of distribution-property testing. The conditional sampling oracle for a discrete distribution μ takes as input a subset S ⊂ [n] of the domain, and outputs a random sample i ∈ S drawn according to μ, conditioned on S (and independently of all prior samples). The conditional-sampling oracle is a natural generalization of the ordinary sampling oracle in which S always equals [n]. We show that with the conditional-sampling oracle, testing uniformity, testing identity to a known distribution, and testing any label-invariant property of distributions is easier than with the ordinary sampling oracle. On the other hand, we also show that for some distribution properties the sample complexity remains near-maximal even with conditional sampling.

We study the problem of testing isomorphism (equivalence up to relabeling of the input variables) between Boolean functions. We prove the following: (1) For most functions $f:\{0,1\}^n \to \{0,1\}$, the query complexity of testing isomorphism to $f$ is $\Omega(n)$. Moreover, the query complexity of testing isomorphism to most $k$-juntas $f:\{0,1\}^n \to \{0,1\}$ is $\Omega(k)$. (2) Isomorphism to any $k$-junta $f:\{0,1\}^n \to \{0,1\}$ can be tested with $O(k \log k)$ queries. (3) For some $k$-juntas $f:\{0,1\}^n \to \{0,1\}$, testing isomorphism to $f$ with one-sided error requires $\Omega(k\log(n/k))$ queries. In particular, testing whether $f:\{0,1\}^n \to \{0,1\}$ is a $k$-parity with one-sided error requires $\Omega(k\log(n/k))$ queries. (4) The query complexity of testing isomorphism between two unknown functions $f,g:\{0,1\}^n \to \{0,1\}$ is $\widetilde{\Theta}(2^{n/2})$. These bounds are tight up to logarithmic factors, and they significantly strengthen the bounds proved by Fischer, Kindler, Ron, Safra, and Samorodnitsky [J. Comput. System Sci., 68 (2004), pp. 753--787] and Blais and O'Donnell [Proceedings of the IEEE Conference on Computational Complexity, 2010, pp. 235--246]. We also obtain results closely related to isomorphism testing, answering a question posed by Diakonikolas, Lee, Matulef, Onak, Rubinfeld, Servedio, and Wan [Proceedings of the IEEE Symposium on Foundations of Computer Science, 2007, pp. 549--558]: testing whether a function $f:\{0,1\}^n \to \{0,1\}$ can be computed by a circuit of size $\le s$ requires $s^{\Omega(1)}$ queries. All of our lower bounds apply to general (adaptive) testers.

We make a step towards characterizing the boolean functions to which isomorphism can be efficiently tested. Specifically, we prove that isomorphism to any boolean function on {0, 1}nwith a polynomial number of distinct permutations can be tested with a number of queries that is independent of n. We also show some partial results in the converse direction, and discuss related problems: testing isomorphism up to linear transformations, and testing isomorphism against a uniform (hyper)graph that is given in advance. Our results regarding the latter topic generalize a theorem of Fischer (SICOMP 2005), and in the process we also provide a simpler proof of his original result which avoids the use of Szemeredi's regularity lemma.

We consider testing directed graphs Eulerianity in the orientation model introduced in Halevy et al. [2005]. Despite the local nature of the Eulerian property, it turns out to be significantly harder to test than other properties studied in the orientation model. We show a nonconstant lower bound on the query complexity of 2-sided tests and a linear lower bound on the query complexity of 1-sided tests for this property. On the positive side, we give several 1-sided and 2-sided tests, including a sublinear query complexity 2-sided test, for general graphs. For special classes of graphs, including bounded-degree graphs and expander graphs, we provide improved results. In particular, we give a 2-sided test with constant query complexity for dense graphs, as well as for expander graphs with a constant expansion parameter.

Many relational operations are best performed when the relations are stored sorted over the relevant attributes (e.g. the common attributes in a natural join operation). However, generally relations are not stored sorted because it is expensive to maintain them this way (and impossible whenever there is more than one relevant sort key). Still, many times relations turn out to be nearly-sorted, where most tuples are close to their place in the order. This state can result from "leftover sortedness", where originally sorted relations were updated, or were combined into interim results when evaluating a complex query. It can also result from weak correlations between attribute values. Currently, nearly-sorted relations are treated the same as unsorted relations, and when relational operations are evaluated for them, a generic algorithm is used. Yet, many operations can be computed more efficiently by an algorithm that exploits this near-ordering.

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 . 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 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 , which is almost optimal. This lower bound is a consequence of a proof that the query complexity of testing, with one-sided error, whether a function is a k-parity is . 2. Testing isomorphism between two unknown functions that can be queried: we prove that the query complexity in this setting is and

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]\to[m]$. Here the probability $P_f(j)$ of an outcome $j$ in $[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 $epsilon$-far in $L_1$-norm. Recently, Bravyi, Hassidim, and Harrow showed that if $P_f$ and $P_g$ are both unknown (i.e., given by oracles $f$ and $g$), then this testing can be done in roughly $sqrt{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 $sqrt{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. This provides an alternative to a recent constant-vs-polynomial speed-up due to Aaronson.

Szemerédi's regularity lemma is a cornerstone result in extremal combinatorics. It (roughly) asserts that any dense graph is composed of a finite number of pseudorandom graphs. The regularity lemma has found many applications in theoretical computer science, and thus a lot of attention was given to designing algorithmic versions of this lemma. Our main results in this paper are the following: (i) We introduce a new approach to the problem of constructing regular partitions of graphs, which results in a surprisingly simple $O(n)$ time algorithmic version of the regularity lemma, thus improving over the previous $O(n^2)$ time algorithms. Furthermore, unlike all the previous approaches for this problem (see [N. Alon and A. Naor, SIAM J. Comput., 35 (2006), pp. 787–803], [R. A. Duke, H. Lefmann, and V. Rödl, SIAM J. Comput., 24 (1995), pp. 598–620], [A. Frieze and R. Kannan, Electron. J. Combin., 6 (1999), article 17], [A. Frieze and R. Kannan, “The regularity lemma and approximation schemes for dense problems,” in Proceedings of the 37th Annual Symposium on Foundations of Computer Science (Burlington, VT, 1996), IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 12–20], and [Y. Kohayakawa, V. Rödl, and L. Thoma, SIAM J. Comput., 32 (2003), pp. 1210–1235]), which only guaranteed to find tower-size partitions, our algorithm will find a small regular partition, if one exists in the graph. (ii) For any constant $r\geq3$ we give an $O(n)$ time randomized algorithm for constructing regular partitions of r-uniform hypergraphs, thus improving the previous $O(n^{2r-1})$ time (deterministic) algorithms [A. Czygrinow and V. Rödl, SIAM J. Comput., 30 (2000), pp. 1041–1066], [A. Frieze and R. Kannan, “The regularity lemma and approximation schemes for dense problems,” in Proceedings of the 37th Annual Symposium on Foundations of Computer Science (Burlington, VT, 1996), IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 12–20]. These two results are obtained as an application of an efficient algorithm for approximating partition problems of hypergraphs which we obtain here: Given a (directed) hypergraph with bounded edge arities, a set of constraints on the set sizes and densities of a possible partition of its vertex set, and an approximation parameter, we provide in $O(n)$ time a partition approximating the constraints if a partition satisfying them exists. We can also test in $O(1)$ time for the existence of such a partition given the approximation parameter. This algorithm extends the result of Goldreich, Goldwasser, and Ron for graph partition problems [O. Goldreich, S. Goldwasser, and D. Ron, J. ACM, 45 (1998), pp. 653–750] and encompasses more recent hypergraph-related results such as the maximal constraint satisfaction approximation of [G. Andersson and L. Engebretsen, Random Structures Algorithms, 21 (2002), pp. 14–32].

An edge-colored graph $G$ is {\em rainbow connected} if any two vertices are connected by a path whose edges have distinct colors. The {\em rainbow connectivity} of a connected graph $G$, denoted $rc(G)$, is the smallest number of colors that are needed in order to make $G$ rainbow connected. In addition to being a natural combinatorial problem, the rainbow connectivity problem is motivated by applications in cellular networks. In this paper we give the first proof that computing $rc(G)$ is NP-Hard. In fact, we prove that it is already NP-Complete to decide if $rc(G)=2$, and also that it is NP-Complete to decide whether a given edge-colored (with an unbounded number of colors) graph is rainbow connected. On the positive side, we prove that for every $\epsilon >0$, a connected graph with minimum degree at least $\epsilon n$ has bounded rainbow connectivity, where the bound depends only on $\epsilon$, and the corresponding coloring can be constructed in polynomial time. Additional non-trivial upper bounds, as well as open problems and conjectures are also presented.

Two graphs G and H on n vertices are $\epsilon$-far from being isomorphic if at least $\epsilon\binom{n}{2}$ edges must be added or removed from $E(G)$ in order to make G and H isomorphic. In this paper we deal with the question of how many queries are required to distinguish between the case that two graphs are isomorphic and the case that they are $\epsilon$-far from being isomorphic. A query is defined as probing the adjacency matrix of any one of the two graphs, i.e., asking if a pair of vertices forms an edge of the graph or not. We investigate both one-sided and two-sided error testers under two possible settings: The first setting is where both graphs need to be queried, and the second setting is where one of the graphs is fully known to the algorithm in advance. We prove that the query complexity of the best one-sided error testing algorithm is $\widetilde{\Theta}(n^{3/2})$ if both graphs need to be queried, and that it is $\widetilde{\Theta}(n)$ if one of the graphs is known in advance (where the $\widetilde{\Theta}$ notation hides polylogarithmic factors in the upper bounds). For two-sided error testers, we prove that the query complexity of the best tester is $\widetilde{\Theta}(\sqrt{n})$ when one of the graphs is known in advance, and we show that the query complexity lies between $\Omega(n)$ and $\widetilde{O}(n^{5/4})$ if both G and H need to be queried. All of our algorithms are additionally nonadaptive, while all of our lower bounds apply for adaptive testers as well as nonadaptive ones.

We show that any partition-problem of hypergraphs has an O(n) time approximate partitioning algorithm and an efficient property tester. This extends the results of Goldreich, Goldwasser and Ron who obtained similar algorithms for the special case of graph partition problems in their seminal paper (1998). The partitioning algorithm is used to obtain the following results: ldr We derive a surprisingly simple O(n) time algorithmic version of Szemeredi's regularity lemma. Unlike all the previous approaches for this problem which only guaranteed to find partitions of tower-size, our algorithm will find a small regular partition in the case that one exists; ldr For any r ges 3, we give an O(n) time randomized algorithm for constructing regular partitions of r-uniform hypergraphs, thus improving the previous O(n2r-1) time (deterministic) algorithms. The property testing algorithm is used to unify several previous results, and to obtain the partition densities for the above problems (rather than the partitions themselves) using only poly(1/isin) queries and constant running time.