# Deterministic Distributed Edge-Coloring with Fewer Colors

We present a deterministic distributed algorithm, in the LOCAL model, that computes a (1+o(1))Δ-edge-coloring in polylogarithmic-time, so long as the maximum degree Δ=Ω̃( n). For smaller Δ, we give a polylogarithmic-time 3Δ/2-edge-coloring. These are the first deterministic algorithms to go below the natural barrier of 2Δ-1 colors, and they improve significantly on the recent polylogarithmic-time (2Δ-1)(1+o(1))-edge-coloring of Ghaffari and Su [SODA'17] and the (2Δ-1)-edge-coloring of Fischer, Ghaffari, and Kuhn [FOCS'17], positively answering the main open question of the latter. The key technical ingredient of our algorithm is a simple and novel gradual packing of judiciously chosen near-maximum matchings, each of which becomes one of the color classes.

## Authors

• 24 publications
• 26 publications
• 21 publications
• 15 publications
• ### A Fast Distributed Algorithm for (Δ+ 1)-Edge-Coloring

We present a deterministic distributed algorithm in the LOCAL model that...
06/28/2020 ∙ by Anton Bernshteyn, et al. ∙ 0

• ### Towards the Locality of Vizing's Theorem

Vizing showed that it suffices to color the edges of a simple graph usin...
01/02/2019 ∙ by Hsin-Hao Su, et al. ∙ 0

• ### Distance-2 Coloring in the CONGEST Model

We give efficient randomized and deterministic distributed algorithms fo...
05/13/2020 ∙ by Magnus M. Halldorsson, et al. ∙ 0

• ### On Derandomizing Local Distributed Algorithms

The gap between the known randomized and deterministic local distributed...
11/06/2017 ∙ by Mohsen Ghaffari, et al. ∙ 0

• ### Girth-reducibility and the algorithmic barrier for coloring

All known efficient algorithms for constraint satisfaction problems are ...
04/05/2020 ∙ by Fotis Iliopoulos, et al. ∙ 0

• ### Distributed Edge Coloring in Time Quasi-Polylogarithmic in Delta

The problem of coloring the edges of an n-node graph of maximum degree Δ...
02/25/2020 ∙ by Alkida Balliu, et al. ∙ 0

• ### Classification of distributed binary labeling problems

We present a complete classification of the deterministic distributed ti...
11/29/2019 ∙ by Alkida Balliu, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction & Related Work

Edge-coloring is one of the four classic problems in the subarea of local distributed algorithms—along with vertex-coloring, maximal independent set (MIS), and maximal matching—which have been studied extensively since the 1980s; see, e.g., the distributed graph coloring book of Barenboim and Elkin [BE13]. While there are rather satisfactory randomized algorithms, finding efficient deterministic algorithms consitute some of the most well-known and central open questions of the area; see, e.g., the first five open problems of [BE13]. In this paper, we present efficient deterministic edge-coloring algorithms that use considerably fewer colors, for the first time going below the barrier of colors, where denotes the maximum degree.

### 1.1 Background

Model. We work with the standard model of distributed computing, usually attributed to Linial[Lin92]: the network is abstracted as an -node undirected graph , and each node is labeled with a unique -bit identifier. Communication happens in synchronous message passing rounds, where in each round each node can send a message to each of its neighbors. At the end of the algorithm, each node should output its own part of the solution, e.g., the colors of its incident edges in the edge-coloring problem. The time complexity of an algorithm is the number of synchronous rounds.

##### History, The Journey to Deterministic (2Δ−1)-Edge-Coloring:

Any graph with maximum degree at most admits a -edge-coloring, by a trivial sequential greedy algorithm. Moreover, a very simple randomized distributed algorithm, following from Luby’s 1986 MIS algorithm[Lub86, ABI86], can compute such a coloring in rounds. This made computing a -edge-coloring a natural first-target for deterministic distributed algorithms. However, in contrast to randomized algorithms, computing such a coloring deterministically and efficiently (in polylogarithmic time) remained an open problem for about 30 years (see, e.g., Open Problem 11.4 in the distributed graph coloring book[BE13]). Until very recently, the best known round complexity for -edge-coloring was by using an algorithm of [PS95b].

