# Local Computation Algorithms

## Presentation on theme: "Local Computation Algorithms"— Presentation transcript:

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

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?

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!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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?

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

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

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…

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

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

Original graph

After Phase 1

Running Phase 2

Running Phase 2

After Phase 2

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)

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)

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)

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

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

A 3-regular hypergraph

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

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

Phase 1 coloring

Phase 1 coloring

Phase 1 coloring

Phase 1 coloring

Phase 1 coloring

Phase 2 coloring

Phase 2 coloring

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)

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

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

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

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

Coloring dependency

Coloring dependency

Coloring dependency

Query tree

Query tree 0.7 0.4 0.8 0.6

Query tree 0.7 0.4 0.6

Query tree 0.7 0.4 0.6 0.5 0.8 0.2 0.5 0.6 0.1

Query tree 0.7 0.4 0.6 0.5 0.2 0.1

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

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)

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.

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

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

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

Thank You!

Similar presentations