Distributed Minimum Vertex Coloring and Maximum Independent Set in Chordal Graphs

We give deterministic distributed $(1+\epsilon)$-approximation algorithms for Minimum Vertex Coloring and Maximum Independent Set on chordal graphs in the LOCAL model. Our coloring algorithm runs in $O(\frac{1}{\epsilon} \log n)$ rounds, and our independent set algorithm has a runtime of $O(\frac{1}{\epsilon}\log(\frac{1}{\epsilon})\log^* n)$ rounds. For coloring, existing lower bounds imply that the dependencies on $\frac{1}{\epsilon}$ and $\log n$ are best possible. For independent set, we prove that $O(\frac{1}{\epsilon})$ rounds are necessary. Both our algorithms make use of a tree decomposition of the input chordal graph. They iteratively peel off interval subgraphs, which are identified via the tree decomposition of the input graph, thereby partitioning the vertex set into $O(\log n)$ layers. For coloring, each interval graph is colored independently, which results in various coloring conflicts between the layers. These conflicts are then resolved in a separate phase, using the particular structure of our partitioning. For independent set, only the first $O( \log \frac{1}{\epsilon})$ layers are required as they already contain a large enough independent set. We develop a $(1+\epsilon)$-approximation maximum independent set algorithm for interval graphs, which we then apply to those layers. This work raises the question as to how useful tree decompositions are for distributed computing.