A brief recap of the concrete steps of progress is as follows: Since Linial’s pioneering 1987 paper [Lin92] and for many years, -colors was the best known palette size for polylogarithmic-time algorithms. Two intermediate steps of progress were polylogarithmic-time algorithms of Czygrinow et al.[CHK01] for -edge-coloring and that of Barenboim and Elkin[BE11] for -edge-coloring. More recently, a significant leap was made by Ghaffari and Su[GS17] who presented a -edge-coloring in polylogarithmic-time. Finally, the question was settled very recently when Fischer, Ghaffari and Kuhn [FGK17] presented a -round deterministic distributed algorithm for -edge-coloring. For -edge-coloring, a simpler and faster algorithm with time complexity was given recently by Ghaffari et al.[GHK17b].222Throughout the paper, we use to hide factors that are polynomial in .

In the special case where is assumed to be small and we investigate the complexity’s dependency on , the following results were presented for -edge-coloring: Panconesi and Rizzi [PR01] gave an -round algorithm. This was improved by Barenboim [Bar15] to and then further to by Fraigniaud, Heinrich and Kosowski [FHK16]. The last two results solve the more general problem of -vertex coloring problem.

##### Going Below 2Δ−1 Colors:

By a classic result of Vizing[Viz64, Bol98], any graph admits a -edge-coloring. However, the proofs of existence and the algorithms for computing such a coloring are fundamentally different from those for -edge-coloring: for instance, for coloring, any partial coloring can be extended to a full coloring of all edges, without altering the already colored edges; moreover, this is the smallest number of colors for which such an extension is always possible. Furthermore, all known proofs of -edge-coloring rely on very non-local arguments, in the sense that coloring one more edge may depend on the color of (and may end up recoloring) edges that are even -hops away.

Similarly, colors have been viewed as a natural barrier for deterministic edge-coloring algorithms and no such algorithm was known that uses (considerably) less than (formally less than colors), even for low-degree graphs. This remained a known open question since the 1990’s, see e.g., Panconesi and Srinivasan[PS92]. Note that in contrast, at least for low-degree graphs—e.g., when —computing a -edge-coloring is easy, and was known since Linial’s paper[Lin92].

Given that the -edge-coloring problem is solved, and noting this intrinsic change in the nature of the problem once we go below colors, an intriguing question that remained open, and was explicitly asked by Fischer et al.[FGK17], is

How close can we get to this [Vizing’s edge-coloring], while remaining in polylogarithmic-time?

### 1.2 Our Contributions

In this paper, we almost settle the above question. Concretely, we get a deterministic distributed coloring that is within a factor of Vizing’s bound, so long as , and for smaller degrees, we show how to get -edge-coloring. Below, we present the formal statement of the results—the precise constants in the exponents are not optimized and can be found in the technical section.

###### Theorem 1.1.

There is a constant such that for every there exist deterministic distributed algorithms that color the edges of any -node graph that has maximum degree at most with

• colors if in rounds

• colors for all in rounds.

We remark that the complexities stated above depend in a black-box manner on the complexity of computing hypergraph maximal matchings and ()-approximations of weighted maximum matching. Above, we have stated the bound based on the current state of the art, which are presented in the concurrent work [GHK17a]; our technical sections make this dependency explicit. If one prefers not to depend on this simultaneous work[GHK17a], we could use the solutions provided in [FGK17], and still obtain a polylogarithmic-time -edge coloring for arbitrarily small constant .

Another remark is that one can choose the parameter in Theorem 1.1 to be quite small, and as a result, can get a coloring with colors, as we formalize in the next corollary. This is interesting because the known randomized methods cannot go below the bound of colors, which is a natural barrier for those methods[CHL18]

, rooted in the standard deviations of the random nibble step.

###### Corollary 1.2.

There is a deterministic distributed algorithm that colors the edges of any -node graph with maximum degree at most with colors in rounds.

Finally, we note that in a recent simultaneous work, Ghaffari, Harris, and Kuhn[GHK17a] present a generic method for derandomizing local distributed algorithms. As we explain in Section 5, combining their result with the randomized edge coloring algorithm of [CHL18], we can obtain an alternative method for proving a slightly weaker version of the first part of Theorem 1.1. We still believe that the algorithm that we present in the main body of this paper has a number of advantages: (1) the lower bound on for which this method works is better, (2) it is much simpler, cleaner, and more comprehensible in comparison with the algorithm that comes out of the “automated” application of derandomization (via a certain method of conditional expectations) atop the non-trivially complex randomized algorithm of[CHL18], (3) the computations and communications in this main algorithm are simpler and more efficient, e.g., the algorithm fits in the model, modulo the part of ()-approximation of maximum-weight matchings, which itself can presumably be improved in the future to work in the model.

