Notes and Comments for [1]

Transcription

1 Notes and Comments for [1] Zhang Qin July 14, 007 The purpose of the notes series Good Algorithms, especially for those natural problems, should be simple and elegant. Natural problems are those with universal assumptions, and search for a solution with symmetric properties. However, in the real world, things are not perfect; problems are often skewed. And the biggest obstacle is, things are often difficult. People believe that randomization and approximation may come to rescue, and then, algorithms become even more erratic. Honestly, randomization and approximation themselves are inherently symmetric, and algorithms could still be simple, effective and beautiful. But like the play of Go 1, they might not still be the best. However, most of us still prefer a move in Go with massiness and resulting in sound shape, even if it could not bring us the maximum benefits. And simple, elegant algorithms are still be thought the most valuable treasure computer scientists bring to the human beings. This notes series is devoted to those good algorithms, which have simple and beautiful ideas, as well as succinct and polished analysis. For the sake of convenience, some of the technical details might be neglected, and some analysis will be simplified. Contents Abstract some key words which denotes the major ideas/techniques one could learn. State the problem the paper want to solve clearly, along with its contributes. Dig out the intuition of the paper, and present the general idea. Summarize the main algorithms. Study the major techniques used and the art of the analysis. Some comments and conclusion 1 An Asian board game, some ugly moves may bring the best results. 1

2 1 Key words Property testing, random sampling, graph algorithm. Problems and Goals There are tons of results in this paper. And here we just select one of it, the k-colorability Testing Algorithm. We first introduce two important concepts. The graphs we assume in this note are undirected (but in the adjacent matrix representation, we can think it as a directed graph with duplicated edges), simple and dense graphs. Definition.1 property testing algorithm. We say that A is a property testing algorithm for the class of function F if for every n, ɛ and δ and for every function f and distribution D n over {0, 1} n the following holds if f F n then with probability at least 1 δ (over the examples drawn from D n and the possible coins of A), A accepts f (i.e., output 1). if f is ɛ-far from F n then with probability at least 1 δ (over the examples drawn from D n and the possible coins of A), A reject f (i.e., output 0). Definition. violating edges and good k-partitions. We say that an edge e = (u, v) E(G) is a violating edge with respect to a k- partition π: V (G) [k] if π(u) = π(v). We say that k-partition is ɛ-good if it has at most ɛn violating edges (otherwise it is ɛ-bad. The partition is perfect if it has no violating edge) Our task is try to construct a k-colorability Testing Algorithm for a given dense undirected graph G = (V, E) with V = N such that It is a property testing algorithm. Its query complexity is O ( k 4 log (k/δ) ɛ 6 ) and running time Exp(O ( k log (k/δ) ɛ 3 ) ). If the test graph G is k-colorable, then it is accepted with probability 1. 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 addition time O ( log(k/δ) ɛ ) N. Actually in the analysis, we treat every undirected edge as two direct edges. That s why sometimes we see the violating edges doubled, but that is not important to us anyway

3 3 Intuition and General Idea The philosophy lies behind the notion of property testing (we restrict it to graph property testing here) is that we try to speculate the global property of the graph by examining only a local configuration of that graph, and we also try to make the speculation almost (with high probability) accurate. For example, in the k-colorability problem, we randomly sample a few (some constant independent with N) vertices (form a set X) along with the edges incident to them. We use our algorithm to experiment possible k-colorings on these elements and build one say, π on U X if possible, and then extend π to a global coloring π over the whole vertices set V. During the construction of π, we also use a small set of vertices S to test the goodness of our π. And if all the π s we could construct is bad, we could say that G is not k-colorable with high probability. otherwise, if one of them is good, then we could say G is k-colorable by introducing a small group of violating edges. A crucial observation in the analysis is that we do not need the sample approximate well all the relevant quantities. For example, here we allow some violating edges (up to the ɛn ). That s the key of fact that a constant number of sampling vertices suffice. This is a simple but great idea. Perfect solutions are always cost a lot, and in most cases approximation solutions or fault (various kinds) tolerant solutions may work pretty well! In this particular problem, during the coloring procedure, a natural idea is that we shall try to fix those restricting vertices (that is, those have little colors to choose due to the color configurations of their neighbors) first. And the rest could be done easily. During the coloring procedure, the color we give to a vertex should not effect the freedom of many of its neighbor vertices. 3 This is the guide line throughout the algorithm. 4 Algorithm and Explanation The general algorithm is described as follows. Algorithm k-colorability Testing(G), output accept/reject 1. Choose a uniformly set X = U S of total size O ( k log(k/δ) ɛ 3 ), where U = U 1 U... U l with l = 4k/ɛ and U i i=1,,...,l = S = m = O(l ɛ 1 log(k/δ)). For every pair of vertices v 1, v X, query if (v 1, v ) E(G). Let G X be the induced subgraph. 3. If k-colorable Verify(G X )=true, then output accept, else output reject. 3 freedom is in terms of the number of colors a vertex could still choose 3

