1. Local Computation Algorithms
Ning Xie, CSAIL MIT
Based on joint works with
Noga Alon, Ronitt Rubinfeld, Gil Tamir and Shai Vardi
TexPoint fonts used in EMF.
Read the TexPoint manual before you delete this box.: AAAAAAAAAAAAAAAAAAAAAAAAAAAA

2. Large data sets and large solutions Large answers
Combinatorial optimization/search
scheduling, coloring, SAT, LP, etc
Coding theoretic
Linear algebra
BUT, only need small portion of answer?

3. In general there are many different legal solutions…
Example problem
In general there are many different legal solutions…
Maximal independent sets
given a sequence v1, v2, , vk (assuming k<<n), which are in an MIS?
All answers must be consistent!

4. Previous and related work
Locally decodable codes (Katz-Trevisan)
Online reconstruction (Ailon, Chazelle, Kale, Liu, Peres, Saks, Seshadhri)
Distributed computing (local algorithms)
Local Computation Algorithms

5. Rest of the talk 1. Model of local computation algorithms (LCA)
2. An LCA for maximal independent set
3. An LCA for hypergraph coloring

6. Part 1: Local Computation Algorithms (LCAs)
F: a computation problem
input x (|x|=n)
set of solutions is F(x)={y1, y2, …, ys}
Want: a randomized algorithm A that implements the oracle access to some yi y1 y2 ys

7. Local computation algorithm
input tape (RAM)
random tape (RAM)
work tape
Algorithm A

8. Local computation algorithm
input tape (RAM) i1
random tape (RAM)
work tape
Algorithm A

9. Local computation algorithm
input tape (RAM) i1
yi1
random tape (RAM)
work tape
Algorithm A

10. Local computation algorithm
input tape (RAM) i1
yi1 i2
random tape (RAM)
work tape
Algorithm A

11. Local computation algorithm
input tape (RAM) i1
yi1 i2
random tape (RAM)
yi2
work tape
Algorithm A

12. Local computation algorithm
input tape (RAM) i1
yi1 i2
random tape (RAM)
yi2
...
work tape
...
Algorithm A

13. Local computation algorithm
input tape (RAM) i1
yi1 i2
random tape (RAM)
yi2
...
work tape
...
Algorithm A iq

14. Local computation algorithm
input tape (RAM) i1
yi1 i2
random tape (RAM)
yi2
...
work tape
...
Algorithm A iq
yiq

15. Local computation algorithms (cont.)
For any sequence of queries i1, i2, ..., iq, A can answer yij with
at most t(n) time
at most s(n) space
All queries are consistent: there exists some y2 F(x) that agrees with all answers
A is correct for all queries w.p. 1-δ(n)
A is a (t(n),s(n),δ(n)) local computation algorithm

16. Would like LCAs to have…
Both t(n) and s(n) are at most poly-logarithmic
Support parallelism
Query order oblivious

17. A generic LCA Generate a random string r
On query i, do the following deterministically
read some bits of input x and random string r
compute yi

18. Part 2: Maximal Independent Set
Input: An undirected graph G(V, E)
Output: A subset of vertices which is a maximal independent set (MIS)
Query: is v in MIS?

19. 1st ingredient: Parnas-Ron
Local distributed approx. algorithm  sublinear approx. algorithm
Query and (usually) time complexity: O(dk)
d: max. degree of graph
k: max. rounds of the distributed algorithm

20. 2nd ingredient: Luby’s distributed algorithm for MIS
repeat O(logn) times in parallel
each vertex selects itself w.p. 1/2d
if v selects itself and none in N(v) is selected
add v to MIS
remove v and N(v) from the graph

21. Combining the first 2 ingredients
Luby+Parnas-Ron  nO(1) running time
But we want poly-logarithmic…
Run Luby’s algorithm a small num. of rounds [Marko-Ron]
Large independent set but not maximal…

22. 3rd ingredient: Beck’s idea
[Beck’91] Algorithmic approach to the Lovasz Local Lemma
First run randomized algorithm to get a “partially good” solution
Show that remaining problems are small enough for brute-force search

23. Two-phase algorithm
Phase 1: run Luby’s algorithm for O(d log d) rounds
Hope: remaining graph has only small components
Phase 2: run greedy (LFMIS) on the connected components in which vi lies

24. Original graph

25. After Phase 1

26. Running Phase 2

27. Running Phase 2

28. After Phase 2

29. Why fast? Phase 1
Apply Parnas-Ron reduction to this local distributed algorithm
Number of rounds is O(d·log d) (instead of O(log n))
Running time of Phase 1 is dO(d·log d)