### 1.3 Our Method in a Nutshell

Here, we provide a brief outline of our -edge-coloring algorithm, which is made of two components. The latter of which is the main novelty of this paper. The first component is a splitting algorithm, borrowed from [GS17, GHK17b], which partitions the edge-set of the graph into roughly disjoint sets, each of which forms a spanning subgraph with max-degree . This effectively means that all that remains to be solved is -edge-coloring for graphs of maximum degree .

We now discuss our -edge-coloring for low-degree graphs, which is our main technical contribution. This algorithm is based on an iterative packing of judiciously crafted matchings, each of which will be one color class. To provide some intuition for this, let us consider a simple (though not ideal) algorithm for the easier objective of -edge-coloring: simply, for iterations, in each iteration , compute a maximal matching, color all of its edges with color , and remove them from the graph. This will color all the edges because in each iteration, for each remaining edge , either edge or at least one of its incident edges gets colored. To get to a -edge-coloring, our hope is that the matching computed in each iteration is more “expansive” and for each remaining edge (formally, some appropriate relaxation of this “for each” guarantee), the computed matching removes at least two of its incident edges. This way, the neighborhood of drops at a rate of two edges per iteration and thus, the edges in this neighborhood are expeced to get exhausted in about iterations, i.e., after about colors.

To gain more intuition, let us consider another hypothetical scenario, a bipartite -regular graph. This graph has a perfect matching [Alo03, Viz64]; if we could compute such a matching distributedly, we could remove it, remain with a bipartite -regular graph, and repeat, eventually ending with a -edge-coloring. However, we cannot compute a perfect matching efficiently in the distributed setting (this problem may need rounds). Our hope would be to use instead some near-maximum matching, but this creates some irregularity in the degrees, which can grow as we continue adding more and more matchings. Our algorithm follows a similar outline but has to be much more careful in managing these irregularities.

Concretely, the algorithm’s core is as follows: For simplicity, assume that is lower bounded by some sufficiently large polylogarithmic bound; the actual algorithm which optimizes this lower bound will need more care. For some iterations, in each iteration , we find a near-maximum matching with the following special property: For each , for the set of all nodes of degree at least , this single matching is incident on a -fraction of . We call such a structure a pervasive matching. One can see that for each , such a matching exists. The core technical challenge in our algorithm will be to find one matching that satisfies this property for all simultaneously. Our algorithm for computing a pervasive matching is abstracted by Lemma 2.1 and its proof appears in Section 2.1. After steps, as we will show, this will ensure that the maximum degree has reduced by about . Hence, repeating this idea will result in a -edge-coloring, in roughly iterations. Once the remaining degree becomes too small, say , we cannot find such a nice matching, but we clean up that case more coarsely, by just packing maximal matchings; we thus use about colors at that point, but this -factor is negligible overall and we still get a -edge-coloring.

Our -edge-coloring algorithm also has a similar iterative structure, but now each iteration extracts some special subgraph, called -graph, instead of a matching. This structure is such that (1) we are able to color its edges using colors, and (2) removing it reduces the maximum degree upper bound by an additive . The extraction of -graphs itself relies on the computation of a sequence of five maximal and maximum matchings of subgraphs of ; the latter is possible locally only thanks to the extra special properties of the bipartite graphs in consideration in those intermediate steps of the algorithm.

### 1.4 Other Related Work

Randomized Edge-Coloring Algorithms: The classic randomized MIS algorithm of Luby [Lub86, ABI86] leads to a randomized -edge-coloring algorithm with runtime . This was improved to by Barenboim et al. [BEPS12] and to by Harris, Schneider and Su [HSS16], both of which work also for the more general problem of -vertex-coloring. Fischer et al.[FGK17] gave a randomized -edge-coloring algorithm with complexity .

In contrast to the deterministic setting there are quite a few randomized algorithms which use fewer than colors. The first such result was by Panconesi and Srinivasan [PS92]; their result was later improved Dubhashi, Grable, Panconesi, to a -edge-coloring algorithm in polylogarithmic time with the restriction that . The time complexity for the same number of colors was improved Elkin, Pettie und Su to , [EPS15]. In [CHL18] Chang, He, Li, Pettie, and Uitto recently showed how to edge-color a graph with colors in where is the complexity of a permissive version of the constructive Lovász local lemma. We also refer to [CHL18] for a more detailed survey of randomized edge-coloring algorithms.