Introduction
The LOCAL Model. In the LOCAL model of distributed computation, the input graph G = (V, E) represents a communication network, where every network node hosts a computational entity. Nodes have unique IDs. A distributed algorithm is executed on all network nodes simultaneously and proceeds in discrete rounds. Initially, besides their own IDs, nodes only know their neighbors. Each round consists of a computation and a communication phase. In the computation phase, nodes are allowed to perform unlimited computations. In the communication phase, nodes can send individual messages of unbounded sizes to all their neighbors (and receive messages from them as well). The runtime of the algorithm is the total number of communication rounds, and the objective is to design algorithms that run in as few rounds as possible. The output is typically distributed: For vertex colorings, it is required that upon termination of the algorithm, every node knows its own color, and for independent sets, every node knows whether it participates in the independent set. Distributed Vertex Coloring. Vertex coloring problems have been studied in distributed computational models since more than 30 years (e.g. [11,18]). Given a graph G = (V, E), a (legal) c-coloring of G is an assignment γ : V → {1, 2, . . . , c} of at most c colors to the nodes of G such that every pair of adjacent nodes receives different colors. The algorithmic challenge lies in computing colorings with few colors. The chromatic number χ(G) is the smallest c such that there is a c-coloring of G. The Minimum Vertex Coloring problem (MVC) consists of finding a χ(G)-coloring and is one of the problems studied in this paper. This is a difficult task, even in the centralized setting: In general graphs, MVC is NP-complete [23] and hard to approximate within a factor of n 1− , for every > 0 [32].
Most research papers on distributed vertex coloring address the problem of computing a (∆ + 1)coloring, where ∆ is the maximum degree of the input graph. Sequentially, a simple greedy algorithm that traverses the nodes in arbitrary order and assigns the smallest color possible solves this problem. Distributively, this is a non-trivial task, and a long line of research has culminated in the randomized algorithm of Harris et al. [22], which runs in O( √ log ∆ + 2 O( √ log log n) ) rounds, and the deterministic algorithm of Fraigniaud et al. [14], which runs in O( √ ∆ log 2.5 ∆ + log * n) rounds. Only very few research papers address the MVC problem in a distributed model itself. On general graphs, the best distributed algorithm computes a O(log n)-approximation in O(log 2 n) rounds [4] and is based on the network decomposition of Linial and Saks [26]. This algorithm uses exponential time computations, which due to the computational hardness of MVC is necessary unless P = N P . Barenboim et al. [6] gave a O(n )-approximation algorithm that runs in exp O(1/ ) rounds. Both the exponential time computations and the relatively large best known approximation factor of O(log n) on general graphs motivate the study of special graph classes. Besides results on graph classes with bounded chromatic number (planar graphs [18] and graphs of bounded arboricity [5,17]), the only graph class with unbounded chromatic number that has been addressed in the literature are interval graphs, which are the intersection graphs of intervals on the line. Halldórsson and Konrad gave a (1 + )-approximation algorithm for MVC on interval graphs that runs in O( 1 log * n) rounds [21] (see also their previous work [20]). This work is the most relevant related work to our results. Distributed Independent Sets. An independent set in a graph G = (V, E) is a subset of nonadjacent nodes I ⊆ V . Algorithms for independent sets are usually designed with one of the following two objectives in mind: (1) Compute a maximal independent set, i.e., an independent set I that cannot be enlarged by adding a node outside I to it, or (2) Compute a Maximum Independent Set (MIS) (or an approximation thereof), i.e., an independent set of maximum size, which is the variant studied in this paper. Similar to MVC, the MIS problem is NP-complete [23] and hard to approximate within a factor of n 1− , for every > 0 [32]. In the distributed setting, Luby [27] and independently Alon et al. [1] gave distributed O(log n) rounds maximal independent set algorithms more than 30 years ago. Improved results are possible for graphs with bounded maximum degree ( [7,15]) or on specific graph classes (e.g. [11,31]). Using exponential time computations, a (1 + )-approximation to MIS can be computed in general graphs in O( 1 log n) rounds [10] (see also [16]). Deterministic distributed MIS algorithms may be inferior to randomized ones: It is known that every deterministic MIS O(1)approximation algorithm on a path requires Ω(log * n) rounds [24,12], while a simple randomized O(1) rounds O(1)-approximation algorithm exists [12]. Chordal Graphs. In this paper, we study MVC and MIS on chordal graphs. A graph is chordal, if every cycle on at least four nodes contains a chord, i.e., an edge different from the edges of the cycle connecting two nodes of the cycle. Chordal graphs play an important role in graph theory and have many applications, for example in belief propagation in machine learning (e.g. the Junction Tree algorithm). They constitute a superclass of interval graphs and trees and an inportant subclass of perfect graphs. The key motivations for our work are as follows: 1. Minimum Vertex Colorings. Since the best known distributed MVC algorithm only gives a O(log n)-approximation, we are interested in pinpointing graph structures that are difficult to handle. In this paper, we show that MVC and MIS can both be well solved on chordal graphs. A defining feature of a chordal graph is that it does not contain any induced cycles of lengths at least 4. This in turn implies that difficult instances for distributed coloring necessarily contain induced cycles of length at least 4.
Furthermore, as previously mentioned, MVC can be solved well on interval graphs in the distributed setting [21]. We are therefore interested in identifying more general graph classes that admit distributed (1 + )-approximation algorithms for MVC. Since trees are chordal, Linial's lower bound for coloring trees applies [25]. Linial proved that coloring trees with a constant number of colors requires Ω(log n) rounds, which gives a Ω(log n) lower bound for any constant factor approximation to MVC on chordal graphs. This separates the difficulties of MVC on chordal and interval graphs. Furthermore, Halldórsson and Konrad proved that a (1 + )-approximation to MVC on interval graphs requires Ω( 1 ) rounds [21]. Combined, we obtain a Ω( 1 + log n) lower bound on the round complexity for approximating MVC on chordal graphs within a factor of 1 + .
2. Tree Decompositions. Tree decompositions are a powerful algorithmic tool that allow for the design of (centralized) linear time algorithms for NP-hard problems on graphs of bounded tree-width (see below for precise definitions) [3]. They have played however only a minor role in the design of distributed algorithms (few exceptions are [19,2,28]). A tree decomposition of a graph G = (V, E) is identified by a set of bags S 1 , S 2 , · · · ⊆ V that are arranged in a tree T such that every adjacent pair of nodes uv ∈ E is contained in at least one bag, and, for any v ∈ V , the set of bags that contain v induces a subtree in T . One potential reason for the limited success of tree decompositions as a tool for distributed computing is that even simple graphs, such as a ring on n nodes, require that many bags of their tree decompositions consist of nodes that are at distance Ω(n) in the original graph. For these graphs, it is thus impossible that nodes obtain coherent local views of a global tree decomposition in o(n) rounds.
Chordal graphs are well-suited for studying distributed algorithms that exploit the input graph's tree decomposition, since in a chordal graph G, each bag consists of a clique in G. Thus, every bag that contains a node v ∈ V further only contains nodes that lie in v's neighborhood. We exploit this locality property and show that in the LOCAL model, nodes can indeed obtain coherent local views of a global tree decomposition. Results. In this paper, we give deterministic distributed (1 + )-approximation algorithms for MVC and MIS on chordal graphs in the LOCAL model. Our algorithm for MVC runs in O( 1 log n) rounds (Theorem 4), and our algorithm for MIS has a runtime of O( 1 log( 1 ) log * n) rounds (Theorem 8). For MVC, as mentioned above, the dependencies of the runtime on log n and 1 are best possible (though the existance of an algorithm with runtine O( 1 + log n) is not ruled out). For MIS, we prove that every possibly randomized (1 + )-approximation algorithm requires Ω( 1 ) rounds, even on paths (Theorem 9). Techniques. Our algorithms for MVC and MIS first compute the tree decomposition of the input chordal graph. Every chordal graph G = (V, E) can be represented as the intersection graph of subtrees of a tree T . In this representation, every node v ∈ V is identified with a subtree T (v) ⊆ T such that for nodes u, v ∈ V , subtrees T (u) and T (v) intersect if and only if uv ∈ E.
We then distributively run the following peeling process: In each iteration i, we first identify the family L i of all pendant (i.e., incident to at least one leaf) and all long enough paths in the tree decomposition (for an appropriate notion of 'long enough'), such that every path consists of vertices of degree at most 2. We then peel off those nodes from the current graph whose corresponding subtrees in the tree decomposition are subpaths of the paths in L i . The removed nodes V i define layer i. We prove that after O(log n) iterations of the peeling process, all nodes are assigned into layers. This partitioning has the useful property that every layer V i induces an interval graph in G. We can thus use distributed algorithms designed for interval graphs on those layers.
For MVC, we use the algorithm of Halldórsson and Konrad [21] to color these layers individually and independently in O( 1 log * n) rounds, which results in various coloring conflicts between the layers. These are then resolved in a separate phase, using the particular structure of the layers.
For MIS, we only compute the first O(log 1 ) layers of the partitioning, since they already contain a large enough independent set for a (1 + )-approximation. In order to compute a large independent set in each layer, we first design a (1 + )-approximation O( 1 log * n) rounds algorithm for MIS on interval graphs, which is then executed on these layers. Outline. We proceed as follows. In Section 2, we give notation and definitions. We then discuss in Section 3 how network nodes can obtain coherent local views of the tree decomposition. A centralized (1+ )-approximation MVC algorithm is then presented in Section 4, and a distributed implementation of this algorithm is given in Section 5. In Section 6, we provide a distributed (1 + )-approximation MIS algorithm for interval graphs, which is then employed in Section 7 to design a distributed (1 + )approximation MIS algorithm for chordal graphs. We complement the latter result in Section 8 by proving that Ω( 1 ) rounds are required for computing a (1 + )-approximation to MIS, even on paths. Finally, we conclude in Section 9.