30. Why fast? Phase 2
Main Lemma: With prob. at least 1-1/n, after running Luby’s algorithm O(d·log d) rounds, all connected components of surviving vertices are of size O(poly(d)·log n)
Proof: “Beck-like” analysis
Running time of Phase 2 is O(poly(d)·log n)

31. 4th ingredient: k-wise independence Making the space complexity small
What about consistency?
Remember all previous random bits used in Luby’s algorithm (each vertex, each round)
Naïve implementation: linear space
But our algorithm is local…
O(log n)-wise independence suffices for Beck
(Alon-Babai-Itai) k-wise independent random variables with seed length O(k·log n)

32. Put everything together…
Theorem: For any degree-bounded graph, there is an (O(log n), O(log2n), 1/n) local computation algorithm for MIS.

33. Part 3: Hypergraph coloring
Hypergraph H=(V, E)
V: finite set of vertices
E: a family of subsets of V (called edge)
H is k-uniform (every edge is of size k)
every edge intersects at most d other edges
Size of the problem: N=# of edges
H is 2-colorable if we can color all the vertices red and blue so that no edge is monochromatic

34. A 3-regular hypergraph

35. 1st ingredient: Alon’s algorithm
(Beck’91, Alon’91) Under certain conditions, there is a quasi-linear algorithm that finds a two-coloring of a hypergraph
The algorithm runs in 2 (or 3) phases, depending on performance requirement

36. Overview of Alon’s algorithm
Phase 1 coloring
Uniformly at random color all vertices sequentially
An edge becomes dangerous if too many of its vertices colored monochromatically
Save all the rest uncolored vertices in that edge
An edge is called survived if it does not have both colors at the end of Phase 1
Phase 2 coloring
brute-force search for a 2-coloring for each connected component of survived edges

37. Phase 1 coloring

38. Phase 1 coloring

39. Phase 1 coloring

40. Phase 1 coloring

41. Phase 1 coloring

42. Phase 2 coloring

43. Phase 2 coloring

44. Overview of Alon’s algorithm
Key Lemma: At the end of Phase 1, almost surely all connected components of survived edges are of size O(log N)

45. A simple observation
Alon’s algorithm works for any ordering of the vertices
So we can simply take the order that queries arrive!

46. Are we done?
Space complexity can be linear as we need to “remember” all previous answers
Not query-oblivious

47. New algorithm Run Alon’s algorithm
Instead of using query order to color vertices
Use random ranking order [Nguyen-Onak]
Recursively color only vertices that we have to

48. 2nd ingredient: Nguyen-Onak
Randomly assign a rank r(v)2[0,1] for each vertex
v’s color depends only on color’s of neighbors with lower rank
In expectation, only need O(ed) recursive calls
But we need worst case bound

49. Coloring dependency

50. Coloring dependency

51. Coloring dependency

52. Query tree

53. Query tree
0.7
0.4
0.8
0.6

54. Query tree
0.7
0.4
0.6

55. Query tree
0.7
0.4
0.6
0.5
0.8
0.2
0.5
0.6
0.1

56. Query tree
0.7
0.4
0.6
0.5
0.2
0.1

57. Bounding the size of query tree
Query tree has bounded degree
H is k-uniform and each edge intersects at most d other edges  max. degree D=kd
Lemma: For any vertex v, with prob. at least 1-1/N2, the query tree rooted at v has size at most c(D)(log N)D+1 , where c(D) is some constant

58. Proof of the lemma
Partition the tree into (D+1) levels based on the values of their random ranks
Upper bound the sizes of trees on each level
Apply results in branching processes theory (Galton-Waton process)

59. 3rd ingredient: k-wise independent orderings
What about space complexity?
Obs. 1: the exact values of random ranks do not matter, only relative orderings do
Obs. 2: our computations are local, so limited independence suffices
Definition: An ordering function [N]  N is k-wise independent if for any index subset of size k, all the k! relative orderings of these k integers happen with equal prob.

60. Reducing the space complexity
Construction of k-wise independent ordering (seed length=polylog(N))
Replace true random strings with k-wise independent random strings for the random colors of vertices (k=O(log n), seed length=polylog(N))
total randomness is at most poly-logarithmic

61. Put everything together…
Theorem: under certain conditions, there is a (polylog n, polylog n, 1/n)-local computation algorithm for hypergraph coloring.

62. Conclusions Propose the notion of local computation algorithms (LCAs)
Develop some techniques for designing LCAs
Open question: LCAs for more problems?

63. Thank You!