Lower bounds for Edge-Coloring: The celebrated round complexity lower bound of Linial’s[Lin92] still remains the only lower bound known for -edge-coloring [Lin92]. Recently, Chang et al.[CHL18] proved that -edge-coloring has lower bounds of for deterministic and for randomized algorithms. Moreover, one natural way to compute -edge-colorings is to extend partial colorings by iteratively recoloring edges along an ‘augmenting paths’. Chang et al.[CHL18] showed that with this ‘recoloring-along-a-path’ approach one might have to recolor nodes along paths of length to color a single additional edge.

Deterministic Edge-Coloring Algorithms for Low-Arboricity Graphs: In [BEM17] Barenboim, Elkin and Maimon gave a polylogarithmic-time determinisitc ()-edge-coloring for graph with arboricity , for a constant . This was then improved by Fischer et al.[FGK17] to -colors. Chang et al.[CHL18] present a -round -edge-coloring algorithm for trees.

Distributed Maximum Matching Approximation: Computing almost optimal matchings is at the core of our algorithms. The standard approach to -approximate the maximum matching problem is by Hopcroft and Karp [HK73]. The main obstacle to transfer the framework to a distributed setting is to find maximal sets of disjoint augmenting paths of length . Czygrinow and Hańćkowiak gave a deterministic algorithm that runs in time  [CH03], which was recently improved to by Fischer et al. [FGK17]. The most recent result by Ghaffari et al. [GHK17a] takes the -dependency out of the exponent, yielding a -time algorithm. On the randomized side, Lotker et al.[LPSP08] developed an -time -approximation for maximum matching (also see [LPSP08] for additional work on randomized distributed matching approximation).

## 2 Distributed Edge-Coloring Algorithm through Iterative Matchings

In this section, we first present the core of our matching algorithm which is especially efficient in graphs with intermediate degrees—e.g., polylogarithmic—and then, in Section 2.2, we explain how to lift this algorithm to higher degrees, with the help of splitting techniques[GS17, GHK17b]. Before proceeding to the algorithm we present some notations that we use to express our complexities.

##### Notation for the Complexity of Some Black-Box Subroutines

Our algorithm makes use of two subroutines in a black-box manner, and thus the final complexity of our algorithm depends on the complexity of the (best known) method for them. To express this complexity explicitly and illustrate the dependencies, we use some notation. We define to be the runtime of a hypergraph maximal matching algorithm with nodes, maximum degree at most and rank at most . The best known published bound is from [FGK17], roughly being , and an improvement to was recently provided by[GHK17a]. Moreover, we define for the runtime of a maximal -approximate weighted maximum matching on a simple graph with nodes and maximum degree at most ; we provide an upper bound on the latter in Lemma 2.5, which is at most .

##### Algorithm Outline.

Our edge-coloring algorithm constructs the color classes iteratively. In each iteration, the algorithm constructs a matching that hits—i.e., is incident on— a large fraction of all the nodes. In order to guarantee progress on all the nodes, when constructing the next matching, we make sure that the nodes that have been hit by fewer previous matchings are given more priority to be hit by the next matching.

More precisely, in step of the algorithm, we compute a single matching that simultaneously hits almost all of the nodes of degree at least for each (cf. Lemma 2.1, detailed proof in Section 2.1). Then, we color all edges of with an unused color and remove from the graph. If the initial maximum degree is large enough and we repeat this process for steps, the maximum degree will reduce by (cf. Lemma 2.2). Repeating this will eventually color the whole graph with few colors. The runtime of this algorithm is inherently at least as it computes the matchings sequentially and each matching corresponds to a single color class, i.e., it is only efficient for graphs with polylogarithmic degree. In Section 2.2 we show how degree splittings can be used to transform it into an efficient algorithm for all degrees. The following lemma is proved in detail in Section 2.1.

###### Lemma 2.1.

(The Pervasive Matching Lemma) Consider a graph with maximum degree at most and an integer . For every , there is an -round distributed algorithm to compute a maximal matching such that for every , hits a -fraction of all the nodes of degree at least , where exactly equals the maximum degree of .

