Arrow's Impossibility Theorem states that any constitution which satisfies Independence of Irrelevant Alternatives (IIA) and Unanimity and is not a Dictator has to be non-transitive. In this paper we study quantitative versions of Arrow theorem. Consider @math voters who vote independently at random, each following the uniform distribution over the 6 rankings of 3 alternatives. Arrow's theorem implies that any constitution which satisfies IIA and Unanimity and is not a dictator has a probability of at least @math for a non-transitive outcome. When @math is large, @math is a very small probability, and the question arises if for large number of voters it is possible to avoid paradoxes with probability close to 1. Here we give a negative answer to this question by proving that for every @math , there exists a @math , which depends on @math only, such that for all @math , and all constitutions on 3 alternatives, if the constitution satisfies: The IIA condition. For every pair of alternatives @math , the probability that the constitution ranks @math above @math is at least @math . For every voter @math , the probability that the social choice function agrees with a dictatorship on @math at most @math . Then the probability of a non-transitive outcome is at least @math .
As noted in @cite_5 , there is an interesting connection between quantitative Arrow statements and the concept of testing introduced in @cite_12 @cite_16 which was studied and used extensively since. Roughly speaking a property of functions is testable if it is possible to perform a randomized test for the property such that if the probability that the function passes the test is close to @math , then the function has to be close to a function with the property (say in the hamming distance). In terms of testing, our result states that among all functions satisfying the IIA property, the Transitivity property is testable. Moreover, the natural test "works": i.e., in order to test for transitivity, one can pick a random input and check if the outcome is transitive.
@cite_5 @cite_16 @cite_12
1970630090 2018925011
The field of property testing studies algorithms that distinguish, using a small number of queries, between inputs which satisfy a given property, and those that are far' from satisfying the property. Testing properties that are defined in terms of monotonicity has been extensively investigated, primarily in the context of the monotonicity of a sequence of integers, or the monotonicity of a function over the n-dimensional hypercube 1,l,m n. These works resulted in monotonicity testers whose query complexity is at most polylogarithmic in the size of the domain.We show that in its most general setting, testing that Boolean functions are close to monotone is equivalent, with respect to the number of required queries, to several other testing problems in logic and graph theory. These problems include: testing that a Boolean assignment of variables is close to an assignment that satisfies a specific 2-CNF formula, testing that a set of vertices is close to one that is a vertex cover of a specific graph, and testing that a set of vertices is close to a clique.We then investigate the query complexity of monotonicity testing of both Boolean and integer functions over general partial orders. We give algorithms and lower bounds for the general problem, as well as for some interesting special cases. In proving a general lower bound, we construct graphs with combinatorial properties that may be of independent interest. We continue the study of combinatorial property testing, initiated by Goldreich, Goldwasser, and Ron in [J. ACM, 45 (1998), pp. 653--750]. The subject of this paper is testing regular languages. Our main result is as follows. For a regular language @math and an integer n there exists a randomized algorithm which always accepts a word w of length n if @math and rejects it with high probability if @math has to be modified in at least @math positions to create a word in L. The algorithm queries @math bits of w. This query complexity is shown to be optimal up to a factor polylogarithmic in @math . We also discuss the testability of more complex languages and show, in particular, that the query complexity required for testing context-free languages cannot be bounded by any function of @math . The problem of testing regular languages can be viewed as a part of a very general approach, seeking to probe testability of properties defined by logical means. A direct product function is a function of the form g(x_1, ldots, x_k)=(g_1(x_1), ldots, g_k(x_k)). We show that the direct product property is locally testable with two queries, that is, a canonical two-query test distinguishes between direct product functions and functions that are far from direct products with constant probability. This local testing question comes up naturally in the context of PCPs, where direct products play a prominent role for gap amplification. We consider the following natural two query test for a given function f:[N]^kto[M]^k begin quote bf Two query direct product test : Choose x, y that agree on a random set A of t coordinates and accept if f(x)_A=f(y)_A. End quote We provide a comprehensive analysis of this test for all parameters N, M, k, tle O(k) and success probability delta>0. Our main result is that if a given function f:[N]^kto[M]^k passes the test with probability delta ge 1-eps then there is a direct product function g such that Pr[f(x)=g(x)]ge 1-O(eps). This is the first result relating success in the above (or any) test to the fraction of the domain on which f is equal to a direct product function. This test has been analyzed in previous works for the case t ll k ll N, and results show closeness of f to a direct product under a less natural measure of "approximate agreement". In the small soundness regime, we prove that if the test above passes with probability delta ge exp(-k), then the function agrees with a direct product function on local parts of the domain. This extends the previous range of parameters of delta ge exp(-sqrt[3]k) to the entire meaningful range of delta>exp(-k). 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 concerns 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 monograph 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; Szemeredi's Regularity Lemma, which plays a very important role in the analysis of algorithms for testing graph properties (in the dense-graphs model); The approach of Testing by implicit learning, which implies efficient testability of membership in many functions classes; and Algorithmic techniques for testing properties of sparse graphs, which include local search and random walks.