Property Testing and its connection to Learning and Approximation Oded Goldreichy
Shafi Goldwasserz
Abstract – We study the question of determining whether an unknown function has a particular property or is -far from any function with that property. A property testing algorithm is given a sample of the value of the function on instances drawn according to some distribution, and possibly may query the function on instances of its choice. First, we establish some connections between property testing and problems in learning theory. Next, we focus on testing graph properties, and devise algorithms to test whether a graph has properties such as being k-colorable or having a -clique (clique of density w.r.t the vertex set). Our graph property testing algorithms are probabilistic and make assertions which are correct with high probability, utilizing only poly(1=) edge-queries into the graph, where is the distance parameter. Moreover, the property testing algorithms can be used to efficiently (i.e., in time linear in the number of vertices) construct partitions of the graph which correspond to the property being tested, if it holds for the input graph.
1. Introduction We are interested in the following general question of PropP be a fixed property of functions, and f be an unknown function. Our goal is to determine (possibly probabilistically) if f has property P or if it is far from any function which has property P, where distance between functions is measured with respect to some distribution D on the domain of f . Towards this end, we are given examples of the form (x; f(x)), where x is distributed according to D. We may also be allowed to query f on instances of our choice. The problem of testing properties emerges naturally in the context of program checking and probabilistically checkable proofs as applied to multi-linear functions or low-degree polynomials [14, 7, 6, 19, 21, 36, 5, 4, 10, 11, 8, 9]. Property testing per se was considered in [36, 35]. Our definition of property testing is inspired by the PAC learning model [37]. It allows the consideration of arbitrary distributions rather than uniform ones, and of testers which utilize randomly chosen instances only (rather than being able to query instances of their own choice). erty Testing: Let
Full version available from http://theory.lcs.mit.edu/~oded/ y Dept. of Computer Science and Applied Math., Weizmann Institute of Science, ISRAEL. E-mail:
[email protected]. On sabbatical leave at LCS, MIT. z Laboratory for Computer Science, MIT, 545 Technology Sq., Cambridge, MA 02139. E-mail:
[email protected]. x Laboratory for Computer Science, MIT, 545 Technology Sq., Cambridge, MA 02139. E-mail:
[email protected]. Supported by an NSF postdoctoral fellowship.
Dana Ronx
We believe that property testing is a natural notion whose relevance to applications goes beyond program checking, and whose scope goes beyond the realm of testing algebraic properties. Firstly, in some cases one may be merely interested in whether a given function, modeling an environment, (resp. a given program) possesses a certain property rather than be interested in learning the function (resp. checking that the program computes a specific function correctly). In such cases, learning the function (resp., checking the program) as means of ensuring that it satisfies the property may be an over-kill. Secondly, learning algorithms work under the postulation that the function (representing the environment) belongs to a particular class. It may be more efficient to test this postulation first before trying to learn the function (and possibly failing when the postulation is wrong). Similarly, in the context of program checking, one may choose to test that the program satisfies certain properties before checking that it computes a specified function. This paradigm has been followed both in the theory of program checking [14, 36] and in practice where often programmers first test their programs by verifying that the programs satisfy properties that are known to be satisfied by the function they compute. Thirdly, we show how to apply property testing to the domain of graphs by considering several classical graph properties. This, in turn, offers a new perspective on approximation problems as discussed below.
F
THE RELEVANT PARAMETERS. Let be the class of functions which satisfy property P. Then, testing property P corresponds to testing membership in the class . The two parameters relevant to property testing are the permitted distance, , and the desired confidence, . We require the tester to accept each function in and reject every function which is further than away from any function in . We allow the tester to be probabilistic and make incorrect positive and negative assertions with probability at most . The complexity measures we focus on are the sample complexity (the number of examples of the function’s values that the tester requires), the query complexity (the number of function queries made – if at all), and the running time of the tester.
F
F
F
1.1. Property Testing and Learning Theory As noted above, our formulation of testing mimics the standard frameworks of learning theory. In both cases one is given access to an unknown target function (either in the form of random instances accompanied by the function values or in the form of oracle access to the function). A semantic differ-
Furthermore:
ence is that, for sake of uniformity, even in case the functions are Boolean, we refer to them as functions rather than concepts. However, there are two important differences between property testing and learning. Firstly, the goal of a learning algorithm is to find a good approximation to the target function f , whereas a testing algorithm should only determine whether the target function is in or is far away from it. This makes the task of the testing seem easier than that of learning. On the other hand, a learning algorithm should perform well only when the target function belongs to whereas a testing algorithm must perform well also on functions far away from . Furthermore, (non-proper) learning algorithms may output an approximation f~ of the target f so that f~ . We show that the relation between learning and testing is non-trivial. On one hand, proper (representation dependent) learning implies testing. On the other hand, there are function classes for which testing is harder than (non-proper) learning, . Nonetheless, there are also function provided classes for which testing is much easier than learning. Further details are given in Subsection 2.2. In addition, the graph properties discussed below provide a case where testing (with queries) is much easier than learning (also with queries).
2F
F
F
F
2F
62 F
NP 6 BPP
?
Except for Bipartite (2-Colorability) testing, running-time of poly(1=) is unlikely, as it will imply .
NP BPP
p
None of these properties can be tested without queries when using o( N) random examples.
The k-Colorability tester has one-sided error: it always accepts k-colorable graphs. Furthermore, when rejecting a graph, this tester always supplies a poly(1=)-size subgraph which is not k-colorable. All other algorithms have two-sided error, and this is unavoidable within o(N) querycomplexity. Our algorithms for k-Colorability, -Clique and -Cut can be easily extended to provide testers with respect to product distributions: that is, distributions : V(G)2 [0; 1] of the form (u; v) = (u) (v), where : V(G) [0; 1] is a distribution on the vertices. In contrast, it is not possible to test any of the graph properties discussed above in a distribution-free manner.
1.2. Testing Graph Properties In the main technical part of this paper, we focus our attention on testing graph properties. We view graphs as Boolean functions on pairs of vertices, the value of the function representing the existence of an edge. We mainly consider testing algorithms which use queries and work under the uniform distribution. That is, a testing algorithm for graph property P makes queries of the form “is there an edge between vertices u and v” in an unknown graph G. It then decide whether G has property P or is “-away” from any graph with property P, and is allowed to err with probability 1=3. Distance between two N -vertex graphs is defined as the fraction of vertex-pairs which are adjacent in one graph but not in the other. We present algorithms of poly(1=) query-complexity and ~ 3)) for testing the following running-time1 at most exp(O(1= graph properties:
7!
7!
GENERAL GRAPH PARTITION. All of the above properties are special cases of the General Graph k-Partition property, parameterized by a set of lower and upper bounds. The parameterized property holds if there exists a partition of the vertices into k disjoint subsets so that the number of vertices in each subset as well as the number of edges between each pair of subsets is within the specified lower and upper bounds. We present a testing algorithm for the above general property. The algo~ 2 =)k+5 queries, runs in time exponential in its rithm uses O(k query-complexity, and makes two-sided error. Approximating partitions, if they exist, can be efficiently constructed in this general case as well. We note that the specialized algorithms perform better than the general algorithm with the appropriate parameters.
k-Colorability for any fixed k 2. (Here the querycomplexity is poly(k=), and for k = 2 the running-time ~ 3).) is O(1= -Clique for any > 0. That is, does the has a clique of size N .
For all the above properties, in case the graph has the desired property, the testing algorithm outputs some auxiliary information which allows to construct, in poly(1=) N time, a partition which approximately obeys the property. For example, for -CUT, we can construct a partition with at least ( )N 2 crossing edges.
OTHER GRAPH PROPERTIES. Going beyond the general graph partition problem, we remark that there are graph propertie s which are very easy to test (e.g., Connectivity, Hamiltonicity, and Planarity). On the other hand, there are graph properties in which are extremely hard to test; namely, any testing algorithm must inspect at least (N 2 = logN) of the vertex pairs. In view of the above, we believe that providing a characterization of graph properties according to the complexity of testing them may not be easy.
N -vertex graph
NP
-CUT for any > 0. That is, does the N -vertex graph has a cut of size at least N 2 . A generalization to k-way cuts works within query-complexity poly((log k)=). -Bisection for any > 0. That is, does the N -vertex graph have a bisection of size at most N 2 .
OUR TECHNIQUES. Our algorithms share some underlying ideas. The first is the uniform selection of a small sample and the search for a suitable partition of this sample. In case of
1 Here and throughout the paper, we consider a RAM model in which trivial
manipulation of vertices (e.g., reading/writing a vertex name and ordering vertices) can be done in constant time.
2
k-Colorability certain k-colorings of the subgraph induced by this sample will do, and these are found by k-coloring a slightly augmented graph. In the other algorithms we exhaustively try all possible partitions. This is reminiscent of the exhaustive sampling of Arora et. al. [3], except that the partitions considered by us are always directly related to the combinatorial structure of the problem. We show how each possible partition of the sample induces a partition of the entire graph so that the following holds. If the tested graph has the property in question then, with high probability over the choice of the sample, there exists a partition of the sample which induces a partition of the entire graph so that the latter partition approximately satisfies the requirements established by the property in question. For example, in case the graph has a -cut, there exists a 2-way-partition of the sample inducing a partition of the entire graph with ( )N 2 crossing edges. On the other hand, if the graph should be rejected by the test, then by definition no partition of the entire graph (and in particular none of the induced partitions) approximately obeys the requirements. The next idea is to use an additional sample to approximate the quality of each such induced partition of the graph, and discover if at least one of these partitions approximately obeys the requirements of the property in question. An important point is that since the first sample is small (i.e., of size poly(1=)), the total number of partitions it induces is only exp poly(1=). Thus, the additional sample must approximate only these many partitions (rather than all possible partitions of the entire graph) and it suffices that this sample be of size poly(1=), The difference between the various algorithms is in the way in which partitions of the sample induce partitions of the entire graph. The simplest case is in testing Bipartiteness. For a partition (S1 ; S2) of the sample, all vertices in the graph which have a neighbor in S1 are placed on one side, and the rest of the vertices are placed on the other side. In the other algorithms the induced partition is less straightforward. For example, in case of -Clique, a partition (S1 ; S2) of the sample S with S1 S , induces a candidate clique roughly as follows. Consider the set T of graph vertices each neighboring all of S1. Then the candidate clique consists of the N vertices with the highest degree in the subgraph induced by T. In the, Cut, -Bisection and General Partition testing algorithms, we use auxiliary guesses which are implemented by exhaustive search.
mation scheme (i.e., to within any constant relative error) for dense graphs, improving on Arora et. al. [3] and de la Vega [17] 2 who solved this problem in polynomial-time (O(N 1= )–time 2 ))) N 2 –time, respectively). In both works ~ and exp(O(1=( the problem is solved by actually constructing approximate max-cuts. Finding an approximate max-cut does not seem to follow from the mere existence of a tester for -Cut; yet, as mentioned above, our tester can be used to find such a cut in ~ 3) N + exp(O(1= ~ 3))–time). time linear in N (i.e., O(1=
One can turn the question around and ask whether approximation algorithms for dense instances can be transformed into corresponding testers as defined above. In several cases this is possible. For example, using some ideas from our work, the Max-CUT algorithm of [17] can be transformed into a tester of complexity comparable to ours. We do not know whether the same is true with respect to the algorithms in [3]. Results on testing graph properties can be derived also from work by Alon et. al. [1]. That paper proves a constructive version of the Regularity Lemma of Szemer´edi, and obtains from it a polynomial-time algorithm that given an N -vertex graph, > 0 and k 3, either finds a subgraph of size f(; k) which is not k-colorable, or omits at most N 2 edges and k-colors the rest. Noga Alon has observed that the analysis can be modified to yield that almost all subgraphs of size f(; k) are not k-colorable, which in turn implies a tester for k-Colorability. In comparison with our k-Colorability Tester, which takes a sample of O(k2 log k=3) vertices, the k-colorability tester derived (from [1]) takes a much bigger sample of size equaling a tower of (k=)20 exponents (i.e., log f(; k) = (k=)20).
?
1.3. Testing Graph Properties and Approximation
A DIFFERENT NOTION OF APPROXIMATION FOR MAX-CLIQUE. Our notion of -Clique Testing differs from the traditional notion of Max-Clique Approximation. When we talk of testing “-Cliqueness”, the task is to distinguish the case in which an N -vertex graph has a clique of size N from the case in which it is -far from the class of N -vertex graphs having a clique of size N . On the other hand, traditionally, when one talks of approximating the size of Max-Clique, the task is to distinguish the case in which the max-clique has size at least N from, say, the case in which the max-clique has size at most N=2. Whereas the latter problem is NP-Hard, for 1=64 (see [9, Sec. 3.9]), we’ve shown that the former problem can be solved in exp(O(1=2))-time, for any ; > 0. Furthermore, Arora et. al. [3] showed that the “dense-subgraph” problem, a generalization of -cliqueness, has a polynomial-time approximation scheme (PTAS) for dense instances.
The relation of testing graph properties to approximation is best illustrated in the case of Max-CUT. A tester for the class -Cut, working in time T(; N), yields an algorithm for approximating the maximum cut in an N -vertex graph, up to additive error N 2, in time 1 T(; N). Thus, for any constant > 0, we can approximate the size of the max-cut to within N 2 in constant time. This yields a constant time approxi-
APPROXIMATING kTESTING k-COLORABILITY VS. COLORABILITY. Petrank has shown that it is NP-Hard to distinguish 3-colorable graphs from graphs in which every 3-partition of the vertex set violates at least a constant fraction of the edges [30]. In contrast, our k-Colorability Tester implies that solving the same promise problem is easy for dense graphs, where by dense graphs we mean N -vertex graphs
j j j j
3
with (N 2) edges. This is the case since, for every > 0, our tester can distinguish, in exp(k2=3 )-time, between kcolorable N -vertex graphs and N -vertex graphs which remain non-k-colorable even if one omits at most N 2 of their edges.2 We note that deciding k-colorability even for N -vertex 3 graphs of minimum degree at least kk? ?2 N is NP-complete (cf., Edwards [18]). On the other hand, Edwards also gave a polynomial-time algorithm for k-coloring k-colorable N vertex graphs of minimum degree at least N , for any constant > kk??23 .
property P which has received much attention in the last two decades [29]. In the classical problem there are no margins of error, and one is required to accept all graphs having property P and reject all graphs which lack it. In 1975 Rivest and Vuillemin [33] resolved the Aanderaa–Rosenberg Conjecture [34], showing that any deterministic procedure for deciding any non-trivial monotone N -vertex graph property must examine (N 2) entries in the adjacency matrix representing the graph. The query complexity of randomized decision procedures was conjectured by Yao to be (N 2). Progress towards this goal was made by Yao [40], King [27] and Hajnal [23] culminating in an (N 4=3 ) lower bound. Our results, that some non-trivial monotone graph properties can be tested by examining a constant number of random locations in the matrix, stand in striking contrast to all of the above.
1.4. Other Related Work PROPERTY TESTING IN THE CONTEXT OF PCP: Property testing plays a central role in the construction of PCP systems. Specifically, the property tested is being a codeword with respect to a specific code. This paradigm explicitly introduced in [6] has shifted from testing codes defined by low-degree polynomials [6, 19, 5, 4] to testing Hadamard codes [4, 10, 11, 8], and recently to testing the “long code” [9].
APPROXIMATION IN DENSE GRAPHS. As stated previously, Arora et. al. [3] and de la Vega [17] presented PTAS for dense instances of Max-CUT. The approach of Arora et. al. uses Linear Programming and Randomized Rounding, and applies to other problems which can be casted as a “smooth” Integer Programs.3 The methods of de la Vega [17] are purely combinatorial and apply also to similar graph partition problems. Following the approach of Alon et. al. [1], but using a modification of the regularity Lemma (and thus obtaining much improved running times), Frieze and Kannan [20] devise PTAS for several graph partition problems such as Max-Cut and Bisection. We note that compared to all the above results, our respective graph partitioning algorithms have better running-times. Like de la Vega, our methods use elementary combinatorial arguments related to the problem at hand. Still our methods suffice for dealing with the General Graph Partition Problem.
PROPERTY TESTING IN THE CONTEXT OF PROGRAM CHECKING: There is an immediate analogy between program self-testing [14] and property-testing with queries. The difference is that in self-testing, a function f (represented by a program) is tested for being close to a fully specified function g, whereas in property-testing the test is whether f is close to any function in a function class . Interestingly, many self-testers [14, 36] work by first testing that the program satisfies some properties which the function it is supposed to compute satisfies (and only then checking that the program satisfies certain constraints specific to the function). Rubinfeld and Sudan [36] defined property testing, under the uniform distribution and using queries, and related it to their notion of Robust Characterization. Rubinfeld [35] focuses on property testing as applied to properties which take the form of functional equations of various types.
G
Important Note: In this extended abstract, we present
only two of our results on testing graph properties: the kColorability and the -Clique testers. The definition and theorem regarding the General Graph Partition property appears in Subsection 3.3. All other results as well as proofs and further details can be found in our report [22].
PROPERTY TESTING IN THE CONTEXT OF LEARNING THEORY: Departing from work in Statistics regarding the classification of distributions (e.g., [24, 16, 41]), Ben-David [12] and Kulkarni and Zeitouni [28] considered the problem of classifying an unknown function into one of two classes of functions, given labeled examples. Ben-David studied this classification problem in the limit (of the number of examples), and Kulkarni and Zeitouni studied it in a PAC inspired model. For any fixed , the problem of testing the class with distance parameter can be casted as such a classification problem (with and the set of functions -away from being the two classes). A different variant of the problem was considered by Yamanishi [39].
F
F
2. General Definitions and Observations 2.1. Definitions
F
fF g
Let = n be a parameterized class of functions, where the functions4 in n are defined over 0; 1 n and let = Dn be a corresponding class of distributions (i.e., Dn is a distribution on 0; 1 n). We say that a function f defined on 0; 1 n is -close to n with respect to Dn if there exists a function g n such that
D f g
F
f g
TESTING GRAPH PROPERTIES. Our notion of testing a graph property P is a relaxation of the notion of deciding the graph
2F
F
f g
f g F
3 In [2], the approach of [3] is extended to other problems, such as Graph Isomorphism, using a new rounding procedure for the Assignment Problem. 4 The range of these functions may vary and for many of the results and discussions it suffices to consider Boolean function.
2 As noted by Noga Alon, similar results, alas with much worse dependence on , can be obtained by using the results of Alon et. al. [1].
4
6
ProbxDn [f(x) = g(x)] : (1) Otherwise, f is -far from n (with respect to Dn ). We shall consider several variants of testing algorithms, where the most basic one is defined as follows.
F
In the learning literature, a distinction is made between proper (or representation dependent) learning and non-proper learning [31]. In the former model, the hypothesis output by the learning algorithm is required to belong to the same , while in function class as the target function f , i.e. h the latter model, no such restriction is made. We stress that a proper learning algorithm (for ) may either halt without output or output a function in , but it may not output functions not in .5 There are numerous variants of PAC learning (including learning with respect to specific distributions, and learning with access to an oracle for the target function f ). Unless stated otherwise, whenever we refer in this section to PAC learning we mean the distribution-free no-query model described above. The same is true for references to property testing. In addition, apart from one example, we shall restrict our attention to classes of Boolean functions.
2F
A
Definition 2.1 (property testing): Let be an algorithm which receives as input a size parameter n, a distance parameter 0 < < 1, and a confidence parameter 0 < < 1=2. Fixing an arbitrary function f and distribution Dn over 0; 1 n, the algorithm is also given access to a sequence of f -labeled examples, (x1; f(x1 )); (x2; f(x2 )); :::, where each xi is independently drawn from the distribution Dn . We say that is a property testing algorithm (or simply a testing algorithm) for the class of functions if for every n, and and for every function f and distribution Dn over 0; 1 n the following holds
f g
F
A
F
f g
if f 2 Fn then with probability at least 1 ? (over the if f
A
F
? A The sample complexity of A is a function of n; and bounding the number of labeled examples examined by A on input (n; ; ).
F
A
The proof of this proposition, as well as of all other propositions in this section, can be found in our report [22]. The above proposition implies that if for every n, n has polynomial (in n) VC-dimension [38, 15], then has a tester whose sample complexity is poly(n=) log(1=). The reason is that classes with polynomial VC-dimension can be properly learned from a sample of the above size [15]. However, the running time of such a proper learning algorithm, and hence of the resulting testing algorithm might be exponential in n.
Though it was not stated explicitly in the definition, we shall also be interested in bounding the running time of a property testing algorithm (as a function of the parameters n; ; , and in some case of a complexity measure of the class ). We consider the following variants of the above definition: (1) Dn may be a specific distribution which is known to the algorithm. In particular, we shall be interested in testing with respect to the uniform distribution; (2) Dn may be restricted to a known class of distributions (e.g., product distributions); (3) The algorithm may be given access to an oracle for the function f , which when queried on x 0; 1 n, returns f(x). In this case we refer to the number of queries made by (which is a function of n, , and ), as the query complexity of .
F
A
F
has a proper learning Proposition 2.1 If a function class algorithm , then has a property testing algorithm 0 such that mA0 (n; ; ) = mA (n; =2; =2)+O(log(1=)=). Furthermore, the same relation holds between the running times of the two algorithm.
is -far from n (with respect to Dn ) then with probability at least 1 , rejects f (i.e., outputs 0).
2f g
F
TESTING IS NOT HARDER THAN PROPER LEARNING.
examples drawn from Dn and the possible coins tosses of ), accepts f (i.e., outputs 1);
A A
F
F
F
Corollary 2.2 Every class which is learnable with a poly(n=) sample is testable with a poly(n=) sample (in at most exponential time).
A
TESTING MAY BE HARDER THAN LEARNING. In contrast to Proposition 2.1 and to Corollary 2.2, we show that there are classes which are efficiently learnable (though not by a proper learning algorithm) but are not efficiently testable. This is proven by observing that many hardness results for proper learning (cf. [31, 13, 32]) actually establish the hardness of testing (for the same classes). Furthermore, we believe that it is more natural to view these hardness results as referring to testing. Thus, the separation between efficient learning and efficient proper learning translates to a separation between efficient learning and efficient testing.
2.2. Property Testing and PAC Learning A Probably Approximately Correct (PAC) learning algorithm [37] works in the same framework as that described in Definition 2.1 except for the following (crucial) differences: (1) It is given a promise that the unknown function f (referred to as the target function) belongs to ; (2) It is required to output (with probability at least 1 ) a hypothesis function h which is -close to f , where closeness is as defined in Equation (1) (and is usually referred to as the approximation parameter). Note that the differences pointed out above effect the tasks in opposite directions. Namely, the absence of a promise makes testing potentially harder than learning, whereas deciding whether a function belongs to a class rather than finding the function may make testing easier.
F ?
5 We remark that in case the function is
F
have an easy to recognize representation, one can easily guarantee that the algorithm never outputs a function not in . Standard classes considered in works on proper learning typically have this feature.
F
5
NP 6 BPP
H
Proposition 2.3 If then there exist function classes which are not poly(n=)-time testable but are poly(n=)-time (non-properly) learnable.
implies proper learning of the class testing of .
F
Proposition 2.6 There exist distribution classes which are efficiently learnable (in both senses mentioned above) but cannot be tested with a subexponential sample (regardless of the running-time).
F
Proposition 2.4 There exist function classes such that has a property testing algorithm whose sample complexity and running time are O(log(1=)=), yet any learning algorithm for must have sample complexity exponential in n.
F
3. Testing Graph Properties
The impossibility of learning the function class in Proposition 2.4 is due to its exponential VC-dimension, (i.e., it is a pure information theoretic consideration). We now turn to function classes of exponential (rather than double exponential) size. Such classes are always learnable with a polynomial sample, the question is whether they are learnable in polynomial-time. We present a function class which is easy to test but cannot be learned in polynomial-time (even under the uniform distribution), provided trapdoor one-way permutations exist (e.g., factoring is intractable).
We concentrate on testing graph properties using queries and with respect to the uniform distribution. We consider undirected, simple graphs (no multiple edges or self-loops). For a simple graph G, we denote by V(G) its vertex set and assume, without loss of generality, that V(G) = 1; :::; V(G) . The graph G is represented by 0; 1 the (symmetric) Boolean function g :V(G) V(G) where g(u; v) = 1 if and only if there is an edge between u and v in G. This brings us to associated undirected graphs with directed graphs, where each edge in the undirected graph is associated with a pair of anti-parallel edges. Specifically, for a graph G, we denote by E(G) the set of ordered pairs which correspond to edges in G (i.e., (u; v) E(G) iff there is an edge between u and v in G). The distance between two N -vertex graphs, G1 and G2, is defined as the number of
f
Proposition 2.5 If there exist trapdoor one-way permutations then there exists a family of functions which can be tested in poly(n=)-time but can not be learned in poly(n=)-time, even with respect to the uniform distribution. Furthermore, the functions can be computed by poly(n)-size circuits.
j
jg
7! f g
2
2
def
f
g
entries (u; v) [N]2 ([N] = 1; :::; N ) which are in the symmetric difference of E(G1) and E(G2 ). We denote
The class presented in Proposition 2.5 consists of multi-valued functions. We leave it as an open problem whether a similar result holds for a class of Boolean functions.
dist(G1 ; G2) def = j(E(G1) n E(G2))N[2(E(G2) n E(G1))j This notation is extended naturally to a set, C , of N -vertex def graphs; that is, dist(G; C ) = minG 2C fdist(G; G0)g.
LEARNING AND TESTING WITH QUERIES (under the uniform distribution). Invoking known results on linearity testing [14, 7, 19, 10, 11, 8] we conclude that there is a class of 2n functions which can be tested within query complexity O(log(1=)=), and yet learning it requires at least n queries. Similarly, using results on low-degree testing [7, 6, 21, 36], there is a class of exp(2n ) function which can be tested within query complexity O( log(1 =) n), and yet learning it requires exp(n) many queries.
0
3.1. Testing k-Colorability In this subsection we present an algorithm for testing the
k-Colorability property for any given k. Namely, we are interested in determining if the vertices of a graph G can be colored by k colors so that no two adjacent vertices are colored by the same color, or if any k-partition of the graph has at least N 2
violating edges (i.e. edges between pairs of vertices which belong to the same side of the partition). The test itself is straightforward. We uniformly select a
AGNOSTIC LEARNING AND TESTING. In a variant of PAC learning, called Agnostic PAC learning [26], there is no promise concerning the target function f . Instead, the learner is required to output a hypothesis h from a certain hypothesis class , such that h is -close to the function in which is closest to f . The absence of a promise makes agnostic learning closer in spirit to property testing than basic PAC learning. In particular, agnostic learning with respect to a hypothesis class
H
H and thus property
LEARNING AND TESTING DISTRIBUTIONS. The context of learning (cf., [25]) and testing distributions offers a dramatic demonstration to the importance of a promise (i.e., the fact that the learning algorithm is required to work only when the target belongs to the class, whereas the testing algorithm needs to work for all targets which are either in the class or far away from it).
We stress that while Proposition 2.1 generalizes to learning and testing under specific distributions, and to learning and testing with queries, the proof of Proposition 2.3 uses the premise that the testing (or proper learning) algorithm works for any distribution and does not make queries. TESTING MAY BE EASIER THAN LEARNING.
H
k2(log(k=)
sample, denoted X, of O vertices of the graph, 3 query all pairs of vertices in X to find which are edges in G, and check if the induced subgraph is k-Colorable. In 3, we lack of efficient algorithms for k-Colorability, for k use the obvious exponential-time algorithm on the induced
H
6
same sides of the partition of U0. For every A [k], the Acluster, denoted CA , contains all vertices in V(G) which have neighbors in U0i for every i A (and do not have neighbors in the other U0i ’s). The clusters impose restrictions on possible extensions of the partition of U0 to partitions (V1 ; : : :; Vk ) of all V(G), which do not have violating edges incident to vertices in U0 . Namely, vertices in CA should not be placed in any Vi such that i A. As a special case, C; is the set of vertices that do not have any neighbors in U0 (and hence can be put on any side of the partition). In the other extreme, C[k] is the set of vertices that in any extension of the partition of U0 will cause violations. For each i, the vertices in C[k]nfig are forced to be put in Vi , and thus are easy to handle. It is more difficult to deal with the the clusters CA where A < k 1.7
subgraph. The resulting algorithm is called the k-Colorability Testing Algorithm. Towards analyzing it, we define violating edges and good k-partitions.6
2
Definition 3.1.1 (violating edges and good k-partitions): We say that an edge (u; v) E(G) is a violating edge with respect to a k-partition : V(G) [k] if (u) = (v). We shall say that a k-partition is -good if it has at most N 2 violating edges (otherwise it is -bad). The partition is perfect if it has no violating edges.
2
!
2
Theorem 3.1 The k-Colorability Testing Algorithm is a property testing algorithm for the class of k-Colorable graphs whose query complexity is poly(k log(1=)=) and whose running time is exponential in its query complexity. If the tested graph G is k-Colorable, then it is accepted with probability 1, and with probability at least 1 (over the choice of the sampled vertices), it is possible to construct an -good k-partition of V(G) in time poly(k log(1=)=) V(G) .
j j
Definition 3.1.2 (clusters): Let U0 be a set of vertices, and def let 0 be a perfect k-partition of U0 . Define Ui0 = v U : 0 (v) = i . For each subset A [k] we define the A-cluster with respect to 0 as follows:
?
j
j
CA
f 2
g
Proof: If G is k-Colorable then every subgraph of G is kColorable, and hence G will always be accepted. The crux of the proof is to show that every G which is -far from the class of k-Colorable graphs, denoted k , is rejected with probability at least 1 . We establish this claim by proving its counter-positive. Namely, that every G which is accepted with probability greater than , must have an -good k-partition (and is thus -close to k ). This is done by giving a (constructive) proof of the existence of an -good k-partition of V(G). Hence, in case G k , we also get an efficient probabilistic procedure for finding an -good k-partition of V(G). Note that if the test rejects G then we have a certificate that G = k , in form of the (small) subgraph induced by X which is not k-colorable. We view the set of sampled vertices X as a union of two disjoint sets U and S, where U is a union of ` (disjoint) sets U1 ; : : :; U` , each of size m. The size of S is m as well, where m = O((` log(k=))=) and ` = 4k=. The set U (or rather a k-partition of U) is used to define a k-partition of V(G). The set S ensures that with high probability, the k-partition of U which is induced by the perfect k-partition of X = U S, defines an -good partition of V(G). In order to define a k-partition of V(G) given a k-partition of U, we first introduce the notion of a clustering of the vertices in V(G) with respect to this partition of U. More precisely, we define the clustering based on the k-partition of a subset U0 U, where this partition, denoted (U01 ; : : :; U0k ), is the one induced by the k-partition of U. The clustering is defined so that vertices in the same cluster have neighbors on the
def =
\
i2A
!
?(U0i )
n
[
i=2A
?(U0i )
!
:
(2)
The relevance of the above clusters becomes clear given the following definitions of extending and consistent partitions.
G
?
?
Definition 3.1.3 (consistent extensions): Let U0 and 0 be as above. We say that a k-partition of V(G) extends a kpartition 0 of U0 if (u) = 0(u) for every u U0 . An extended partition is consistent with 0 if (v) = 0 (u) for every u U0 and v ?(u) C[k], where C[k] is the [k]-cluster w.r.t 0 .
G
2
2G
2G
2
6
n
2
Thus, each vertex v in the cluster CA (w.r.t 0 defined on U0 ) is forced to satisfy (v) A def = [k] A, for every kpartition which extends 0 in a consistent manner. There are no restrictions regarding vertices in C; and vertices in C[k] (the latter is guaranteed artificially in the definition and the consequences will have to be treated separately). For v C[k]?fig the consistency condition forces (v) = i. We now focus on the main problem of the analysis. Given a k-partition of U, what is a good way to define a k-partition of V(G)? Our main idea is to claim that with high probability the set U contains a subset U0 so that the clusters with respect to the induced k-partition of U0 determine whatever needs to be determined. That is, if these clusters allow to place some vertex on a certain side of the partition, then doing so does not introduce too many violating edges. The first step in implementing this idea is the notion of a restricting vertex.
2
n
2
[
6 k -partitions are associated with mappings of the vertex set into the canon[k] is ical k -element set [k]. The partition associated with : V(G)
Definition 3.1.4 (restricting vertex): A pair (v; i), where v 2= C[k] and i 2 [k], is said to be restricting with respect to a k-partition 0 (of U0 ) if v has at least 4 N neighbors
(V1 = 1 (1); : : : ; Vk = 1 (k)). We shall use the mapping notation , and the explicit partition notation (V1 ; : : : ; Vk ), interchangeably.
7 In the Bipartite case, this is easy too (since C is likely to contain few ; vertices of high degree).
def
?
def
?
!
7
[B:i=2B CB . Otherwise, (v; i) is non-restricting. A vertex v 2 CA , where A 6= [k], is restricting with respect to 0 if for every i 2 A the pair (v; i) is restricting. Otherwise, v is non-restricting. As always, the clusters are with respect to 0 .
In other words, U is such that for every perfect k-partition of U and for each of the at most ` iterations of the procedure, if there exist at least (=8)N restricting vertices with respect to the current partition of U0, then Uj will include at least one such restricting vertex.
in
Thus, a vertex v 2 CA is restricting if for every i 2 A, adding v to U0i (and thus to U0 ) will cause may of its neighbors to
Lemma 3.1.7 With probability at least 1 2 , a uniformly 2 k=) is a covering set. chosen set of size ` m = O k log( 3
[f g
[f g
2
Definition 3.1.8 (closed partitions): Let U0 be a set and 0 a k-partition of it. We call (U0 ; 0) closed if there are less than (=8)N restricting vertices with respect to 0 .
[ [
Clearly, if the Restriction Procedure outputs a set U0 then this set together with its (induced) partition are closed. If (U0 ; 0) is closed, then most of the vertices in V(G) are non-restricting. Recall that a non-restricting vertex v, belonging to a cluster CA , A = [k], has the following property. There exists at least one index i A, such that (v; i) is non-restricting. It follows from Definition 3.1.4 that for every consistent extension of 0 to which satisfies (v) = i there are at most 2 N violating edges incident to v.8 However, even if v is non-restricting there might be indices i A such that (v; i) is restricting, and hence there may exist a consistent extensions of 0 to which satisfies (v) = i in which there are more than 2 N violating edges incident to v. Therefore, we need to define for each vertex its set of forbidden indices which will not allow to have (v) = i for a restricting pair (v; i).
6
Restriction Procedure (Construction of U0 ) Input: a perfect k-partition of U = U1 1.
U0
2. For j = 1; 2; : : : do the following. Consider the current set U0 and its partition 0 (induced by the perfect kpartition of U).
2
2
[ [ U` .
;.
?
move to a cluster corresponding to a bigger subset. That is, v’s neighbors in the B -cluster (w.r.t (U01 ; : : :; U0k )) move to the (B i )-cluster (w.r.t (U10 ; : : :; Ui0 v ; : : :; U0k )). Given a prefect k-partition of U, we construct U0 in steps starting with the empty set. At step j we add to U0 a vertex u Uj (recall that U = U 1 U ` ), which is a restricting vertex with respect to the k-partition of the current set U0 . If no such vertex exists, the procedure terminates. When the procedure terminates (and as we shall see it must terminate after at most ` steps), we will be able to define, based on the k-partition of the final U0, an -good k-partition of V(G). The procedure defined below is viewed at this point as a mental experiment. Namely, it is provided in order to show that with high probability there exists a subset U0 of U with certain desired properties (which we later exploit).
Definition 3.1.9 (forbidden sets): Let (U0 ; 0 ) be closed and consider the clusters with respect to 0 . For each v V(G) U0 we define the forbidden set of v, denoted Fv , as the smallest set satisfying
If there are less than (=8)N restricting vertices with respect to 0 then halt and output U0. If there are at least (=8)N restricting vertices but there is no restricting vertex in Uj , then halt and output error. Otherwise (there is a restricting vertex in Uj ), add the first (by any fixed order) restricting vertex to U0 .
2
n
Fv A, where v 2 CA . For every i 2 A, if v has at least (=4)N neighbors in the clusters CB for which i 2 = B , then i is in Fv . For u 2 U0 , define Fu = [k] n f0 (u)g.
Claim 3.1.5 For every U and a perfect k-partition of U, after at most ` = 4k= iterations, the Restriction Procedure halts and outputs either U0 or error.
Lemma 3.1.10 Let (U0 ; 0) be an arbitrary closed pair and Fv ’s be as in Definition 3.1.9. Then:
The proof of this claim, as well as all other missing proofs, can be found in our report [22]. Before we show how U0 can be used to define a k-partition of V(G), we need to ensure that with high probability, the restriction procedure in fact outputs a set U0 and not error. To this end, we first define the notion of a covering set.
1. 2.
jfv : (v 2= C[k] ) ^ (Fv = [k])gj 8 N . Let be any k-partition of V(G) n fv : Fv = [k]g such that (v) 2 = Fv , for every v 2 V(G). Then, the number of edges (v; v0 ) 2 E(G) for which (v) = (v0 ) is at most (=2)N 2.
Definition 3.1.6 (covering sets – for k-coloring): We say that U is a covering set for V(G), if for every perfect k-partition of U, the Restriction Procedure, given this partition as input, halts with an output U0 U (rather than an error message).
8 First note that by definition of a consistent extension no vertex in cluster CB , where i
2
2
B , can have -value i. Thus, all violated edges incident to v are incident to vertices in clusters CB so that i = B . Since the pair (v; i) is non-restricting, there are at most 2 N such edges.
8
def
The lemma can be thought of as saying that any k-partition which respects the forbidden sets is good (i.e., does not have many violating edges). However, the partition applies only to vertices for which the forbidden set is not [k]. The first item tells us that there cannot be many such vertices which do not belong to the cluster C[k] . We next show that, with high probability over the choice of S , the k-partition 0 of U0 (induced by the k-partition of U S) is such that C[k] is small. This implies that all the vertices in C[k] (which were left out of the partition in the previous lemma) can be placed in any side without contributing too many violating edges (which are incident to them).
Theorem 3.2 Let ` = O(log(1=)). There exists a property testing algorithm, , for the class whose edge-query complexity is O(`2 2 =6 ) and whose running time is exp(`=2 ). In particular, uniformly selects O(`22 =4) vertices in G and queries the oracle only on the existence of edges between these vertices. In case G , one can also retrieve in time O(`2 2 =4) V(G) a set of V(G) vertices in G which is almost a clique (in the sense that it lacks at most V(G) 2 edges to being a clique).
A
A
j
[
uniformly chosen set of size m. Then, with probability at least 2 k?`, there exists no perfect k-partition of U0 S which extends 0 .
[
j
2C
j
j
C
? ?
C
j
j j
j j
If all closed pairs (U0 ; 0) which are deter-
Corollary 3.1.13 mined by all possible k-partitions of U are unuseful, then with probability at least 1 =2 over the choice of S, there is no perfect k-partition of X = U S.
\
[
C
We can now wrap up the proof of Theorem 3.1. If G is accepted with probability greater than , then by Lemma 3.1.7, the probability that it is accepted and U is a covering set is greater than =2. In particular, there must exist at least one covering set U, such that if U is chosen then G is accepted with probability greater than =2 (with respect to the choice of S). That is, (with probability greater than =2) there exists a perfect partition of U S. But in such a case (by applying Corollary 3.1.13), there must be a useful closed pair (U0 ; 0) (where U0 U). If we now partition V(G) as described in Lemma 3.1.10, where vertices with forbidden set [k] are placed arbitrarily, then from the two items of Lemma 3.1.10 and the usefulness of (U0 ; 0 ) it follows that there are at most N 2 violating edges with respect to this partition. This completes the main part of the proof. (Theorem 3.1)
[
\
j j
?
3.2. Testing Max-Clique Let !(G) denote the size of the largest clique in graph G,
j
j
In the rest of this subsection we provide a motivating discussion to the algorithm asserted in Theorem 3.2. Recall that N = V(G) denotes the number of vertices in G. Our first idea is to select at random a small sample U of V(G) and to consider all subsets U0 of size 2 U of U where U = poly(1=). For each U0 let T(U0 ) be the set of all vertices which neighbor every vertex in U0 (i.e., T(U0 ) = u2U0 ?(u)). In the subgraph induced by T(U0 ), consider the set Y(U0 ) of N vertices with highest degree in the induced subgraph. Clearly, if G is -far from , then Y(U0 ) misses at least N 2 edges to being a clique (for every choice of U and U0). On the other hand, we show that if G has a clique C of size N then, with high probability over the choice of U, there exists a subset U0 U such that Y(U0 ) misses at most (=3)N 2 to being a clique (in particular, U0 C U will do). Assume that for any fixed U0 we could sample the vertices in Y(U0 ) and perform edge queries on pairs of vertices in this sample. Then, a sample of O(t=2) vertices (where t = U ) suffices for approximating the edge density in Y(U0 ) to within an =3 fraction with probability 1 O(2?t). In particular a sample can distinguish between a set Y(U0 ) which is far from being a clique and a set Y(U0 ) which is almost a clique. The ? point is that we need only consider jjUU0jj < 2t possible sets Y(U0 ), where t is only a polynomial in 1=. The only problem which remains is how to sample from Y(U0 ). Certainly, we can sample T = T(U0 ), by sampling V(G) and testing membership in T, but how do we decide which vertex is among those of highest degree? The first idea is to estimate the degrees of vertices in T using an additional sample, denoted W. Thus, instead of considering the N
The following is a corollary to the above claim and to the fact that the number of possible closed pairs (U0 ; 0) determined by all possible k-partitions of U is at most k` .
f
j
Corollary 3.3 Let m = poly(1=) and let R be a uniformly selected set of m vertices in V (G). Let GR be the subgraph (of G) induced by R. Then, if G then ProbR [!(GR) > ( 2 ) m] > 32 . if dist(G; )> then ProbR [!(GR ) ( 2 ) m] > 23 .
Claim 3.1.12 Let U0 be a fixed set of size ` and 0 be a fixed k-partition of U0 so that (U0 ; 0) is -unuseful. Let S be a
def
2C
?
above definition.
C
j
Theorem 3.2 is proven by presenting a seemingly unnatural algorithm/tester (see below). However, as a corollary, we observe that “the natural” algorithm, which uniformly selects poly(log(1=)=) many vertices and accepts iff they induce a subgraph with a clique of density 2 , is a valid -tester as well.
Definition 3.1.11 (useful k-partitions): We say that a pair (U0 ; 0) is -useful if jC[k]j < 8 N . Otherwise it is -unuseful. The next claim directly follows from our choice of m and the
?
C
jg
V(G) be the set of graphs and = G : !(G) having cliques of density at least . The main result of this subsection is:
9
vertices of highest degree in T, we consider the N vertices in T having the most neighbors in T W. The second idea is that we can sample T, order vertices in this sample according to the number of neighbors in T W, and take the fraction with the most such neighbors.
[6] L. Babai, L. Fortnow, L. Levin, and M. Szegedy. Checking computations in polylogarithmic time. In 23nd STOC, pages 21–31, 1991. [7] L. Babai, L. Fortnow, and C. Lund. Non-deterministic exponential time has twoprover interactive protocols. Computational Complexity, 1(1):3–40, 1991. [8] M. Bellare, D. Coppersmith, J. H˚astad, M. Kiwi, and M. Sudan. Linearity testing in characteristic two. In 36th FOCS, pages 432–441, 1995. [9] M. Bellare, O. Goldreich, and M. Sudan. Free bits, pcps and non-approximability – towards tight results. In 36th FOCS, pages 422–431, 1995. [10] M. Bellare, S. Goldwasser, C. Lund, and A. Russell. Efficient probabilistically checkable proofs and applications to approximation. In 25th STOC, pages 294– 304, 1993. [11] M. Bellare and M. Sudan. Improved non-approximability results. In 26th STOC, pages 184–193, 1994. [12] S. Ben-David. Can finite samples detect singularities of real-valued functions? In 24th STOC, pages 390–399, 1992. [13] A. Blum and R. Rivest. Training a 3-node neural network is NP-complete. In Advances in Neural Information Processing Systems I, pages 494–501, 1989. [14] M. Blum, M. Luby, and R. Rubinfeld. Self-testing/correcting with applications to numerical problems. Journal of Computer and System Sciences, 47:549–595, 1993. [15] A. Blumer, A. Ehrenfeucht, D. Haussler, and M. K. Warmuth. Learnability and the Vapnik-Chervonenkis dimension. JACM, 36(4):929–965, October 1989. [16] T. M. Cover. On determining the rationality of the mean of a random variable. Annals of Statistics, 1:862–871, 1973. [17] W. F. de la Vega. MAX-CUT has a randomized approximation scheme in dense graphs. To appear in Random Structures and Algorithms, 1994. [18] K. Edwards. The complexity of colouring problems on dense graphs. Theoretical Computer Science, 43:337–343, 1986. [19] U. Feige, S. Goldwasser, L. Lov´asz, S. Safra, and M. Szegedy. Approximating clique is almost NP-complete. In 32nd FOCS, pages 2–12, 1991. [20] A. Frieze and R. Kanan. The regularity lemma and approximation schemes for dense problems. In these proceedings, 1996. [21] P. Gemmell, R. Lipton, R. Rubinfeld, M. Sudan, and A. Wigderson. Selftesting/correcting for polynomials and for approximate functions. In 23nd STOC, pages 32–42, 1991. [22] O. Goldreich, S. Goldwasser, and D. Ron. Property testing and its connection to learning and approximation. Available from http://theory.lcs.mit.edu/ oded/ggr.html. 4 = 3 [23] P. Hajnal. An lower bound on the randomized complexity of graph properties. Combinatorica, 11(2):131–144, 1991. [24] W. Hoeffding and J. Wolfowitz. Distinguishability of sets of distributions. Annals of Mathematical Statistics, 29:700–718, 1958. [25] M. J. Kearns, Y. Mansour, D. Ron, R. Rubinfeld, R. E. Schapire, and L. Sellie. On the learnability of discrete distributions. In The 25th Annual ACM Symposium on Theory of Computing, pages 273–282, 1994. [26] M. J. Kearns, R. E. Schapire, and L. M. Sellie. Toward efficient agnostic learning. In 5th COLT, pages 341–352, 1992. 5=4 lower bound on the randomized complexity of graph [27] V. King. An properties. Combinatorica, 11(1):23–32, 1991. [28] S. R. Kulkarni and O. Zeitouni. On probably correct classification of concepts. In 6th COLT, pages 111–116, 1993. [29] L. Lo´vasz and N. Young. Lecture notes on evasiveness of graph properties. Technical Report TR–317–91, Princeton University, Computer Science Department, 1991. [30] E. Petrank. The hardness of approximations: Gap location. Computational Complexity, 4:133–157, 1994. [31] L. Pitt and L. G. Valiant. Computational limitations on learning from examples. JACM, 35(4):965–984, October 1988. [32] L. Pitt and M. K. Warmuth. The minimum consistent DFA problem cannot be approximated within any polynomial. JACM, 40(1):95–142, January 1993. [33] R. L. Rivest and J. Vuillemin. On recognizing graph properties from adjacency matrices. Theoretical Computer Science, 3:371–384, 1976. [34] A. L. Rosenberg. On the time required to recognize properties of graphs: A problem. SIGACT News, 5:15–16, 1973. [35] R. Rubinfeld. Robust functional equations and their applications to program testing. In 35th FOCS, 1994. [36] R. Rubinfeld and M. Sudan. Robust characterization of polynomials with applications to program testing. SIAM Journal on Computing, 25(2):252–271, 1996. [37] L. G. Valiant. A theory of the learnable. CACM, 27(11):1134–1142, November 1984. [38] V. N. Vapnik and A. Y. Chervonenkis. On the uniform convergence of relative frequencies of events to their probabilities. Theory of Probability and its applications, 17(2):264–280, 1971. [39] K. Yamanishi. Probably almost discriminative learning. Machine Learning, 18:23– 50, 1995. [40] A. C. C. Yao. Lower bounds to randomized algorithms for graph properties. In 28th FOCS, pages 393–400, 1987. [41] O. Zeitouni and S. R. Kulkarni. A general classification rule for probability measures. To appear in Annals of Statistics, 1991.
\
\
3.3. The General Partition Problem The following General Graph Partition property generalizes all properties considered in previous subsections. In particular, it captured any graph property which requires the existence of partitions satisfying certain fixed density constraints. These constraints may refer both to the number of vertices on each side of the partition and to the number of edges between each pair of sides. lb def ; ub k ub k Let = lb j j j =1 %j;j 0 ; %j;j 0 j;j 0=1 be a set of lb ub non-negative parameters so that lb j j ( j ) and %j;j 0 ub 0 %j;j 0 ( j; j ). Let be the class of graphs which have a k-way partition (V1 ; : : :; Vk ) such that
[
8
GP
8
8j; lbj N jVj j ub j N ;
2 8j; j 0; %lbj;j N 2 jE(Vj ; Vj )j %ub j;j N ; 0
0
0
(3) (4)
where E(Vj ; Vj 0 ) denotes the set of edges with one endpoint in Vj and one in Vj 0 . That is, Eq. (3) places lower and upper bounds on the relative sizes of the various parts; whereas Eq. (4) imposes lower and upper bounds on the density of edges among the various pairs of parts. For example, k-colorability is expressed by setting %ub j (and setting lb j;j = 0 for every j = 0, ub xx j = 1, and similarly setting the %j;j 0 ’s for j 0 = j ).
(n )
6
A
Theorem 3.4 There exists an algorithm such that for every given set of parameters , algorithm is a propwith query comerty testing algorithm for the class 2 )=)k+5 k2 log(k=), and running time plexity (O(k ? exp (O(k2 )=)k+2 log(k=) .
GP
A
(n )
Recall that better complexities for Max-CUT and Bisection (as well as for k-Colorability and -Clique), are obtained by custom-made algorithms.
Acknowledgments We wish to thank Noga Alon, Ravi Kannan, David Karger and Madhu Sudan for useful discussions.
References [1] N. Alon, R. A. Duke, H. Lefmann, V. Rodl, and R. Yuster. The algorithmic aspects of the regularity lemma. Journal of Algorithms, 16:80–109, 1994. [2] S. Arora, A. Frieze, and H. Kaplan. A new rounding procedure for the assignment problem with applications to dense graph arrangement problems. In these proceedings, 1996. [3] S. Arora, D. Karger, and M Karpinski. Polynomial time approximation schemes for dense instances of NP-hard problems. In 27th STOC, pages 284–293, 1995. [4] S. Arora, C. Lund, R. Motwani, M. Sudan, and M. Szegedy. Proof verification and intractability of approximation problems. In 33rd FOCS, pages 14–23, 1992. [5] S. Arora and S. Safra. Probabilistic checkable proofs: A new characterization of NP. In 33rd FOCS, pages 1–13, 1992.
10
~