We continue to prove that when starting with a sufficiently large maximum degree , we can reduce the maximum degree at a rate close to one by iteratively computing matchings with Lemma 2.1. For readability, we provide proof sketches explaining the main ideas and full proofs of the following two lemmas.

###### Lemma 2.2.

Assume that we have an -node graph with maximum degree at most . Then there is an algorithm that partially edge colors the graph with colors such that the maximum degree of the uncolored graph is at most .

For each of the colors, the algorithm has round complexity .

Algorithm: We start with all edges uncolored. In step , we choose the set of edges that are to be colored with color . Let be the graph induced by the set of uncolored edges after the first steps and let be the maximum degree of graph . With these definitions at hand, step of the algorithm uses a single invocation of Lemma 2.1 on to compute a maximal matching such that for each , covers at least a -fraction of all nodes with degree at least . We assign color to all edges in and remove them from the graph.

We first provide a proof sketch for the Lemma to indicate the main ideas of the proof. The full proof follows right afterwards.

###### Proof Sketch:.

The runtime of one step of the algorithm follows from the runtime of Lemma 2.1 with . In the rest of the proof we need to upper bound the maximum degree of the uncolored graph after steps.

It is essential that the matching in a single step of the algorithm hits at least a -fraction of the large degree nodes. If we assumed a stronger requirement on , e.g., , it is easy to see that

 Δ−T+1Δt+1≥Δ−T+1Δ+1=1−TΔ+1≥1−ε

holds, that is, the computed matching would hit at least a -fraction of the nodes of degree at least for all . With the weaker assumption on one has to carefully track to (at least) show that for all we have (subclaim in the full proof). Thus, the matching in step hits at least a -fraction, that is, at least a -fraction, of the nodes of degree at least for . Then, by an induction on the number of rounds, one can show that for all the number of nodes with degree at least after steps of the algorithm is less than  .

Finally, to prove the main claim of Lemma 2.2, we need to show that the number of nodes with degree at least after round is smaller than one. This holds because with we have

 (ti)⋅(2ε)i⋅n≤(eTi)i(2ε)i⋅n=(2eεTi)i⋅n (i>4eεT)< (12)4eεT⋅n T=⌈logn4eε⌉≤ 1. \qed

We now give a formal proof of the statement.

###### Proof.

The runtime of one step of the algorithm follows from the runtime of Lemma 2.1 with .

In the rest of the proof we upper bound the maximum degree of the uncolored graph after steps. For the statement holds as . So from now on we assume that .

For each and for all , define to be the number of nodes of degree at least after the first steps (i.e., in graph ). Note that for all .

We first show by induction on that for all and , the following holds

 K(t,i)≤(ti)⋅(2ε)i⋅n. (1)

Induction Base: Note that for (and any ) Equation 1 is trivial as it states that . Thus, Equation 1 also holds for because is the only possible value with .

Induction Step: Consider some step and . We first prove the following subclaim which is necessary to show that the computed matching hits a fraction that is very close to one of the nodes of degree at least .

Subclaim : .

###### Proof.

Let be the smallest integer such that . By the definition of , the maximum degree after steps is at most . Then the ratio simplifies to

 Δ−t+iΔt+1 ≥ Δ−t+iΔ−t+I+1 (i≥0)≥ Δ−tΔ−t+I+1 = 1−I+1Δ−t+I+1 I≥0≥ 1−I+1Δ−t+1.

To show the claim we now prove that holds. Using and we can first lower bound the denominator in the term.

 Δ−t+1≥2lognε−⌈logn4eε⌉+1≥2lognε−logn4eε=8e−14eε⋅logn . (2)

Next, we upper bound the nominator in the term, i.e., we upper bound . Let . If then by definition. Otherwise, by the induction hypothesis and using as well as , we have

 K(t−1,j)≤(t−1j)⋅(2ε)j⋅n < (2εe(t−1)j)j⋅n ≤ ⎛⎜⎝2εe⋅logn4eεj⎞⎟⎠j⋅n ≤ 1.

Thus, holds for . Hence, we obtain that .

With and the lower bound on from Equation 2 we obtain

 I+1Δ−t+1 ≤ ε⋅4e8e−1⋅logn+2logn ≤ ε .

The last inequality follows with .

Now, we can proceed with proving the induction step. Recall, that and are fixed. Then there are two different types of nodes of degree at least after step : Nodes of degree at least after step . Nodes of degree after step that are not hit by the matching computed in step . We now upper bound the number of nodes of each type.