Preliminaries
Notation and Definitions for Graphs. Let G = (V, E) be a graph. For a node v ∈ V , we denote by i.e., the set of nodes at distance at most k from v in G, is denoted Γ k G (v). The subgraph of G induced by a set of nodes U is denoted by G[U ]. A set of pairwise adjacent (resp., non-adjacent) nodes in G is called a clique (resp., an independent set). A clique (resp., an indepedent set) S is maximal if S ∪ {v} is not a clique (resp., an indepedent set), for every v ∈ V \ S. A maximum independent set in G is an independent set of maximum size. The cardinality of a maximum independent set is called the independence number of G and denoted by α(G). When the context is clear, instead of α(G[S]) we will simply write α(S). A graph is chordal if every cycle of length at least four contains a chord, i.e., an edge that connects two non-consecutive nodes of the cycle. It is a well-known fact that an n-node chordal graph has at most n maximal cliques. Tree Decomposition. A tree decomposition of an n-node graph G = (V, E) is a forest T = (S, E) whose vertex set S = {S 1 , S 2 , . . . , S n } is a family of subsets of V , and: 1. every node 1 v ∈ V belongs to at least one subset in S; 2. for every edge uv ∈ E, there is a subset S i ∈ S containing both nodes u and v; 3. for every node v ∈ V the family φ(T , v) ⊆ S of subsets containing v induces a tree in T , which we denote When the tree decomposition is clear from the context we will write φ(v) instead of φ(T , v). It follows from the definition that G is a subgraph of the intersection graph of the trees T (v). Tree Decomposition of Chordal Graphs. It is well known (see, e.g., [9]) that a graph G is chordal if and only if it has a tree decomposition T = (C, E) whose vertex set C is the family of maximal cliques of G. We call such a tree decomposition a clique forest of chordal graph G. Since every vertex of the clique forest is a clique, G coincides with the intersection graph of the subtrees T (v) of clique forest T . In other words, a clique forest of a chordal graph G is a forest T = (C, E) whose vertex set C is the family of maximal cliques of G, such that T [φ(v)] is a tree for every v. If a clique forest of a chordal graph is linear, i.e., a forest with every component being a path, then the graph is interval.

Theorem 1 ([13]). A chordal graph G is interval if and only if its clique forest is a linear forest.
Binary Paths. We say that a path v 1 , .
. For convenience, we consider an isolated vertex as a pendant path. A binary path v 1 , . . . , v k is an internal path, if deg G (v i ) = 2, for every i ∈ [k]. A binary/pendant/internal path is maximal if it cannot be enlarged by adding a vertex outside the path to it. Let G = (V, E) be a chordal graph with clique forest T = (C, E). Let P = C 1 , . . . , C k be a binary path in T . We define the diameter of P to be the maximum distance in G between nodes in C 1 ∪. . .∪C k , that is, diam(P) = max u∈Ci,v∈Cj ,i,j∈ [k] dist G (u, v). Similarly, we define the independence number of P as Distributed Algorithms for Interval Graph. Halldórsson and Konrad [21] gave a deterministic distributed algorithm for coloring interval graphs. For every ≥ 2 χ(G) , their algorithm computes a (1 + )-approximation to MVC in O( 1 log * n) rounds. We will reuse this algorithm and denote it by ColIntGraph( ).

Computing Local Views of the Clique Forest
Our algorithms make use of the clique forest of the input chordal graph. For network nodes to obtain a coherent view of the clique forest, we make use of the following maximum weight spanning forest characterization: With a chordal graph G we associate the weighted clique intersection graph W G whose vertex set is the family C of maximal cliques of G, and any two cliques C 1 , C 2 ∈ C with a nonempty intersection are connected by an edge with weight |C 1 ∩ C 2 |. Then: Observe that while the vertex set of a clique forest is unique, i.e., the family of maximal cliques of G, the edge set is not necessarily unique as there may be multiple different maximum weight spanning forests in W G . To obtain coherent local views of a clique forest, it is thus necessary that nodes agree on a unique maximum weight spanning forest in W G . This can be achieved by defining a linear order < on the edges of W G that respects the partial order given by the edge weights, and preferring edges that are larger with respect to <. To this end, we first assign to every maximal clique C ∈ C a word σ(C) over the alphabet of the identifiers of nodes, where σ(C) consists of the identifiers of the nodes in C listed in increasing order. Further, we associate with every edge e = C i C j a triple (w e , l e , h e ), where w e is the weight of e, i.e., w e = |C i ∩ C j |, l e = lexmin{σ(C i ), σ(C j )}, and h e = lexmax{σ(C i ), σ(C j )}. Now for two edges e and f we define e < f if and only if either w e < w f , or w e = w f and l e ≺ l f , or w e = w f , l e = l f and h e ≺ h f , where ≺ is the lexicographical order. Clearly, < orders the edges of W G linearly while preserving the weight order.
In what follows, when we say that T is the clique forest of a chordal graph G, we implicitly assume that it is the clique forest uniquely specified by the mechanism. Figure 2 demonstrates the weighted clique intersection graph and the clique forest of the chordal graph presented in Figure 1.
A maximum weight spanning forest has the following local optimality property: be a weighted graph with a unique maximum weight spanning forest F , and let U ⊆ V be a set of nodes inducing a tree T in F . Then G[U ] has a unique maximum weight spanning tree, which coincides with T .
Applied to a chordal graph and its clique forest, we thus obtain: This suggests a method for a node v ∈ V to compute a local view T of clique forest T : Suppose , v computes the family φ(u) of maximal cliques containing u (notice that a maximal clique that contains a node at distance d − 1 from v may include nodes at distance d). Then, v computes the maximum weight spanning forest in every W G [φ(u)] and adds the edges of this forest to T .

Minimum Vertex Coloring: Centralized Algorithm
In this section, we give a centralized (1 + )-approximation algorithm for MVC on chordal graphs. This algorithm will later be implemented in the LOCAL model in Section 5.

Algorithm
Our algorithm (Algorithm 1) consists of the pruning, the coloring, and the color correction phase: In the pruning phase, the node set V is partitioned into at most log n layers V 1 , . . . , V log n such that, for every i ∈ [ log n ], G[V i ] constitutes an interval graph. In each step of the pruning phase, we remove every node v ∈ U i from the current graph G[U i ] (we set U 1 = V and hence G[U 1 ] = G) whose corresponding subtree T (v) in the clique forest T i of G[U i ] is a subpath of a pendant path or an internal path of diameter at least 3k. The set of removed nodes is denoted V i , and G[V i ] forms an interval graph (which follows from Lemma 7). We prove in Lemma 5 that the clique forest T i+1 of the can be obtained by removing all pendant paths and all internal paths of diameter at least 3k from T i . We also show in Lemma 1 that the pruning process ends after at most log n iterations and thus creates at most log n layers.
In the coloring phase, each interval graph G[V i ] is colored with at most (1 + 1/k)χ(G[V i ]) + 1 colors. In the centralized setting, it would be easy to color these interval graphs optimally. However, since we will implement this algorithm later in the distributed setting, and an optimal coloring on interval graphs cannot be computed distributively in few rounds, we impose a weaker quality guarantee that can be achieved distributively. The colorings of different layers are computed independently from each other and do not give a coherent coloring of the entire input graph.
In the color correction phase, these incoherencies are corrected. To this end, the colors of V log n remain unchanged and we correct the layers iteratively, starting with layer log n − 1 and proceeding downwards to layer V 1 . In a general step, for every path P ∈ L i , we show that the subgraph induced by the nodes W ⊆ V i whose subtrees are subpaths of P forms an interval graph together with those nodes in j≥i+1 V j that have coloring conflicts towards W (Lemma 8). Notice that each path P connects to at most two maximal cliques in T i . The neighborhood of W thus consists of subsets of these (at most two) cliques, which further implies that all conflicting nodes in j≥i+1 V j are included in these cliques      Input: G = (V, E) is an n-node chordal graph with clique forest T = (C, E); a parameter > 2 χ(G) . Set k = 2/ .

