Property testing deals with tasks where the goal is to distinguish between the case that an object (e.g., function or graph) has a prespecified property (e.g., the function is linear or the graph is bipartite) and the case that it differs significantly from any such object. The task should be performed by observing only a very small part of the object, in particular by querying the object, and the algorithm is allowed a small failure probability. One view of property testing is as a relaxation of learning the object (obtaining an approximate representation of the object). Thus property testing algorithms can serve as a preliminary step to learning. That is, they can be applied in order to select, very efficiently, what hypothesis class to use for learning. This survey takes the learning-theory point of view and focuses on results for testing properties of functions that are of interest to the learning theory community. In particular, we cover results for testing algebraic properties of functions such as linearity, testing properties defined by concise representations, such as having a small DNF representation, and more. 1

Property testing algorithms are “ultra”-efficient algorithms that decide whether a given object (e.g., a graph) has a certain property (e.g., bipartiteness), or is significantly different from any object that has the property. To this end property testing algorithms are given the ability to perform (local) queries to the input, though the decision they need to make usually concern properties with a global nature. In the last two decades, property testing algorithms have been designed for many types of objects and properties, amongst them, graph properties, algebraic properties, geometric properties, and more. In this article we survey results in property testing, where our emphasis is on common analysis and algorithmic techniques. Among the techniques surveyed are the following: • The self-correcting approach, which was mainly applied in the study of property testing of algebraic properties; • The enforce and test approach, which was applied quite extensively in the analysis of algorithms for testing graph properties (in the dense-graphs model), as well as in other contexts;

In this paper we study the problem of approximating the distance of a function over [n] d to monotonicity. Namely, we are interested in randomized sublinear algorithms that approximate the Hamming distance between a given function and the closest monotone function. Previous work on distance approximation to monotonicity focused on the one-dimensional case and the only extension to higher dimensions was with an approximation factor exponential in the dimension d. Building on work of Dodis et. al. (Proceedings of RANDOM, 1999), we describe a reduction from the case of functions over the d-dimensional hyper-cube to the case of functions over the k-dimensional hyper-cube, where k < d. The quality of estimation that this reduction provides is linear in the size of the dimension and logarithmic in the size of the range |R | (if the range is infinite or just very large, then log |R | can be replaced d log n). Using this reduction and a known distance approximation algorithm for the one dimensional case, we suggest a distance approximation algorithm for functions over the d-dimensional hyper-cube, with any range. For the case of the Boolean range, we present solutions for distance approximation to monotonicity

How well can the maximum size of an independent set, or the minimum size of a dominating set of a graph in which all degrees are at most d be approximated by a randomized constant time algorithm? Motivated by results and questions of Nguyen and Onak, and of Parnas, Ron and Trevisan, we show that the best approximation ratio that can be achieved for the first question (independence number) is between Ω(d / log d) and O(d log log d / log d), whereas the answer to the second (domination number) is (1 + o(1)) ln d. 1

For input x, let F (x) denote the set of outputs that are the “legal ” answers for a computational problem F. Suppose x and members of F (x) are so large that there is not time to read them in their entirety. We propose a model of local computation algorithms which for a given input x, support queries by a user to values of specified locations yi in a legal output y ∈ F (x). When more than one legal output y exists for a given x, the local computation algorithm should output in a way that is consistent with at least one such y. Local computation algorithms are intended to distill the common features of several concepts that have appeared in various algorithmic subfields, including local distributed computation, local algorithms, locally decodable codes, and local reconstruction. We develop a technique, based on Beck’s analysis in his algorithmic approach to the Lovász Local Lemma, which under certain conditions can be applied to construct polylogarithmic time local computation algorithms. We apply this technique to maximal independent set computations, scheduling radio network broadcasts, hypergraph coloring and satisfying k-SAT formulas.

Abstract. Approximations can aim at having close to optimal value or, alternatively, they can aim at structurally resembling an optimal solution. Whereas value-approximation has been extensively studied by complexity theorists over the last three decades, structural-approximation has not yet been defined, let alone studied. However, structuralapproximation is theoretically no less interesting, and has important applications in cognitive science. Building on analogies with existing valueapproximation algorithms and classes, we develop a general framework for analyzing structural (in)approximability. We identify dissociations between solution value and solution structure, and generate a list of open problems that may stimulate future research.

We present a technique for transforming classical approximation algorithms into constant-time algorithms that approximate the size of the optimal solution. Our technique is applicable to a certain subclass of algorithms that compute a solution in a constant number of phases. The technique is based on greedily considering local improvements in random order. The problems amenable to our technique include

Recently Rubinfeld et al. (ICS 2011, pp. 223–238) proposed a new model of sublinear algorithms called local computation algorithms. In this model, a computation problem F may have more than one legal solution and each of them consists of many bits. The local computation algorithm for F should answer in an online fashion, for any index i, the ith bit of some legal solution of F. Further, all the answers given by the algorithm should be consistent with at least one solution of F. In this work, we continue the study of local computation algorithms. In particular, we develop a technique which under certain conditions can be applied to construct local computation algorithms that run not only in polylogarithmic time but also in polylogarithmic space. Moreover, these local computation algorithms are easily parallelizable and can answer all parallel queries consistently. Our main technical tools are pseudorandom numbers with bounded independence and the theory of branching processes.

We deal with the problem of designing one-sided error property testers for cycle-freeness in bounded degree graphs. Such a property tester always accepts forests. Furthermore, when it rejects an input, it provides a short cycle as a certificate. The problem of testing cycle-freeness in this model was first considered by Goldreich and Ron [13]. They give a constant time tester with two-sided error (it does not provide certificates for rejection) and prove a Ω ( √ n) lower bound for testers with one-sided error. We design a property tester with one-sided error whose running time matches this lower bound (upto polylogarithmic factors). Interestingly, this has connections to a recent conjecture of Benjamini, Schramm, and Shapira [3]. The property of cycle-freeness is closed under the operation of taking minors. This is the first example of such a property that has an almost optimal Õ( √ n)-time one-sided error tester, but has a constant time two-sided error tester. It was conjectured in [3] that this happens for a vast class of minor-closed properties, and this result can seen as the first indication towards that. 1