1. [label=(0)]

2. By the definition there are nodes of type .

3. We show that there are at most nodes of type .

Note that lies in the range of when applying Lemma 2.1 as . Thus, by Lemma 2.1, of the nodes of degree at least after step , at least a -fraction is hit by the matching in step . The subclaim implies that this fraction is at least a -fraction.

The number of nodes that are not hit is therefore at most

Due to the bounds in and we obtain and plugging in the induction hypothesis leads to Equation 1 as follows.

 K(t,i)≤(t−1i)⋅(2ε)i⋅n+2ε⋅(t−1i−1)⋅(2ε)i−1⋅n = (t)i⋅(2ε)i⋅n.

This finishes the induction step.

Finally, to prove the main claim of Lemma 2.2, we show that , or equivalently that for , we have . Using Equation 1 and , we get

 K(T,i)<(eTi)i(2ε)i⋅n=(2eεTi)i⋅n (i>4eεT)< (12)4eεT⋅n≤ 1 .

The last inequality follows because . ∎

###### Lemma 2.3.

There is a constant such that for any there exists deterministic distributed algorithm that colors the edges of any -node graph with maximum degree at most with colors and has round complexity .

We first provide a proof sketch for a weaker result; the proof of the full result follows afterwards.

###### Proof Sketch.

In the full proof of the lemma one has to apply Lemma 2.2 with increasing values for and perform a careful analysis of the number of used colors. In this proof sketch we prove a slightly weaker result, i.e., we show that we can color the graph with colors if .

To obtain the desired result we apply Lemma 2.2 with until the current upper bound on the maximum degree that is guaranteed by the lemma falls below . Then perform a clean-up step in which the remaining uncolored graph is colored with colors, e.g., by computing further maximal matchings with Lemma 2.1. A single application of Lemma 2.2 uses at most colors, reduces the maximum degree of the graph by , and there are at most applications of the lemma. Thus, the total number of colors is bounded by

 K⋅T+2Δ′−1≤Δ−Δ′(1−4eε)+2Δ′≤(1+24ε)(Δ−Δ′)+2Δ′=Δ+O(ε)Δ .

Computing a single color class with Lemma 2.1 needs rounds. Thus, the runtime for the color classes is bound by . ∎

We continue with the full proof.

###### Proof.

Define the constant . For define , , the threshold degrees and where is the smallest such that holds. Then, the algorithm consists of phases and a clean-up step.

In phase we apply Lemma 2.2 with until the current upper bound of the maximum degree, which is guaranteed by the lemma, falls below . Then we continue to the next phase. Note that no node has to know the actual current maximum degree of the uncolored graph for this process. After phase the maximum degree of the remaining graph will be at most and we use the clean-up step to color the edges of the remaining graph with colors, e.g., by computing further maximal matchings with Lemma 2.1.

We now upper bound the number of used colors. For that purpose define . In phase a single application of Lemma 2.2 reduces the maximum degree of the graph by  , we use at most colors in each application of the lemma and there are at most applications of the lemma. Thus, the total number of colors used in phase is upper bounded by

 Ki⋅Ti=Δi−1−Δi(1−4eεi)≤(1+24εi)(Δi−1−Δi) .

During the phases and the clean-up step, we use

 l∑i=0(1+24εi)(Δi−1−Δi)+2Δl = (1+24ε′)Δ+l∑i=124εiΔi+Δl (∗) ≤ (1+24ε′)Δ+(48l+96)logn ≤ (1+24ε′)Δ+(48(log1/ε+3)+96)logn ≤ (1+24ε′)Δ+48log1/εlogn+240logn (∗∗) ≤ Δ+315εΔ+215εΔ+1015εΔ=(1+ε)Δ ,

that is, colors in total. At we used and . At we used and .

##### Runtime:

Computing a single color class in phase needs

rounds. As we compute color classes the total runtime is upper bounded by

 O(Δ⋅(logn/ε2+TWM(n,Δ,ε/2))) . \qed

Lemmas 2.2 and 2.3 are simpler to prove if we tolerate a larger dependency on in the lower bound for . However, with that increased dependency we would not only lose in the runtime but, more importantly, the number of colors could not go below (as in Section 2.3) regardless of the time that we spend.