4 Algorithm k-colorable Verify(U), output true/false 1. For any possible k-partition of U, denote π (a) (U, π ) =Contruct Core(U, π) (U : troublesome vertices.) (b) Use brute force to test if there is a perfect k-partition of U S that extends π, output true and return.. Output false. We would like to introduce several definitions in order to continue. Definition 4.1 clusters. Let U be a set of vertices, and let π be a perfect k-partition of U. Define U i = {v U : π (v) = i}. For each subset A [k], we define the A-cluster with respect to π as follows (let Γ(v) be the set of the neighbors of v): ) C A = ( Γ(U i) i A \ Γ(U i) Obviously, any v C A cannot be placed in any V i such that i A. Definition 4. restricting vertex. (restricting: not die but close to die.) A pair (v, i), where v C A, A / [k] and i Ā is said to be restricting with respect to a k-partition π of U if v has at least ɛ N neighbors in 4 B:i/ BC B. A vertex v C A, A / [k], is restricting with respect to π if for every i Ā, the pair (v, i) is restricting. The clusters are with respect to π. Intuitively, a vertex v C A is restricting if for every i Ā, add v to U i will cause many of its neighbors to move to a cluster corresponding to a bigger subset. Algorithm Contruct Core(U, π), output U (conceptual version, used only for the analysis.) 1. U =.. For j = 1,,... (index of copies) do the following. Consider the current set U and its partition π. (a) If there are less than ɛ N restricting vertices with respect to π then halt and output U. (b) If there are at least ɛ N vertices but there is no restricting vertex in U j, then halt and output an error symbol (seldom happen). (c) Otherwise add the first (by any fixed order 4 ) restricting vertex in U j to U. Go on to the next iteration. 4 One can think that we give an order to all vertices in U j aforehand. i/ A 4

5 Algorithm Contruct Core(U, π), output U (practical version.) 1. U =.. For j = 1,,... do the following. Consider the current set U and its partition π. (a) Uniformly select a set W j of size Θ ( ) log(k/ɛδ) ɛ (b) For each u U j, let R(u, i) be the set of neighbors of u in W j that belong to B-clusters such that i / B. If for some u U j, R(u, i) / W j 3ɛ/ for every i Ā, then we conclude that u is a restricting vertex, and we select the first (according to some fix order) such vertex in U j to U. When there is no such vertex, halt. Definition 4.3 close partitions. A partition of (U, π ) is called closed if there are less than ɛ N restricting vertices with respect to π. Remark 4.1 We observe (see the algorithm Contruct Core(U) and the corresponding analysis section 5) the following simple but important facts: The algorithm output a set U this set together with its induced partition are closed. And the algorithm output a closed partition with high probability ( 1 δ ). Thus with high probability, we would get a close partition. Definition 4.4 forbidden sets. Let (U, π ) be closed and consider the clusters with respect to π. For each v V (G)\U, we define the forbidden set of v, denoted F v, as the smallest set satisfying F v A, where v C A. For every i Ā, if v has at least ɛ 4 N neighbors in the cluster C B for which i / B, then i is in F v. For u U, define F u = [k]\{π (u)}. Be confused by these definitions? Actually, they just tell us which color we could choose and among those which is best to choose. A guide line here is that the color we choose for a vertex should not affect too much about the freedom of its neighbors. Algorithm Coloring(V, {F v : v V }) 5

6 1. For each v V \U we select a sample of S = Θ ( ) log(k/(ɛδ)) ɛ vertices, and approximate, for each i Ā (where v C A), the number of neighbors (denoted M) that v has in B-clusters such that i / B. And if M ɛ S, 4 add i to F v.. For each u U, F u = [k]\{π (u)}. 3. For every vertex v V, assign a color π(v) / F v. 4. For those v with F v = [k], assign an arbitrary color. A few explanations. 1. The remark 4.1 is true according to two facts. First, after at most l = 4k/ɛ, the procedure Contruct Core(U) halts, and output U or error. Second, with high probability, the procedure halts with output U rather than error. These two facts will be illustrate in section 5.. In the practical version of the Contruct Core(U), we use sampling again to avoid the time overhead to query every vertex in V in order to determine those restricting vertices in U j. The analysis will be given in section 5. An observation here is that we need not care about the borderline of ɛ N. All that we need to do is try to find restricting vertex in U j and continue. If cannot find, halt. That borderline is just useful for the analysis. Note that in the practical version, there is no error state. 3. In the procedure Coloring(V, {F v : v V }), one problem is that some vertices might have no color to choose, that is, F v = [k]. However, we will see later in the analysis that such vertices are rare ( ɛ N), thus we could choose an arbitrary color for it. 5 Major Techniques and Proofs 5.1 Proof of Remark 4.1 Remember we need two things. The algorithm should halt within l steps. The algorithm seldom output error. The first is true because every vertices will stay in at most k different clusters (bigger and bigger) during the whole procedure. And every time a restricting vertex is picked, at least ɛ n neighbor vertices will be picked to a different (bigger) 4 cluster. Since there are n vertices, so at most (l =)4k/ɛ such events would happen. 6

7 The second due to our choice of U i (1 i l) to be m = O ( ) l log(k/δ) ɛ. If there is at least ɛ N restricting vertices. Then the probability that U i contains none of them is at most ( ) m 1 ɛ < δ k l, Further more, there are at most k l different coloring schemes for the vertices picked in those (at most l) rounds. Since every time we add the first vertices in U i, and it could be colored in at most k colors. Therefore with probability greater than 1 δ, the procedure never output error. 5. Vertices which have No Color to Use is Rare That is, #vertices belonging to C [k] or with F v = [k] is small. If F v = [k] and v / C [k], v must be a restricting vertex due to the second item of the Definition of forbidden vertex. And we already show that the number of restricting vertices would be less than ɛ N when the algorithm terminates. Otherwise v C [k], we need the check set S (remember X = U S) to prove that C [k] is small with high probability. We say a (closed) pair (U, π ) is ɛ-useful if C [k] < ɛ N, otherwise it is ɛ-unuseful. The crucial observation is that Claim 5.1 If (U, π ) is ɛ-unuseful, then with probability 1 δ k l, there is no perfect partition for U S which extend π Proof. If C [k] ɛ N the probability of S contains no vertex in C [k] is at most ( 1 ɛ ) S ( = 1 ɛ ) O(l ɛ 1 log(k/δ)) δ k l Since there are at most k l closed pairs of (U, π ), we have the following Corollary 5.1 If all the closed partitions (U, π ) are unuseful, with probability 1 δ over the choices of S, there is no perfect k-partition of X = U S. In other words, if there is a k-partition with probability greater than δ, there must be a useful closed partition. 5.3 Put things together Now we put things together. Suppose the probability that G is k-colorable is greater than δ, we have following deduction. P r[g is k-colorable] δ Remark 4.1 P r[g is k-colorable there is an output U ] > δ Corollary 5.1 Exist an ɛ-useful closed pair(u, π ) Algo Coloring Obtain an ɛ-good partition. 7

8 Last section already shows that vertices with no color to use is rare, that is, less than ɛ N in total. Coloring them with arbitrary color will introduce at most 4 ɛ N violating edges since each vertices incident with at most n edge (every undirected edge would be counted twice here). In the next section, we would see that if we use the practical version of Contruct Core(U), we will introduce another (at most) ɛ N bad vertices, which contribute another ɛ N violating edges, 4 thus the total we have at most ɛn violating edges. The other direction (that is, if G is not k-colorable) follows directly from the Corollary Small Samplings Suffice That is, a small set of sampling vertices suffices to determine restricting vertices and forbidden sets, see algorithm Contruct Core(U) and Coloring(V, F v ). As posed in section, we want the query time and running time to be independent on n. Thus we d better perform sampling, and fortunately we can sample a set of vertices whose cardinality is independent on n to determine restricting vertices and forbidden sets (which related to n) with high probability. The seemingly magical fact actually makes use of the following two assumptions (implicitly) graph is dense. error torrent. We want the following two properties. 1. If for some u U j, R(u, i) / W j 3ɛ/ for every i Ā, then u is a restricting vertex with probability at least 1 δ. If this is true, we can 4l conclude that algorithm Contruct Core(U) works correctly with probability at least 1 δ. 4. With probability at least 1 δ 4, there are at most ɛ 4 N vertices whose F vs (the forbidden set) are wrongly computed. (These wrongly computed vertices would contribute another (at most) ɛ N violating edges as mentioned before.) The first property could be proved directly by using Chernoff bound. Use the additive form P r [ 1 m m i=1 X i p > γ ] < e γm. Here m = W j = Θ ( ) log(k/ɛδ) ɛ, p = ɛ, γ = 3ɛ, and plug in these values we get what we need. 4 We use basically the same method for the second. We still choose m, p, γ as in the first case, and the right bound is O ( ) ɛδ k. Since we have at most k colors to test for each vertex, the error bound would be less than ɛδ. Thus the expected number of vertices who are wrongly approximated (differ significantly from the

9 expected value) by the samplings is O(ɛδ)N. Apply the Markov inequality, we have P r[#wrongly approximated vertices ɛ O(ɛδN) N] ɛ 4 N δ Conclusion and Comments One kind of excellent papers = natural and beautiful idea + deep exploration and analysis + fundamental results. References [1] Oded Goldreich, Shafi Goldwasser, and Dana Ron. Property testing and its connection to learning and approximation. In IEEE Symposium on Foundations of Computer Science, pages ,