Pruning Phase.
Let (a) Let L i be the set that contains all maximal pendant paths of T i , and all maximal internal paths of T i of diameter at least 3k.
2. Coloring Phase. for i = 1, 2, . . . , log n do: for each path P ∈ L i do: is an interval graph. Applying Lemma 10, we recolor those nodes of W that are at distance at most k + 3 from some node in W using at most as well. We then reuse a recoloring result previously proved by Halldórsson and Konrad [21], which shows that we can resolve all conflicts by changing the colors of those nodes in W that are at distance at most k + 3 from the (at most) two conflicting cliques.

Analysis
In the first part of our analysis, we show that throughout the algorithm, T i+1 as computed in Step 1(c) is the (unique) tree decomposition of G[U i+1 ]. Recall that U i+1 is obtained from U i by removing nodes whose corresponding subtrees in the tree decomposition T i are contained in pendant and internal paths. We prove that it is enough to remove the pendant and internal paths from T i in order to obtain T i+1 . This is an important property as it allows us to bound the number of iterations required to partition all nodes into layers. We first address internal paths in Lemma 3 (see Figures 5 and 6 for an illustration), and then state a similar result for pendant paths in Lemma 4.
Proof. Notice that the condition diam(P) ≥ 4 implies that no node in C s is adjacent to a node in C e , and, in particular, The uniqueness of T then follows from the uniqueness of T . First, we show that , and since no node in C s is adjacent to a node in C e , we have that for every Therefore, by removing from G the nodes in U we destroy the maximal cliques C 1 , C 2 , . . . , C k , and do not affect the others. It remains to show that T (v) is a tree for every v ∈ V \ U . Assume to the contrary, that T (v) is disconnected for some v ∈ V \ U . Since T (v) is a tree, and T (v) = T (v) − P, we conclude that v belongs to both C s and C e . But this contradicts the disjointness of C s and C e . Hence the lemma.   Using essentially the same argument, a similar lemma for pendant paths can be obtained: Proof. We prove this statement by induction on i. The base case i = 1 follows by definition of T 1 (recall that T 1 = T and U 1 = V ). For the induction step, we apply Lemma 3 for every internal path in L i of diameter at least 3k, and Lemma 4 for every pendant path in L i .
Using the fact that T i+1 is obtained from T i by removing all pendant and some internal paths, we show now that the first phase of our algorithm requires at most log n iterations. This is a consequence of the following pruning lemma: Lemma 6 (Pruning Lemma). Let T 1 be an n-node forest, and for every i ≥ 2, let T i be a forest obtained from T i−1 by removing all its maximal pendant paths and some of its maximal internal paths. Then T i has less than n/2 i nodes of degree at least 3. In particular, T log n +1 has no nodes.
Proof. The maximality of the removed paths implies that the nodes of degree at most 1 in T i have degree at least 3 in T i−1 . Therefore denoting by L i and A i the set of nodes of degree at most 1 and the set of nodes of degree at least 3 in T i , respectively, we have Since the number of nodes of degree at least 3 in a forest is less than the number of nodes of degree at most 1, we have that |A 1 | < n/2. For the same reason |A i | < |L i |, which together with inequality (1) implies |A i | < |A i−1 |/2 for every i ≥ 2. This implies the lemma.
Corollary 1. Phase 1 in Algorithm 1 requires at most log n iterations, i.e., 1≤i≤ log n V i = V .
Next, we address the color correction phase. In each iteration of this phase we consider every path P ∈ L i independently. The subgraph induced by the set of nodes W ⊆ V i whose corresponding trees are subpaths of P is legally colored in the coloring phase. This coloring may be inconsistent with the coloring of subgraph G[U i+1 ]. We first prove in Lemma 8 that the set W ⊆ s>i V s = U i+1 of neighbors of W in G[U i+1 ] (i.e., the nodes in U i+1 that could potentially cause conflicts) is the union of at most two cliques, which are included in the end vertices of the clique forest of interval graph G[W ∪ W ]. This lemma makes use of Lemma 7, which shows that the set of nodes whose corresponding subtrees in T i are contained in an arbitrary path in T i form an interval graph.
Lemma 7. Let T = (C, E) be the clique forest of a chordal graph G = (V, E). Let P = C 1 , C 2 , . . . , C k be a path in T , and let V P = k i=1 C i be the set of nodes whose corresponding subtrees intersect with P. Then P is the clique forest of G[V P ], and G[V P ] is an interval graph. Proof. First, notice that W ∪ W is a subset of nodes v whose subtrees T (v) intersect with P. Hence, it follows from Lemma 7 that G[W ∪ W ] is an interval graph. Let now P be an internal path. It follows from the definition of clique forest that W is a subset of C s ∪ C e . Since W ∪ C s ∪ C e = k i=1 C i ∪ C s ∪ C e , and C s , C 1 , . . . , C k , C e is a path in T , by Lemma 7 graph G[W ∪ C s ∪ C e ] is an interval graph with the clique forest being path C s , C 1 , C 2 , . . . , C k , C e . As W ⊆ C s ∪ C e we conclude that G[W ∪ W ] is an interval graph as well. Finally, it is not hard to see that every node of W is necessarily contained in one of the end vertices of the clique forest of G[W ∪ W ]. The case of P being a pendant path is proved similarly.
In order to resolve these coloring conflicts we carry out a recoloring process on interval graph G[W ∪ W ] with fixed colorings of its 'boundary' cliques. To this end, we reuse a result by Halldórsson and Konrad [21]: 2 Lemma 9 (Halldórsson and Konrad [21]). Let G = (V, E) be an interval graph with its clique forest T = (C, E) being a path P = C 1 , C 2 , . . . , C k such that dist G (u, v) ≥ r for every pair of nodes u ∈ C 1 , v ∈ C k , for an integer r ≥ 5. Suppose that cliques C 1 and C k are legally colored using at most c colors. Then the coloring of G[C 1 ∪ C k ] can be extended to a legal coloring of G with at most max{ (1 + 1 r−3 )χ(G) + 1, c} colors. Equipped with Lemma 9, we now prove correctness of the color correction phase.
Lemma 10 (Recoloring Lemma). Consider the color correction phase (Step 3) of Algorithm 1. Let P ∈ L i be a path and let W ⊆ V i be the subset of nodes whose corresponding subtrees are included in P. Further, let W ⊆ s>i V s = U i+1 be the nodes in U i+1 that have neighbors in W . Suppose that W is colored using colors from the set [ (1 + 1/k)χ(G) + 1 ]. Then, we can recolor those nodes of W that are at distance at most k + 4 from W in G with colors from the set [ (1 + 1/k)χ(G) + 1 ] so that G[W ∪ W ] is legally colored.
Proof. By Lemma 8, G[W ∪ W ] is an interval graph and its clique forest is a path. Let P = C 1 , C 2 , . . . , C r denote this path. Lemma 8 also states that W ⊆ C 1 ∪ C r .
Let i be the minimum index such that dist(u, v) ≥ k + 3, for every u ∈ W ∩ C 1 and v ∈ C i . Then, by Lemma 9, the nodes of the cliques C 2 , . . . , C i−1 can be recolored using at most (1 + 1/k)χ(G) + 1 colors to resolve the coloring conflicts between W ∩ C 1 and W . Similarly, let j be the maximum index such that dist(u, v) ≥ k + 3, for every u ∈ W ∩ C r and v ∈ C j . Then, again by Lemma 9, the nodes of the cliques C j+1 , . . . , C r−1 can be recolored using at most (1 + 1/k)χ(G) + 1 colors to resolve the coloring conflicts between W ∩ C r and W .