### 2.1 Proof of The Pervasive Matching Lemma (Lemma 2.1)

In this section we prove Lemma 2.1. First, in Section 2.1.1 we prove that a simple consequence of Vizing’s edge coloring theorem (cf. Lemma 2.4) shows that for all there exists a maximum matching that hits at least a -fraction of the nodes with degree at least , where is the exact maximum degree of the graph. Then a distributed implementation of the weighted maximum matching approximation algorithm by Hougardy and Vinkemeier [HV06] (cf. Lemma 2.5) can be used to compute a matching that hits a -fraction of the nodes with degree at least (cf. Lemma 2.6). In Section 2.1.2 (Lemma 2.7) we first show how two matchings and where hits a -fraction of the nodes of degree at least and hits a -fraction of the nodes of degree at least can be combined into a single matching that has both properties. Then in Lemmas 2.1 and 2.8 we compute matchings for each and then use the Lemma 2.7 to iteratively combine them into the single matching while maintaining their properties.

#### 2.1.1 A Matching that Hits Most Nodes of One Target Node Set

A consequence of Vizing’s edge coloring theorem [Viz64, Bol98] shows that large maximum matchings exist. We use it to show that our maximum matching approximations hit enough nodes.

###### Lemma 2.4.

Given a graph and a node set . If the maximum degree of is and all nodes in have degree at least , there exists a matching of that hits at least of the nodes in .

###### Proof.

By Vizing’s theorem, the graph has an edge-coloring with colors. Hence, the graph contains disjoint matchings such that each node in is hit by at least of the matchings. On average, the matchings therefore hit at least nodes in . Consequently, one of the matchings has to hit at least nodes in . ∎

To prove the following lemma we essentially provide a distributed version of the weighted maximum matching approximation algorithm by Hougardy and Vinkemeier [HV06] that runs in the model. Its formal proof emphasizing the differences to the proof in [HV06] can be found in Section 4. As combination of Lemmas 2.4 and 2.5, one obtains a distributed algorithm that finds a matching that approximately satisfies the properties of the matching guaranteed to exist by Lemma 2.4.

###### Lemma 2.5.

Let be an -node graph with positive edge weights and let and denote the minimum and the maximum edge weight, respectively. If , then, for every , a maximal -approximate weighted matching can be computed in time

 TWM(n,Δ,ε)=O(1/ε2+(1/ε)⋅THM(n,ΔO(1/ε),1/ε)⋅logn+log3n) .
###### Lemma 2.6.

Given a graph and a node set . If all nodes in have degree at most and all nodes in have degree at least , then, for every , there is a distributed algorithm with time complexity that computes a matching that hits a -fraction of the nodes in , where exactly equals the maximum degree of .

###### Proof.

The problem of finding a matching of that hits as many nodes as possible of can be formulated as a maximum weighted matching problem as follows. We define the weight of an edge of as . Hence, the total weight of a matching is equal to the number of nodes in hit by . Thus, Lemma 2.4 implies that a -approximation of this maximum weighted matching problem gives a matching that hits at least a -fraction of the nodes in . By Lemma 2.5 such an approximate weighted matching can be computed in time . Note that when computing the matching, edges of weight can be ignored. ∎

#### 2.1.2 Combining Matchings while Maintaining their Properties

The core application (cf. the proof of Lemma 2.8) of the next lemma will be a combination of a matching that hits a large fraction of all nodes with a matching that hits a large fraction of a subset into a single matching that hits a large fraction of the nodes in and a large fraction of all nodes.

###### Lemma 2.7.

Given a graph and a node set . Assume that we are given two matchings and of such that matching hits at least nodes of . Then for every , in rounds, we can compute a matching such that

1. [label=()]

2. , i.e., for every node outside that is matched by and not matched by there is a node inside that is matched by and not matched by .

3. matches at least nodes of .

###### Proof.

We start with some notation, then present a simple algorithm that computes the matching , and finally show that the matching has the desired properties. At first restrict only to edges that have at least one node in . Throughout, we denote the edges in the symmetric difference of and as blue and green edges, i.e., denote edges in as blue edges and edges in as green edges. Let , and denote the nodes of that are matched by , and , respectively.

The subgraph induced by the blue and green edges contains alternating (in blue/green) paths and cycles as every node has at most one incident blue and green edge.

