Tuesday, April 8, 2008 * Synchronous network model * Vertex coloring problem * O(log^*n) algorithm for coloring trees and bounded-degree graphs * Omega(log*n) bound for rings SYNCHRONOUS NETWORK MODEL Thus far, we have discussed the impact of faults and asychnrony on computability of certain functions in distributed environments. Today we wil look at the impact of network topology. In the synchronous network model, all the nodes share a common clock. In each step, each node can do local computation and can communicate with each of its neighbors in one step. We assume that all nodes are fault-free and all messages are delivered in one step. We further assume that computation time is insignificant. So our focus is on time complexity -- the number of steps taken to complete some task. VERTEX COLORING Assign a color to each vertex such that no two adjacent vertices have the same color. Applications to resource allocation. The color can indicate the round in which the vertices can share a resource (e.g., frequency band in a wireless medium). Easy D+1-coloring algorithm, where D is the maximum degree. Each node selects a color from {1,...,D+1} that its neighbors do not have. If done sequentially, works perfectly. Basic Reduction Procedure: Suppose the vertices start with a valid coloring from {1,...,m} and are aware of D. For j <- m to D+2: If color of v is j, then v sets its color to first free color from {1,...,D+1}. Inform all neighbors of this choice. The above reduction procedure reduces colors from m to D+1 in m-D-1 rounds. TREES AND BOUNDED DEGREE GRAPHS 1. Start with an arbitrary coloring. 2. Repeat (a) l = |c(v)| (b) If v is root, then set c(v) = <0,c(v)[0]> else c(v) = where I is the smallest bit position where c(v) differs from c(parent(v)). (c) Inform all children of this choice. 3. until |c(v)| does not change. Claim: The coloring in each iteration is valid. Proof: Consider v. If I computed by v is same as that by parent, then the colors of v and parent are clearly different in the second component. Otherwise, they are different in the first component. End Proof Let K_i denote the number of bits in the color representation after i iterations. K_i <= ceil(log_2 K_{i-1}) + 1. So K_i < K_{i-1} as long as K_{i-1} >= 4. So when we stop, we have the first component with at most 3 values and the second component with 1 bit. A total of at most 6 different colors. We thus have a 6 coloring in log*n + 2 rounds. Can bring this down to 3 colors. Every node adopts the color of their parent. Color the root different from its current color. We can number the colors 1 through 6. Now we apply the basic reduction procedure three times to bring the number down to 3. -------- Extension to bounded-degree graphs: Each node v selects for each of its d neighbors w an index I_w such that c(v)[I_w] != c(w)[I_w], and sets its new color to . K-bit coloring becomes a D(ceil(log_2 K) + 1)-bit coloring. In O(log*n) steps, can bring the number of bits down to function of D alone. Thereafter, use basic reduction procedure to achieve (D+1)-coloring. -------- For arbitrary graphs, can produce a D+1-coloring in O(Dlog(n)) time. LOWER BOUND FOR 3-COLORING RINGS Purely information-theoretic lower bound. In t steps, a node becomes aware of its t-neighborhood. In particular, v ends up with a (2t+1)-tuple (x_1,...,x_{2t+1}) from the set W_{2t+1,n} where W_{s,n} = {(x_1,...,x_s): 1 <= x_i <= n, x_i != x_j}. We can view any t-step coloring algorithm as: (a) obtain the topological information from nodes within t steps; (b) select color c(v) as a function f of the information collected, where f is a function from W_{2t+1,n} -> {1,...,c_{max}}. Consider graph G_{s,n} = (W_{s,n}, E_{s,n}) where E_{s,n} is an edge from (x_1,x_2,...,x_s) to (x_2,...,x_s,x_{s+1}). Lemma: If the above algorithm produces a valid coloring for an n-vertex ring, then so does the function f for the graph G_{s,n}. Proof: Run the protocol on all possible ID assignments. Use the coloring function f. Suppose coloring is not valid for G_{s,n}. Then, there exist two adjacent nodes with same color. Use that id assignment to reach a contradiction. End Proof Main Lemma: X(G_{2t+1,n}) >= log^(2t) n. We will prove by showing that a subgraph of G_{2t+1,n} requires these many colors. Consider vertices W_{s,n} = {(x_1,...,x_s): 1 <= x_1 <= ...<= x_s <= n} with edge set (x_1,x_2,...,x_s) -> (x_2,...,x_s,x_{s+1}). Notion of coloring as for undirected graphs. Call these graphs D_{s,n}. Line graph of a directed graph G is a graph L(G) whose vertices are the edges of G and we have an edge (e_1,e_2) in L(G) if the head of e_1 equals the tail of e_2. Lemma: X(D_{s+1,n}) >= log(X(D_{s,n})) Proof: D_{s+1,n} is nothing but a line graph of D_{s,n}. So a coloring for D_{s+1,n} is in fact an edge coloring for D_{s,n}. Given a k-coloring c for D_{s+1,n}, set the color of a vertex v in D_{s,n} to be the set of colors of all incident outgoing edges as given by c. Note that c is an edge coloring for D_{s,n}. For contradiction, consider two vertices in D_{s,n} that are adjacent yet have the same color. They each have an outgoing edge with the same color -- a contradiction. Number of different colors is clearly at most 2^k. End Proof Since initial coloring size is at least n, we obtain an Omega(log*n) bound. KNOWN RESULTS -- For general graphs, D+1 coloring in O(D log(n)) time deterministic and O(log n) time randomized. -- Lower bound: only the Omega(log^* n) bound known. Other lower bounds known for special classes of algorithms. Omega(Delta+log^* n) running time for a special kind of algorithm. -- There is a lot of work on quantum Byzantine agreement and multi-party communication.