Minimum Vertex Coloring: Distributed Implementation
We now give an implementation of Algorithm 1 in the LOCAL model.

Algorithm
The global behavior of our distributed algorithm, Algorithm 2, is identical to that of our centralized Algorithm 1. The main challenge lies in the coordination of the network nodes. One particular difficulty stems from the fact that network nodes are not aware of n, the total number of nodes, and thus do not know when the log n iterations of the pruning phase have completed. For this reason, nodes execute the three phases of Algorithm 1 asynchronously.
We will first present the pseudocode of our distributed algorithm, which is executed independently on every node v. Then we will describe each of the three phases in detail.

Algorithm 2. A distributed (1 + )-approximation algorithm, code for node v.
The Pruning Phase. In the pruning phase, the subroutine PruneTree is invoked and returns parameters l v , parent v , and children v , where l v is the layer of node v, and parent v and children v are variables necessary for the coordination of the color correction phase and are defined and explained further below. The pseudocode of PruneTree is given in Algorithm 3.
In each iteration of the while loop of PruneTree, one layer is removed from the clique forest of the input graph. To describe the global behavior of the algorithm, we will reuse the naming conventions already used in Algorithm 1. Let U 1 = V , and let V i ⊆ U i be the set of nodes removed in iteration i, i.e., assigned layer index i. Let also U i+1 = U i \ V i , and let L i be the set of maximal paths removed from the clique forest T i of G[U i ]. For convenience we will sometimes denote G[U i ] by G i . In each iteration i, first, each node v collects its distance-10k neighborhood. Then, v computes its local view of the clique forest T i of the graph induced by the nodes that have not yet been removed from the graph, i.e., of G[U i ] (as in Section 3). Next, nodes v are removed from G[U i ] and added to the current layer V i if its corresponding subtrees T i (v) are entirely contained in either a pendant path or a binary path of large enough diameter. This step is identical to Algorithm 1, and the exact same partitioning

Collect Γ 10k
G (v) together with variables l u and ID u , for every u ∈ Γ 10k G (v).