An (undirected) path is called alternating if its edges are blue and green in an alternating manner. An alternating path of length at least one is called a maximal alternating path if it cannot be extended to a longer alternating path. A maximal alternating path in which at least one of its endpoint-edges is blue is called a maximal augmenting path. Note that the graph induced by blue and green edges consists of alternating paths and cycles and that all nodes on an alternating cycle are matched by and . Further note that all maximal alternating paths are node disjoint.

Algorithm to compute :

• Add all edges of to .

• For every maximal augmenting path of length at most such that at least one of its endpoints lies in remove its green edges from , i.e., remove from , and add its blue edges to , i.e, add to .

The algorithm is well defined and as it only imposes changes on maximal augmenting paths of length at most it can be implemented by a distributed algorithm in rounds.

Analysis: Throughout the analysis and the set denote the sets after the execution of the algorithm.

Matching Property: The only edges that are changed are on (short) maximal augmenting paths. For a single maximal augmenting path, removing the green edges from the matching and adding the blue edges to the matching does not destroy the matching property as augmenting paths are alternating and the paths are maximal. Furthermore, all resulting maximal augmenting paths are node disjoint and thus, the operations on all maximal augmenting paths can be performed in parallel and still result in a matching. We continue with proving properties .

• As each maximal augmenting path begins with a blue edge the matching size does not decrease by switching the edges on an augmenting path.

Here we want to emphasize that the total number of matching edges in does not increase by handling an augmenting path if the path ends with a green edge. However, the term ’augmenting path’ is still valid in the sense that it increases the number of nodes within that are matched.

• We prove this property by finding one distinct node in for every node in . As we add all edges from to in step one of the algorithm a node can only be in if it became unmatched in step two, i.e., if was an endpoint of a maximal augmenting path and had an incident green edge before handling the path. However, then the other endpoint of the path had an incident blue edge (here we use that only maximal augmenting paths with one endpoint in perform changes) and is contained in . Thus, a simple induction on the number of handled maximal augmenting paths shows the result.

• Every node , i.e., a node in which is matched by but is not matched by at the end of the algorithm, has an incident blue edge and no incident green edge. Thus, it lies at the start of a maximal alternating path that starts with a blue edge. As is unmatched in , the path cannot be a maximal augmenting path of length at most . Because starts with a blue edge this implies that the length of is at least and contains at least nodes in . As all alternating paths are node disjoint and any path can have at most two endpoints this implies . Thus, we have  .∎

The next lemma proves the main distributed matching result that is needed to iteratively compute a good edge-coloring. For a given decreasing chain of node sets the lemma computes a single matching that hits a large fraction of the nodes in each . In its proof we use Lemma 2.5 to compute matchings such that hits a large fraction of . Then we use Lemma 2.7 to iteratively combine the matchings into a single matching while maintaining their properties.

###### Lemma 2.8.

Let be a graph with maximum degree at most . Further, assume that we are given disjoint nodes sets such that the minimum node degree of the nodes in is at least , where for all .

For every , there is a distributed -round algorithm that computes a maximal matching such that for every , hits an -fraction of the nodes in

 Ui:=t⋃j=iVj ,

where exactly equals the maximum degree of .

###### Proof.

First, for each we compute a matching that hits a -fraction of all nodes in by using Lemma 2.6 and the fact that all nodes in have degree at least . All of these matchings can be computed in parallel. Now, the matching is constructed inductively by applying Lemma 2.7 times. Formally, we iteratively construct matchings such that for each and each matching hits at least a -fraction of all nodes in . This proves the lemma as the matching satisfies all required conditions, except for the maximality. To obtain matching we extend to a maximal matching in time with the algorithm by Fischer [Fis17].

Inductive construction of : Set . For , set where is the result of applying Lemma 2.7 with , , and .

satisfy the required properties: The matching satisfies all the properties required for by its definition. Assume that satisfies the required properties for . We then need to show that the matching in the inductive construction of satisfies all the properties required for matching .

For , matches at least a -fraction of the nodes in : We already know that matches at least a -fraction of the nodes in . This is also true for matching because by Lemma 2.7, and for every node outside that is matched by and not matched by , there is a node in (and thus also in ) that is matched by and not by .

matches a -fraction of the nodes in : As matches a -fraction of the nodes in and because , it follows from Lemma 2.7 that matches a -fraction of the nodes in . Thus, the matching satisfies the required properties because .

Runtime: As mentioned above, we first construct matchings