Compute local view of the clique forest
is a subpath of a binary path in T i of diameter at least 3k then Algorithm 3. PruneTree(), code for node v.
is computed. Nodes v that are removed in the current iteration store their parent in variable parent v , and nodes that remain in the graph potentially store some of the removed nodes as their children in variable children v . The notions of parent and child are defined as follows: Definition 1 (Parent, Child). Let v ∈ V i and let P be the maximal binary path in T i that contains Otherwise, let C be the vertex outside P in T i such that C is adjacent to an end vertex of P and dist G (v, C) is minimal. Let c be the node with maximum ID in C. Then the parent of v is defined to be c, if dist G (v, C) ≤ k + 3, and ⊥ otherwise. If c is the parent of v, then we say that v is the child of c.
The parent of node v is responsible for recoloring v in the color correction phase. Notice that a node v does not have a parent if the closest maximal clique outside v's path P is at least at distance k + 4 from v. In this case, the color that v will receive in the coloring phase is final and no color correction is needed for v. Recall that in the color correction phase of Algorithm 1, we only need to recolor nodes that are at distance at most k + 3 from the cliques that contain nodes with color conflicts. Finally, the subroutine returns the node's level l v , its parent parent v , and its children children v . The Coloring Phase. Notice that all nodes of layer i return from the subroutine PruneTree in the same round. They can hence invoke the coloring phase simultaneously. They run the algorithm ColIntGraph of Halldórsson and Konrad [21] and compute a coloring on G[V i ] that uses at most (1 + 1 k )χ(G[V i ] + 1 colors. This algorithm runs in O(k log * n) rounds. While some nodes execute the coloring phase, others still proceed with the execution of PruneTree. These nodes repeatedly collect their distance-10k neighborhood. This requires all other network nodes, in particular, nodes that already completed the first phase, to continuously forward messages. This can be taken care of in the background, and we will not address this type of implementation detail any further. The Color Correction Phase. In the color correction phase, nodes with assigned parents (i.e., nodes v with parent v = ⊥) first wait until they received their final color from their parents. Only then they proceed and correct the colors of their children. To this end, each such node v runs the subroutine CorrectChildren, which processes children v layer by layer, starting with layer l v − 1 down to 1. If v has children in layer V i , then it waits until all nodes adjacent to children v

Analysis
To ensure correctness of our algorithm, we need to show that the parent of a node v ∈ V i is contained in a layer j > i (Corollary 2). This is proved via the following lemma: Lemma 11. Let P ∈ L i , and let W ⊆ V i be the set of nodes whose corresponding subtrees are included in P. Then every node u ∈ Γ Gi (W ) is contained in a layer V j with j > i.
Proof. Notice that if a node v is assigned layer number i, then T i (v) is a subpath of a binary path in T i . Now let u ∈ Γ Gi (W ) be a neighbor of some node v ∈ W . Since u / ∈ W , T i (u) is not a subpath of P. On the other hand, the fact that u is a neighbor of v implies that u belongs to a vertex C of T i , which is adjacent to one of the end vertices of P. As P is a maximal binary path, C has degree at least 3 in T i . Therefore T i (u) is not a subpath of a binary path in T i , and hence u is not assigned a layer number in the i-th iteration, which implies the lemma.
It follows from the definition of parent that the parent of a node v ∈ V i belongs to Γ Gi (W ). Hence: We next demonstrate that Algorithm 2 mimics the behavior of our centralized algorithm and uses O( 1 log n) rounds. This establishes our main result, which is stated in Theorem 4. Proof. We first argue that Algorithm 2 computes the same node set partition as Algorithm 1. Indeed, a node assigns itself a layer number if the condition in Step 3 of the while loop in algorithm PruneTree is fulfilled. This condition is equivalent to the removal condition in Algorithm 1. Furthermore, note that the node's parent and the node's children are at distances at most k + 4 from a node. Since nodes possess knowledge about their distance-10k neighborhoods, computing and storing the parent and children can be done locally. Concerning the runtime, every node of layer i exits PruneTree after i iterations of the while loop, which each requires O(k) rounds. Since by Lemma 1 the number of layers is bounded by log n , after O(k log n) rounds, every node has returned from PruneTree.
Next, nodes of the same layer exit the first phase simultaneously and then execute the coloring algorithm ColIntGraph of Halldórsson and Konrad. This assigns each node v a color c v similar to Algorithm 1. Algorithm ColIntGraph runs in O(k log * n) rounds. Hence, overall after O(k log n) rounds, every node has completed the coloring step.
Let t max be the number of rounds when the last node has completed the coloring phase. Note that t max ≤ rk log n for some constant r. We prove by induction that after t max + iO(k) rounds, all nodes of layers log n − i, . . . , log n have received their final colors. First, observe that nodes of layer log n have received their final colors already in the coloring phase. Suppose now that all nodes of layers log n − i, . . . , log n have received their final colors. Let v ∈ V log n −i−1 be a node that has a parent u (otherwise, v has received its final color already in the coloring phase), let P ∈ L log n −i−1 be the path that contains T log n −i−1 (v), and let W be the set of nodes whose subtrees are contained in P. By Lemma 11, all neighbors of W outside W are contained in a layer with index greater than log n − i − 1, and hence, by the induction hypothesis, all of them have received their final colors after t max + iO(k) rounds. The same applies to v's parent u, by Corollary 2. Node u hence begins the execution of CorrectChildren no later than in iteration t max + iO(k) + 1. Since it takes at most O(k) rounds to collect the local neighborhood and inform nodes about their new colors, after t max + (i + 1)O(k) rounds, the nodes of layer V log n −i−1 have received their final color. This completes the induction.
Hence, the runtime of the algorithm is O(k log n) = O( 1 log n), which completes the proof.
Theorem 4. For every ≥ 2 χ(G) , there is a deterministic (1 + )-approximation algorithm for MVC on chordal graphs that runs in O( 1 log n) rounds in the LOCAL model.

Maximum Independent Set on Interval Graphs
As an intermediate step towards a distributed (1 + )-approximation algorithm for MIS on chordal graphs, we provide in this section a distributed (1 + )-approximation algorithm for MIS on interval graphs.

Centralized Algorithm
In this section we give a deterministic distributed (1 + )-approximation algorithm for MIS on interval graphs that runs in O( 1 log * n) rounds in the LOCAL model. Our algorithm is stated as a centralized algorithm in Algorithm 5. Its implementation in the LOCAL model is straightforward and will be discussed further below.
Let H = (V, E) be an interval graph. Let V P ⊆ V be the set of nodes v such that there exists a node u ∈ V with Γ H [v] Γ H [u]. Notice that nodes in V P can be ignored when computing a maximum independent set, since if a maximum independent set contains a node of V P , then there always exists a node outside V P that could be included instead. We therefore first remove from H all nodes in V P . It is easy to see that the resulting graph H is a proper interval graph, and therefore is a unit interval graph [30]. Next, we find a distance-k maximal independent set I 1 in H , and compute maximum independent sets between any two consecutive intervals in I 1 . As we will see from the analysis, the union of these maximum independent sets gives us a desired approximate maximum independent set in H.
To construct a distance-k maximal independent set in a unit interval graph we employ the fact that for any natural number k, the k-th power of a unit interval graph is a unit interval graph [29]. We use the O(log * n) rounds distributed algorithm of Schneider and Wattenhofer [31], which can be used to compute a maximal independent set in a unit interval graph. We will denote the latter algorithm by MISUnitInterval.
Proof. Let k = 2.5/ + 0.5 . To prove the approximation factor it is enough to prove it for a maximal connected subgraph G of H. If diam(G) ≤ 10k, then the algorithm computes a maximum independent set. Therefore we assume that diam(G) > 10k. Let I * denote a maximum independent set in G, and let I * 1 ⊆ I * be those intervals that intersect with some interval in I 1 . Since G is a unit interval graph (in particular, claw-free), we have |I * 1 | ≤ 2|I 1 |. For every (u, v) ∈ P , let I * u,v ⊆ I * be those intervals that lie between u and v and are not adjacent to u and v. Then, I * u,v ⊆ V u,v holds, and, since I u,v is a maximum independent set in V u,v , we have |I * u,v | ≤ |I u,v |. Furthermore, let I * l , I * r ⊆ I * be the remaining intervals outside I * 1 ∪ (u,v)∈P I * u,v on the left of v l and on the right of v r , respectively. Then, |I * l | ≤ |I l | and |I * r | ≤ |I r |. Next, let β = (u,v)∈P |I u,v |. Observe that for every (u, v) ∈ P , we have |I u,v | ≥ (k − 3)/2. We thus obtain β ≥ |P |(k − 3)/2. Furthermore, notice that |I 1 | = |P | + 1. Finally, since diam(G) > 10k, we have |I 1 | ≥ 5 and hence |P | ≥ 4. This in turn implies that β ≥ 2(k − 3).
Using the inequalities argued above, we can bound the approximation factor as follows: Since k ≥ 2.5/ + 0.5, we obtain a (1 + )-approximation.
Remove from H all nodes v such that there exists a node u ∈ for every maximal connected subgraph G of the resulting graph do if diam(G) ≤ 10k then 1. Compute a maximum independent set I * of G.
2. I = I ∪ I * . else 1. Compute a distance-k maximal independent set I 1 in G (in the distributed setting simulate MISUnitInterval on G k in O(k log * n) rounds).
5. Furthermore, let v , v r ∈ I 1 be the left-most and right-most intervals of I 1 , respectively.
Interval v (v r ) computes a maximum independent set I (resp. I r ) using intervals located to the left (resp. right) of v (resp. v r ).
Algorithm 5. A deterministic centralized (1 + )-approximation algorithm for the maximum independent set problem in interval graphs.

Distributed Implementation
Observe that nodes v ∈ V can check locally both whether there exists a node u ∈ and whether the diameter of the input graph is at least 10k. Simulating algorithms on the k-th power of the input graph incurs an additional factor of k in the round complexity. All steps except the computation of the distance-k independent set require O(k) rounds, while the latter requires O(k log * n) rounds. This gives the following theorem: Theorem 6. For every > 0, there is a deterministic (1 + )-approximation algorithm for MIS on interval graphs that operates in O( 1 log * n) rounds in the LOCAL model.

Maximum Independent Set on Chordal Graphs
In this section we present a distributed (1 + )-approximation algorithm for MIS on chordal graphs that runs in O( 1 log( 1 ) log * n) rounds in the LOCAL model. Similarly to Minimum Vertex Coloring, we first provide and analyze a centralized algorithm (Sections 7.1 and 7.2), and then briefly discuss a distributed implementation of the algorithm (Section 7.3).

Centralized Algorithm
Similar to our coloring algorithm, we iteratively peel off binary paths from the clique forest of an input graph. However, instead of peeling off all layers in O(log n) iterations, we stop after k iterations, for some k = Θ(log 1 ). We will show that the set of removed nodes in these k iterations already contains an almost optimal independent set. For convenience, we denote by At each iteration i < k, we first compute the set L i of maximal pendant paths and maximal internal paths of diameter at least 2d + 3, where d is an integer depending on . Then, for every path P ∈ L i we calculate an independent set I P in the subgraph G i [W P \ Γ G [I]] induced by those nodes v, whose trees T i (v) are contained in P, and which have no neighbors in the set I of nodes that have already been included in the final independent set at the previous iterations. Note that by Lemma 7 graph G i [W P \ Γ G [I]] is an interval graph. We compute an independent set I P by computing an independent set in every maximal connected subgraph H of G i [W P \ Γ G [I]]. In order to achieve the desired approximation factor, in graphs H of independence number at least d we compute a (1 + /8)-approximate independent set using a distributed implementation of the algorithm for interval graphs given in Section 6.1. In each graph H of independence number less than d, we compute an absorbing maximum independent set, i.e., a maximum independent set I H possessing the property that To explain how such a maximum independent set can be constructed, we first observe that if α(H) < d, then nodes of H can have neighbors in at most one vertex of T i outside P. This is clearly true if P is pendant. Now suppose that P = C 1 , C 2 , . . . , C k is an internal path connected to T i by edges C s C 1 and C k C e , and assume that H contains a node that has a neighbor in C s , and a node that has a neighbor in C e . Then, since G[C s ∪ C 1 ∪ . . . ∪ C k ∪ C e ] is an interval graph, it is not hard to see that diam(P) ≤ diam(H) + 4. Further, notice that the diameter of H is at most 2(d − 1), as its independence number is at most d − 1. Therefore diam(P) ≤ 2d + 2, which contradicts the assumption that diam(P) ≥ 2d + 3.
Now if no node of H has a neighbor in a vertex of T i outside P, then any maximum independent set of H is an absorbing maximum independent set. If H has a node with a neighbor in a vertex C of T i outside P, then it is not hard to see that an absorbing maximum independent set of H can be obtained by iteratively removing simplicial nodes (and their neighbors) in the order of their remoteness from C, i.e., the furthest node is removed first.
At the last iteration k, we do everything exactly as in the previous iterations except that L i is defined to be the set containing all maximal pendant paths of T k , and all maximal internal paths of independence number at least d. The reason for this is that we want to use maximal internal paths of large independence number to compute the final approximate independent set, but such paths could have small diameter which would not allow us to apply Lemma 3 to go easily from T i to T i+1 in the peeling process. Therefore we postpone the processing of paths of large independence number and small diameter until the last iteration, when it is no longer necessary to update the clique forest for the remaining graph. Notice that we utilized the lower bound on the diameter of maximal internal paths in the construction of an absorbing maximum independent set, and therefore, at the last iteration, we can not use the corresponding arguments. This is however not a problem, as we do not need the absorption property in the last iteration, and we compute arbitrary maximum independent sets for graphs H with α(H) < d.

Analysis
Let a i be the number vertices of degree at least 3 in T i .
Proof. Let l 1 be the number vertices of degree at most 1 in T 1 . It holds α(G) ≥ l 1 ≥ a 1 . The latter inequality follows from the fact that the number of vertices of degree at least 3 in a forest is less than the number of vertices of degree at most 1. The former inequality follows from the fact that every vertex of degree at most one in T 1 contains at least one node that belongs only to this vertex, and hence the union of these nodes forms an independent set.
Proof. It follows from the proof of Lemma 6 that a k ≤ a1 2 k−1 . Hence. using Lemma 13 we derive Now, according to Algorithm 6, G k+1 is obtained from G k by removing nodes w such that T k (w) is a subpath of a maximal pendant path or a maximal internal path of independence number at least d. Therefore, every node of G k+1 belongs to a vertex in T k of degree at least 3, or to a vertex of a maximal internal path in T k of independence number less than d. Since there are at most a k − 1 maximal internal path in T k , we conclude that α(G k+1 ) ≤ (d − 1)(a k − 1) + a k ≤ da k , which together with (2) implies the result.
Let T i+1 be the forest obtained from T i by removing all paths in L i . As proved in Lemma 5, T i+1 is the clique forest of G i+1 .
(d) Update the independent set: I = I ∪ I i .
Return I Algorithm 6. A deterministic centralized (1 + )-approximation algorithm for the maximum independent set problem in chordal graphs.
. In order to show that |I * ≤k | ≤ (1 + 4 )|I| holds, we assign to each binary path P ∈ L i a subset of nodes V P = (W P ∪ Γ Gi [I P ]) \ S i−1 , if i < k, and V P = W P \ S i−1 , if i = k. It is easy to see that It thus remains to show that α(V P ) ≤ (1 + /4)|I P | holds, for every P ∈ k i=1 L i . Let first i < k. We distinguish two cases: 1. α(W P \ S i−1 ) < d. In this case, the algorithm computes an absorbing maximum independent set I P in G i [W P \ S i−1 ], and hence |I P | = α(Γ Gi [I P ] \ S i−1 ) = α((W P ∪ Γ Gi [I P ]) \ S i−1 ) = α(V P ).
For i = k the above analysis becomes simpler, as V P = W P \ S i−1 , and we omit the details.

Distributed Implementation
We will argue now that Algorithm 6 can be implemented in the LOCAL model in O( 1 log( 1 ) log * n) rounds.
Most of the techniques used in this implementation have already been employed in our distributed coloring algorithm, and we therefore omit a lengthy exposition.
Similar to the coloring algorithm, network nodes obtain local views of the clique forest and execute the peeling process, however, they stop after k = O(log 1 ) rounds. After each step of the peeling process, we compute independent sets in interval graphs corresponding to the removed maximal binary paths of the clique forest. In general, these interval graphs are disconnected, and we compute independent sets in every connected component in parallel. For components of small independence number, and therefore of small diameter, we compute the maximum independent sets, which are local operations requiring at most O(d) rounds. For components of large independence number, we compute approximate maximum independent sets in O( 1 log * n) rounds using Algorithm 5. The runtime is hence O( 1 log( 1 ) log * n).

Lower Bound on the Round Complexity for MIS
In this section we show that any randomized (1 + )-approximation algorithm for MIS in the LOCAL model requires Ω( 1 ) rounds, even on paths.
Let P n = (V, E) be the path on n nodes with V = {v 1 , v 2 , . . . , v n } and E = {v i v j | |i − j| = 1}. We assume that the path is labelled, i.e., every node v i is assigned a unique label (v i ), where is chosen uniformly at random from the set of bijections between V and {1, 2, . . . , n}. In the following proof, for i ≤ j we use the notation V i,j := {v i , v i+1 , . . . , v j }.
Theorem 9. For every > 0 and n large enough, every randomized algorithm in the LOCAL model with expected approximation factor at most 1 + for MIS requires Ω( 1 ) rounds.
Proof. Let A be an r-round distributed randomized algorithm for the maximum independent set problem with expected approximation ratio at most 1 + . Let I be the output independent set computed by A on P n . We define p i := P [v i ∈ I], where the probability is taken over the random bits of the algorithm and the labelling function. Then, by linearity of expectation, E|I| = i∈[n] p i . Since the size of a maximum independent set in P n is n/2 , and the expected approximation factor of A is at most 1 + , we have (1 + ) · i∈ [n] p i ≥ n/2 .
Next, notice that in r rounds, every node can only learn its local r-neighborhood. Hence, by symmetry, all nodes that are at distance at least r + 1 from the boundary of the path (i.e., from v 1 and v n ) have the same probability p to be chosen into the independent set, i.e., p i = p for every i ∈ {r + 2, r + 3, . . . , n − r − 1}. Since a maximum independent set in G[V r+2,n−r−1 ] is of size at most n−2r−2 2 + 1, we have p ≤ 1 2 + O( 1 n ). For every i ∈ {r + 2, r + 3, . . . , n − 3r − 3} we denote by X i the number of nodes of V i,i+2r+2 selected into I, i.e., X i = |V i,i+2r+2 ∩ I|. We will argue now that X i ≤ r + 5/4 + O( 1 n ). To this end, suppose first that the event v i ∈ I happens (which happens with probability p). Since the r-neighborhoods of v i and v i+2r+1 are disjoint, and the r-neighborhoods of v i and v i+2r+2 are disjoint too, it is equally likely that v i+2r+1 or v i+2r+2 will be selected into the independent set. Therefore, P [v i+2r+2 ∈ I | v i ∈ I] ≤ 1 2 . Notice that if v i+2r+2 / ∈ I, then X i ≤ r + 1. . Using this in inequality (4), we obtain:

Conclusion
In this paper, we gave distributed (1 + )-approximation algorithms for MVC and MIS on chordal graphs. We showed that in chordal graphs network nodes can obtain coherent views of a global tree decomposition, which enabled us to exploit the tree structure of the input graph for the design of algorithms. How can we extend the class of graphs on which we can solve MVC and MIS within a small approximation factor even further? In particular, how can we handle graphs that contain longer induced cycles, such as k-chordal graphs (for some integer k)?