Distributed Approximate Maximum Matching in the CONGEST Model
D I S C
Distributed Approximate Maximum Matching in the CONGEST Model
Rotem Oshman 0 2
0 Tel Aviv University , Israel
1 University of Freiburg , Germany
2 Mohamad Ahmadi
We study distributed algorithms for the maximum matching problem in the CONGEST model, where each message must be bounded in size. We give new deterministic upper bounds, and a new lower bound on the problem. We begin by giving a distributed algorithm that computes an exact maximum (unweighted) matching in bipartite graphs, in O(n log n) rounds. Next, we give a distributed algorithm that approximates the fractional weighted maximum matching problem in general graphs. In a graph with maximum degree at most Δ, the algorithm computes a (1−ε)approximation for the problem in time O log(ΔW )/ε2 , where W is a bound on the ratio between the largest and the smallest edge weight. Next, we show a slightly improved and generalized version of the deterministic rounding algorithm of Fischer [DISC '17]. Given a fractional weighted maximum matching solution of value f for a given graph G, we show that in time O((log2(Δ) + log∗ n)/ε), the fractional solution can be turned into an integer solution of value at least (1 − ε)f for bipartite graphs and (1 − ε) · g−1 · f for general graphs, where g is the length of the shortest odd cycle of G. Together g with the above fractional maximum matching algorithm, this implies a deterministic algorithm that computes a (1 − ε) · g −g1 approximation for the weighted maximum matching problem in time O log(ΔW )/ε2 + (log2(Δ) + log∗ n)/ε . On the lowerbound front, we show that even for unweighted fractional maximum matching in bipartite graphs, computing an (1 − O(1/√n))approximate solution requires at least Ω˜ (D + √n) rounds in CONGEST. This lower bound requires the introduction of a new 2party communication problem, for which we prove a tight lower bound. 2012 ACM Subject Classification Mathematics of computing → Graph algorithms, Mathematics of computing → Approximation algorithms
and phrases distributed graph algorithms; maximum matching; deterministic rounding; communication complexity

1
Introduction
In the maximum matching problem, we are given a graph G, and asked to find a maximumsize
set of edges of G which do not share any vertices. In the weighted version of the problem, the
graph edges are associated with weights, and our goal is to find a set of vertexdisjoint edges
that maximizes the total weight. Maximum matching is a fundamental graph optimization
problem, extensively studied in the classical centralized setting, as well as in other settings
such as streaming algorithms (e.g., [24]) and sublineartime approximation (e.g., [29]). The
problem has also received significant attention from the distributed computing community,
so far focusing on approximation algorithms (cf. Section 2).
In this paper we study maximum matching in the CONGEST model, a synchronous
network communication model where messages are bounded in size. We consider both exact
and approximate maximum matching, weighted and unweighted, and give new upper bounds
and a lower bound. Our upper bounds are deterministic, while the lower bound holds for
randomized algorithms as well. Our contributions are as follows.
1.1
Exact Unweighted Maximum
Matching in Bipartite Graphs
In the sequential world, the fastestknown algorithm for finding a maximum matching
in unweighted bipartite graphs is the Hopcroft–Karp algorithm [17]. Its running time is
O(m · √n) on graphs with n nodes and m edges. Its central building block is a fast way,
using breadthfirstsearch, to find a maximal set of nodedisjoint augmenting paths: paths of
alternating matching and nonmatching edges, used to increase the size of the matching.
A naive implementation of the Hopcroft–Karp algorithm in the CONGEST model would
yield an algorithm requiring O(n3/2) rounds. Taking inspiration and ideas from Hopcroft–
Karp, we are able to instead give an algorithm that takes only O(n log n) rounds. More
specifically, we obtain the following result.
I Theorem 1. The deterministic round complexity in the CONGEST model of computing an
exact maximum matching in unweighted, bipartite graphs is O(s∗ log s∗), where s∗ is the size
of a maximum matching.
Note that the algorithm is not assumed to initially know the value s∗.
The core of our algorithm is a procedure that finds a single augmenting path of length k in
O(k) rounds. Together with the wellknown fact that if we are given a matching of size s∗ − `,
we are guaranteed to have an augmenting path of length at most O(s∗/`), this procedure
implies the above result. To our knowledge, this is the first nontrivial algorithm for exact
bipartite maximum matching in the CONGEST model.
1.2
Approximate Fractional Weighted Maximum
Matching
One strategy for computing an approximate maximum matching is to first solve the fractional
version of the problem, and then round the solution to obtain an integral matching. A
fractional matching is the natural linear programming (LP) relaxation of the notion of a
matching, where instead of taking a set of edges (where each edge is “taken” or “not taken”), we
instead assign each edge e ∈ E a value ye ∈ [0, 1]. Whereas before, we required that each node
participate in at most one edge of the matching, we now require that for each node v, the sum
of the values of v’s edges must be at most 1. This is a linear constraint: Pu∈N(v) y{u,v} ≤ 1.
To compute a fractional matching, we can thus bring to bear the powerful machinery
of linear programming (LP). In particular, the fractional maximum matching problem is a
packing LP. Packing LPs and their duals, covering LPs, are a class of LPs for which there
are particularly efficient distributed solutions (e.g., [19, 26]). In this paper, we extend an
approach that was developed by Eisenbrand, Funke, Garg, and Könemann [9] to solve the
fractional set cover problem. We prove the following theorem.
I Theorem 2. Let G = (V, E, w) be a weighted graph. Assume that Δ is the maximum degree
of G, and let W denote the ratio between the largest and smallest edge weight. Then, for
every ε > 0, there is a deterministic O log(ΔW )/ε2 time CONGEST algorithm to compute
a (1 − ε)approximation for the maximum weighted fractional matching problem in G.
The algorithm is based on another distributed implementation of the algorithm of [9],
which appeared in [19]. The algorithm of [19] is general: it approximates general covering
and packing LPs. When applied to the weighted fractional matching problem, the algorithm
of [19] computes a (1 − ε)approximation in time O log(ΔW )/ε4 , which was the best
(1 − ε)approximation for the problem in the CONGEST model prior to the present work.
As we are only interested in the matching problem, our algorithm is simpler than the
algorithm of [19], and more importantly, our algorithm significantly improves the εdependency
of computing a (1 − ε)approximate fractional matching in the CONGEST model.
1.3
Deterministic Rounding of Fractional Matchings
After computing a fractional matching, we wish to round the edge values to {0, 1}, to obtain
an integral matching with roughly the same weight.
Randomized rounding of LP solutions, in order to obtain approximate solutions of
the corresponding integer LPs, has been used for a while, even in the distributed context
(e.g., [18, 19]). However, deterministic distributed rounding algorithm have only been studied
recently. In [11], Fischer gave an amazingly simple and elegant deterministic O(log2 Δ)time
algorithm, which rounds a fractional unweighted matching into an integral matching that
is smaller by only a constant factor. Repeating this rounding step O(log n) times, Fischer
obtains a maximal matching in deterministic time O(log2 Δ log n).3
At its core, the approach of Fischer [11] solves the problem on bipartite graphs, and
it decomposes the problem of rounding a fractional matching to the problem of rounding
fractional matchings on paths and even cycles. Our contribution in this part of the paper is
twofold. First, while Fischer loses a constant factor when rounding the matching, we show
that a simple change in the algorithm allows us to only lose a factor (1 − ε) on bipartite
graphs. Second, we generalize the technique to also work for weighted (fractional) matching.
I Theorem 3. Let G = (V, E, w) be a weighted graph, y be a fractional matching of G, and
ε > 0 be a parameter. There is a deterministic O log2(Δ/ε)+log∗ n time CONGEST algorithm
ε
that computes an matching M of G such that the ratio between the total weight of M and the
value of the given fractional weighted matching y is at least 1 − ε if G is bipartite, and at
least (1 − ε) · g −g1 if G is not bipartite and g is the length of the shortest odd cycle of G.
In combination with Theorem 2, we obtain a deterministic CONGEST algorithm to
compute a (1 − ε)approximate maximum weighted matching in bipartite graphs in time
O log(ΔW ) + log2(Δ/ε)+log∗ n . For general graphs, we obtain a (2/3 − ε)approximate
maxiε2 ε
mum weighted matching in the same asymptotic time. To the best of our knowledge, this is
the first CONGEST algorithm that obtains an approximation ratio better than 1/2 for the
weighted maximum matching problem in general graphs.
3 Actually, the earlier polylogtime deterministic algorithms for computing a maximal matching [14, 15]
can also be interpreted as approximate rounding algorithms. However, these algorithms are not explicitly
phrased in this way.
1.4
Lower Bound for (1 − O(1/√n))Approximate Fractional
Matching
As we said above, in this paper we show that a (1 − ε)approximate maximum matching in
bipartite graphs can be computed in time O˜(1/ε2) (ignoring the logarithmic terms in n, Δ
and W ). Is this dependence on optimal? We do not yet know, but we are able to show
that O˜(1/ ) rounds are necessary, for sufficiently small :
I Theorem 4. There exists a constant α ∈ (0, 1), such that any randomized algorithm that
computes a (1 − α/√n)multiplicative approximation to the maximum fractional matching in
unweighted, bipartite graphs with diameter O(log n) requires Ω(√n/ log n) rounds.
The lower bound is based on the framework of [27], and it is shown by reduction from
twoparty communication complexity. Given a fast algorithm A for approximate fractional
matching, we construct a protocol for two players, Alice and Bob, to solve a communication
complexity problem, by simulating the execution of A in a network that the players construct.
In contrast to [27], here we are not interested in a verification problem. In [27], in addition
to the network graph, there is a set of marked edges, and the goal is to check whether the
marked edges satisfy some property. Thus, we can give the algorithm a “hard subgraph to
check”, even if the corresponding search problem is easy: e.g., [27] shows that checking if the
marked edges form a spanning tree is hard (Ω˜ (√n + D) rounds), even though constructing a
spanning tree is easy (O(D) rounds). Here, we do not give the algorithm a set of marked
edges, and instead we allow the algorithm to compute any feasible fractional matching.
To prove the lower bound, we argue that a good approximation to the maximum matching
on odd paths “looks different” from one on even paths, and this difference allows us to solve
a communication complexity problem, PXA, that we introduce for this purpose. We prove,
using information complexity [4], that the randomized communication complexity of PXA is
linear. One unusual feature of this lower bound is that at the end of the simulation, each
player only knows part of the matching constructed. Thus, we cannot guarantee that both
players will “see” the difference between odd and even paths, but at least one of them will.
The problem PXA reflects this: instead of asking the players to agree on an output, each
player produces its own output, and at least one of them must “be correct”.
For lack of space, many technical details are omitted in this version of the paper. They
appear in the full version of the paper [1].
2
Related Work
We survey here only the most directly relevant work. In particular, we mostly focus on
the CONGEST model, and we discuss only some of the work for the LOCAL model, where
messages do not need to be of bounded size.
The first polynomialtime algorithm for unweighted maximum matching in general graphs
was given by Edmonds [7, 8]. It was preceded by the algorithm of Hopcroft and Karp [17],
which is restricted to bipartite graphs. Our exact algorithm for bipartite graphs is inspired
by and uses insights from the Hopcroft–Karp algorithm.
Because exact maximum matching is a “global problem”, work on distributed algorithms
has mostly been focused on approximation algorithms. The first ones were for the maximal
matching problem; in the unweighted case, a maximal matching is also a 1/2approximation to
the maximum matching. Even in the 80s, simple and elegant solutions for maximal matching
in O(log n) rounds were known [2, 16, 23]. (These papers give PRAM algorithms, but they
translate to the CONGEST model easily.) The best randomized distributed algorithm for
maximal matching is due to Barenboim et al. [5], and has time complexity O(log Δ+log3 log n).
On the deterministic side, maximal matching was first shown to be solvable in
polylogarithmic distributed time, O(log4 n) rounds, in [14, 15]. While they do not explicitly analyze
the message size, we believe that their algorithm can be implemented in the CONGEST model.
Currently, the best deterministic algorithm (in CONGEST and LOCAL) is from [11], and
requires O(log2 Δ log n) rounds. As one of our algorithms heavily builds on the techniques
of [11], we discuss them in more detail in Section 6. The best lower bound for maximal
matching, and more generally, for obtaining constant or polylogarithmic approximations
for unweighted maximum matching, is Ω min n lolgolgoΔgΔ , q lolgolgongn o [20]. The lower bound
even holds for randomized algorithms in the LOCAL model.
Beyond the simple 1/2approximation provided by a maximal matching, there is series of
works on the distributed complexity of obtaining a (1 − ε)approximate maximum cardinality
matching. All are based on the framework of Hopcroft and Karp [17], of repeatedly computing
a (nearly) maximal vertexdisjoint set of short augmenting paths. The first such algorithm
is [21], a randomized CONGEST algorithm with time complexity O(log n) for every constant
ε > 0; however, the dependence on ε is exponential in 1/ε. This was recently improved in [3],
log Δ
which gives a randomized algorithm with time complexity O poly(1/ε) · log log Δ . Note that
the Δdependency of the running time matches the lower bound of [20]. There are also
deterministic distributed algorithms to obtain a (1 − ε)approximate maximum cardinality
matching in polylogarithmic time [6, 10, 12, 13], but they require the LOCAL model.
As for weighted matching, the first paper to explicitly study distributed approximation of
the weighted maximum matching is [28]. They give a randomized O(log2 n)time algorithm
with an approximation ratio of 1/5. This result for the weighted case was later improved in [22]
and in [21], which give O(log n)round randomized CONGEST algorithms with approximation
ratios (1/4 − ε) and (1/2 − ε), respectively. In [3], BarYehuda et al. improve the running time
and provide a (1/2 − ε)approximation in time O(log Δ/ log log Δ). The only known
polylogtime deterministic CONGEST algorithm for approximate weighted maximum matching in
general graphs is the (1/2 − ε)approximation algorithm by Fischer [11], which runs in
O log2 Δ · log 1ε rounds.
3
Model and Definitions
Communication model. Our algorithms and lower bounds are designed for the CONGEST
model [25]. The network is modeled as an undirected nnode graph G = (V, E), where each
node has a unique O(log n)bit identifier. Time is divided into synchronous rounds; in each
round, each node can send an O(log n)bit message to each of its neighbors in G. We are
interested in the time complexity of an algorithm, which is defined as the number of rounds
that are required until all nodes terminate.
For simplicity, we assume that all nodes know the maximum degree Δ of G. In all our
algorithms, one can replace the value of Δ by a polynomial upper bound, without changing
the asymptotic results. We note that at the cost of a slightly more complicated algorithm,
the knowledge of n and Δ can also be dropped completely. If the edges of G have weights,
we assume that we > 0 is the weight of edge e. We assume that the weights are normalized
such that for all e ∈ E, we have 0 < we ≤ 1. We further assume that the nodes know a
value W such that the smallest weight is at least 1/W .
Distributed matching. When we say that a distributed algorithm computes a matching,
we mean that when the algorithm terminates, each node of the graph knows which of its
edges is in the matching (if any). Since the graph is undirected, both endpoints of an edge
must agree about whether it is in the matching or not. For fractional matching, each node
knows the value of all of its edges, and again, both endpoints of the edge agree on its value.
Notation. Let G = (V, E) be an undirected graph. The bipartite double cover of G is
the graph G2 := G × K2 = (V × {0, 1} , E2), where there is an edge between two nodes (u, i)
and (v, j) in E2 if and only if {u, v} ∈ E and i 6= j. Hence, in G2, every node u of G is
replaced by two nodes (u, 0) and (u, 1) and every edge {u, v} of G is replaced by the two
edges {(u, 0), (v, 1)} and {(u, 1), (v, 0)}. If G is a weighted graph with edge weights we for
e ∈ E, we assume that the bipartite double cover G2 is also weighted and each edge of G2
has the same weight as the underlying edge in G. Throughout the paper, log refers to the
logarithm to base 2.
4
Exact Integral Maximum Matching in Bipartite Graphs
Here we present an O(n log n)round deterministic algorithm to compute a maximum integral
matching for a given nnode bipartite graph. The algorithm is based on finding augmenting
paths and using them to increase the size of the matching we are constructing, as in the
celebrated Hopcroft–Karp sequential algorithm for matching in bipartite graphs [17]. We
give a somewhat informal description of the algorithm here; the full version appears in [1].
Let us review some basic notions. Given a matching M , we say that a node v ∈ V is
matched if one of its edges is in the matching, and otherwise we say that v is free. A path
u0, u1, . . . , uk is called alternating (with respect to M ) if u0 is free, every oddnumbered
edge {u2i, u2i+1} (where 2i + 1 ≤ k) is in the matching M , and every evennumbered edge
{u2i+1, u2i+2} (where 2i + 2 ≤ k) is not in the matching. If an alternating path ends in a
free node, then it is called an augmenting path, and in this case we can increase the size of
the matching by removing all the evennumbered edges along the path from the matching,
and instead adding all the oddnumbered edges.
Our algorithm is based on the following observation, which forms the basis for the
Hopcroft–Karp algorithm:
I Lemma 5 ( [17]). Consider an unweighted graph G, and let M ∗ be a maximum matching
in G. Then for any positive integer ` and any matching M in G, if M  ≤ (1 − 1/`)M ∗,
then there is an augmenting path of length less than 2` in G w.r.t. M .
From Lemma 5 we get an upper bound on the length of the shortest augmenting path
remaining for a matching of given size:
I Corollary 6. If the maximum matching in G has size s∗, and M is a matching of size
M  = i, then M has an augmenting path of length less than 2ds∗/(s∗ − i)e.
Proof. We have: M  = i = s∗−(s∗−i) = s∗ (1 − 1/(s∗/(s∗ − i))) ≤ s∗ (1 − 1/ds∗/(s∗ − i)e).
Therefore, by Lemma 5, there is an augmenting path of length less than 2ds∗/(s∗ − i)e. J
Note that the length of the shortest remaining augmenting path depends on the size s∗ of
the maximum matching, which we do not know. To get an upper bound on the length of
the shortest augmenting path, we need a lower bound on s∗. Thus, we first deterministically
compute a 2approximation sˆ ∈ [s∗/2, s∗], using, e.g., [11] or [19], in O(log n) rounds. We set
s = 2sˆ. We are guaranteed that s ≥ s∗, and hence s/(s−i) ≥ s∗/(s∗−i), so we can safely use s
in place of s∗ when computing an upper bound on the length of the shortest augmenting path.
The core of our algorithm is a procedure called SetupPath: given an upper bound k on
the length of the shortest augmenting path, SetupPath(k) finds an augmenting path in O(k)
rounds. We describe this procedure below, but before showing how we find an augmenting
path, let us describe the overall structure of the algorithm.
Let s∗ be the size of the maximum matching in G. Our strategy is as follows: we start
with an empty matching M , and improve it by searching for augmenting paths onebyone:
for each i = 1, 2, . . . , n − 1, we call SetupPath(2ds/(s − i)e), spending O(s/(s − i)) rounds
searching for an augmenting path of length O(s/(s − i)); if we find one, we apply it to M to
increase its size by at least 1. Note that by Corollary 6 and the fact that s ≥ s∗, if M  = i,
then indeed there is an augmenting path of length less than 2ds/(s − i)e. (If M  > i, then
we might not find an augmenting path in the current iteration, but this is fine; we move on
to the next value of i.)
n−1
The time spent constructing the matching is P O (s/(s − i)) = O(s log s) = O(s∗ log s∗).
i=1
Now let us explain how we find each augmenting path.
4.1
Setting Up an Augmenting Path: Procedure SetupPath
In the SetupPath procedure, we are given an upper bound 2k + 1 on the length of the shortest
remaining augmenting path, and we want to find and “set up” a collection of vertexdisjoint
augmenting paths, in O(k) rounds. Setting up a path means assigning the path a unique
path ID, informing all path nodes that they are on the path, and having them confirm
that they will participate in the path. Once this is done, we augment the matching along
all augmenting paths that were successfully set up. (To augment along the path, we only
need each path node to know its successor and predecessor on the path.) Note that unlike
Hopcroft–Karp, here we do not insist on finding a maximal set of vertexdisjoint augmenting
paths; we are satisfied with merely finding and setting up one augmenting path, provided
there is one with length ≤ 2k + 1.
Finding the path
To find the augmenting path, we perform a k + 1round BFS along alternating paths, starting
from all free nodes. Initially, each free node sends out a BFS token carrying its ID along all
its edges, and tries to have the network propagate this token along alternating paths: in odd
rounds the token is sent along edges that are not in the matching, and in even rounds it is
sent along matching edges. However, every node in the network forwards at most one BFS
token, the first one it receives. (If multiple BFS tokens are received in the same round, the
one with the smallest ID will be forwarded.) BFS tokens received in subsequent rounds (or
in the same round but with a larger ID) are discarded.
During the BFS traversal, each node v stores the BFS token that it propagated, if there
is one, in a local variable srcv. Also, node v stores the neighbor from which srcv was received
in the local variable predv. (If srcv was received from multiple neighbors in the same round,
then v chooses an arbitrary neighbor.)
An augmenting path is detected in round r if in this round, two adjacent nodes u, v
both send each other BFS tokens of distinct free nodes srcu 6= srcv. This means that
the alternatingpath BFS started by srcu has “met” the one started by srcv, yielding an
augmenting path (i.e., an alternating path that starts and ends at a free node).
We show that if 2` + 1 is the length of the shortest augmenting path in the graph, u is
the free node with the minimum ID among the nodes that have augmenting paths of length
2` + 1, and v is the node with the minimum ID to which u has an augmenting path of length
2` + 1, then some augmenting path between u and v is detected in round ` + 1. This is
because only free nodes start a BFS traversal, and no free node can “block” the BFS started
by u unless it has a shorter alternating path to the same node. But this would then imply
a shorter augmenting path than the one u has, and we assumed that u has the shortest
augmenting path present. Since we know that there exists an alternating path with length
at most 2k + 1, we only need to develop the BFS to depth k + 1 before some augmenting
path is detected. Therefore this phase requires k + 1 rounds.
Setting up the path
When u and v detect an augmenting path in round r, they assign it the path identifier
(r, {srcu, srcv} , {u, v}). Path identifiers are sorted in lexicographic order, and we assume
some fixed ordering on unordered pairs of IDs. If a node detects more than one augmenting
path at the same time, it keeps the one with the smallest path identifier. (This can happen
if the augmenting path has length 1, that is, if there are two adjacent free nodes.)
Next, u and v inform all the path nodes of the detected path’s ID, by sending messages
backwards along the pred pointers of the nodes on the path. As we traverse backwards, each
node stores its successor on the path in a local variable succ. (Note that the succ fields point
“inwards”, towards the edge that detected the path.)
Eventually, each free node receives a (possibly empty) list of augmenting path IDs for
which it is an endpoint. (Note that each inner path node can only receive one path ID; only
endpoints of the path may receive more than one path ID.) At this point, each free node
selects the smallest path ID (in lexicographic order), and discards the others. We know that
of the augmenting paths detected, the one with the smallest path ID will be selected by both
its endpoints, so at least one augmenting path survives.
We now sweep forward along each selected path, to confirm that it is properly set up:
the two endpoints send each other confirmation messages carrying the path ID, by having
the path nodes forward the messages along the path. If an inner path node does not receive
confirmation from both endpoints, it discards the path, and similarly, if an endpoint of the
path does not receive confirmation from the other endpoint, it discards the path.
5
Fractional Matching Approximation
We first describe a distributed approximation scheme for the weighted fractional matching
problem. The algorithm is based on distributed algorithm for general covering and packing
linear programs, which appeared in [19]. Further, the distributed algorithm in [19] itself
is based on a sequential fractional set cover algorithm by Eisenbrand, Funke, Garg, and
Könemann [9].
Reduction to the Bipartite Case: We first show how to reduce the problem of computing
a fractional (weighted) matching for a general graph G to the fractional maximum matching
problem on twocolored bipartite graphs.
I Lemma 7. Let G = (V, E) be a graph with positive edge weights we ≥ 0 for all e ∈ E and
let H = (V × {0, 1} , EH ) be the bipartite double cover of G.
(1) Let x be a fractional matching of G and let y be an edge vector of H such that for every
edge {(u, i), (v, 1 − i)} of H, y{(u,i),(v,1−i)} = x{u,v}. Then, y is a fractional matching
of H of size Pe∈EH weye = 2 · Pe0∈E we0 xe0 .
(2) Let z be a fractional matching of H and let y be an edge vector of G such that for
every edge {u, v} of G, ye{∈uE,v}w=eye(z={(u21,0·),(v,1)} + z{(u,1),(v,0)})/2. Then y is a fractional
matching of G of size P Pe0∈EH we0 ze0 .
Proof. Follows immediately from the definition of the bipartite double (cf. Section 3).
Distributed Algorithm for 2Colored Bipartite Graphs
In light of Lemma 7, we can w.l.o.g. assume that we are given a weighted bipartite graph
B = (V0 ∪˙V1, E, w) for which the bipartition is given (i.e., a node knows whether it is in V0
or in V1). We further define V := V0 ∪ V1 to be the set of all nodes.
Formulation as a Linear Program. The maximum weighted fractional matching problem
can be phrased as a packing linear program (LP). As it will be convenient to describe
our algorithm, we use the following nonstandard way to describe the maximum matching
problem as an LP. Consider some fractional matching z that assigns a value ze ≥ 0 to each
edge e ∈ E. Instead of directly computing the variables ze, we make a simple change of
variable and we assign a value ye ≥ 0 to each node such that ye = we · ze. In terms of the
variables ye, we then obtain the following packing LP:
max X ye s.t. ∀v ∈ V : X
e∈E
e∈E:v∈e we
ye
≤ 1 and
∀e ∈ E : ye ≥ 0.
After solving (1), we obtain a weighted fractional machting z of the same quality by setting
ze := ye/we for each edge e ∈ E. The dual covering LP of (1) is defined as follows:
min X xv s.t. ∀e = {u, v} ∈ E : xu + xv
v∈V we we
≥ 1 and
∀v ∈ V : xv ≥ 0.
Note that (2) is a variation of the fractional vertex cover LP. We will design an algorithm that
solves (2) and (1) at the same time. The algorithm is based on an adaptation of the greedy
set cover algorithm (the vertex cover problem is a special case of the set cover problem). It
is therefore most natural to think of the algorithm primarily as an algorithm for solving (2).
The Distributed Fractional Matching Algorithm. Our algorithm has a realvalued
parameter α > 1 and an integer parameter f ≥ 1. The values of both parameters will be fixed later.
Recall that we assume that all edge weights we are normalized and the node know a value
W ≥ 1 such that 1/W < we ≤ 1 for all edges e ∈ E.
The algorithm maintains a variable xv ≥ 0 for each node v ∈ V and variables ye ≥ 0 and
re ∈ [0, 1] for each edges e ∈ E. Initially, we set xv := 0, ye := 0, and re := 1 for all nodes
v ∈ V and all edges e ∈ E. Throughout the algorithm, the values of xv and ye only increase
and the value of re only decreases. We further define a generalized notion of the degree of a
node v as γ(v) := Pe∈E:v∈e wree and we define γˆ(v) := maxu∈{v}∪N(v) γ(u).
Our algorithm consists of phases: a node v participates in a phase as long as γ(v) > 0
and v terminates as soon as γ(v) = 0. Alg. 1 gives the details of a single phase.
Before analyzing the algorithm in detail, we make some simple observations. First note
that whenever we increase some variable xv by 1, in line 8, we make sure that the total
increase to the edge variables ye is also equal to 1. The increase of the variables ye is
proportional to their contribution to the generalized node degree γ(v). At the end, we
therefore have Pv∈V xv = Pe∈E ye. Further, consider some node v ∈ V and some incident
edge e. Each time, we increase xv by 1, we divide re by a factor α1/we . We set re = 0 as
soon as re becomes less than α−f at the end of the algorithm, for every edge e = {u, v}, we
therefore have xu + xv ≥ we · f and thus wxue + wxve ≥ f . Hence, all inequalities of the LP (2)
are “oversatisfied” by a factor at least f and we can therefore obtain a feasible solution x0
for LP (2) by setting x0v := xv/f . The solution y for the fractional matching LP (1) is
feasible. In order to obtain a feasible solution y0, we compute the value Yv := Pe∈E:v∈e wyee
for each nodes v and for each edge e = {u, v}, we set ye0 := ye/ max {Yu, Yv}. By LP duality,
(1)
(2)
Algorithm 1: A single phase of the fractional matching algorithm.
the optimal solutions of (1) and (2) have the same values and we can therfore lower bound
the approximation ratio of our fractional matching algorithm by the ratio f / maxv∈V Yv ≤ 1.
The following lemma and corollary show that for suitable choices of the parameters α and f ,
this ratio can be made arbitrarily close to 1. The proof is similar to the analyses in [9, 19]
and it appears in the full version of this paper [1].
I Lemma 8. At the end of running the above fractional weighted matching algorithm, for
all nodes v ∈ V , we have
α2
Yv ≤ α − 1 · ln(W Δ) + (f + 1) ln α .
I Corollary 9. Let ε ∈ (0, 1/2] be a parameter. By choosing α = 1 + ε/c and choosing
f = 2c · ln(ΔW )/ε2 for a sufficiently large constant c, the above fractional matching algorithm
can be used to compute a (1 − ε)approximate fractional weighted matching in an arbitrary
weighted graph G = (V, E).
It remains to bound the time complexity of the algorithm in the distributed setting.
The proof appears in the full version of this paper [1]. It shows that a single phase of the
algorithm can be implemented in O(1) CONGEST model rounds and that the total number
of phases is O(log(W Δ)/ε2).
I Lemma 10. The described fractional weighted matching algorithm can be implemented in
O(f + logα(W Δ)) rounds in the CONGEST model.
Together with Corollay 9, Lemma 10 directly proves Theorem 2.
6
Deterministic Rounding of Fractional Matchings
For rounding the obtained fractional matching from Section 5, we adapt the technique by
Manuela Fischer in [11]. In [11], Fischer shows how to round a fractional matching to an
integral matching at the cost of losing a nontrivial constant factor (in the unweighted and in
the weighted case). We show that a simple adaptation of the algorithm allows to keep the loss
within a (1 + ε)factor in the unweighted bipartite case. We further show that the method
can also be generalized to the weighted bipartite case while only losing a (1 + ε)factor in
the rounding.
Normalizing the Fractional Matching. As for the fractional maximum matching problem
in Section 5, we first solve the problem in 2colored bipartite graphs, and we then show how
to extend the solution to general graphs. The following lemma further shows that we can
assume that we start with a normalized fractional matching where all the fractional edge
values are of the form 2−i for some integer i ≥ 0. The relatively straightforward proof of the
following lemma is omitted in this short version of the paper.
I Lemma 11. At the cost of at most an εfraction of an optimal matching, the problem of
rounding a weighted fractional matching y of a graph G with maximum degree Δ can be
reduced to the problem of rounding a weighted fractional matching y0 on a multigraph G0 such
that for all edges e of G0, we have y0e = 2−i for some nonnegative integer i = O log(Δ/ε) .
Basic Rounding Strategy. We use the same basic rounding approach as Fischer [11]. In
the following, we assume that we are given a biparite (multi)graph B = (V0∪˙ V1, E) and a
normalized fractional matching y that assigns a value ye = 2−i for some integer i ≥ 0 to
each edge e ∈ E. For convenience, let Ei be the set of edges e ∈ E for which ye = 2−i and
let Bi := (V0 ∪˙V1, Ei) be the subgraph of B induced by the edges in Ei. Assume further
that k is the largest integer such that Ek 6= ∅, i.e., for which there is some edges e ∈ E with
ye = 2−k. For a given parameter δ > 0, we describe a rounding algorithm that rounds each
edge e ∈ Ek either to value 0 or to value 2−(k−1) such that the total value of the fractional
(weighted) matching does not decrease by more than a factor 1 − δ.
In order to do the rounding of the edges in Ek, we define a virtual graph Bk0 as follows.
For each node v ∈ V , let dk(v) be the number of edges in Ek that are incident to v. If
dk(v) ≥ 1, we create sv := ddk(v)/2e virtual nodes v1, . . . , vsv and we arbitrarily divide the
dk(v) edges in Ek that are incident to v among the nodes v1, . . . , vsv such that each node vi
receives at most two such edges (i.e., if dk(v) is even, all virtual nodes vi get two edges and if
dk(v) is odd, one of the virtual nodes gets one edge and the others get two edges). Note that
the graph Bk0 has maximum degree 2 and because Bk0 is bipartite, it means that it consists of
disjoint paths and even cycles. The next lemma shows that we can use an arbitrary matching
of Bk0 to select the set of edges in Ek, which are rounded up to value 2−(k−1). The proof of
the lemma appears in the full version [1].
I Lemma 12. Let Mk0 be a matching of the graph Bk0 and let Mk the corresponding subset
of edges of Ek. Further, let y0 be obtained from the fractional matching y of B by setting
ye0 = ye for all e 6∈ Ek, ye0 = 2ye for all e ∈ Mk and ye0 = 0 for all e ∈ Ek \ Mk. Then y0 is a
valid fractional matching of B.
Further, if the total weight of Mk0 is at least (1 − δ)/2 of the total weight of Bk0 for some
δ ≥ 0, the total weight of y0 is at most a (1 − δ)factor smaller than the total weight of y.
The above rounding of edges is the main difference between the approach of [11] and our
algorithm. In [11], to be on the safe side, the fractional matching value of the edge incident to
a virtual node of degree 1 is always rounded down unless the total fractional matching value
at the respective node is far from 1. This simple change makes the rounding more efficient
and it also makes it easier to argue that the rounded matching is not much smaller than
the original matching, in particular in the case of weighted matchings. Lemma 12 implies
that rounding fractional matchings to integral matchings essentially boils down to computing
almost maximum (weighted) matchings in graphs of maximum degree 2.
Approximating Maximum Matching in Paths and Cycles. As discussed above, Lemma 12
essentially reduces the problem of rounding (weighted) fractional matchings to solving the
weighted maximum matching problem in paths and cycles.
I Lemma 13. Let G = (V, E) be a weighted nnode graph with maximum degree 2 and
assume that W is the total weight of all edges of G. Let δ > 0 be a parameter, and let g be
the length of the shortest odd cycle of G.4 In the CONGEST model, a matching of weight at
least g −g1 · (1 − δ) · W/2 can be computed in time O 1δ · log∗ n .
If G = (V0 ∪˙V1, E) is a bipartite graph for which the bipartition (V0, V1) is given, there is
an O(1/δ)time algorithm that computes a matching of total weight at least (1 − δ)W/2.
Proof Sketch. The full proof of the lemma appears in the full version [1]. The main idea
of the proof is as follows. For short paths and cycles, it is straightforward to compute the
required matchings. For long paths, we define an edge to be `light if its weight is at most the
average weight in some subpath of length `. We then choose a set L of `light edges such that
after removing those edges, the matchings of the remaining paths can be computed efficiently
(either because the paths are sufficiently short or in the case of 2colored bipartite graphs
because we have a 2edge coloring of the paths that allows to find the matching). If the `light
edges in L are sufficiently separated, one can show that we only lose a (1 − O(1/`))factor in
the matching size. J
Putting the Pieces Together. We now have all the tools that are needed for the rounding
and we can therefore prove Theorem 3.
Proof of Theorem 3. First of all, we assume that y is at least a 1/3approximation. If not,
one can directly apply the weighted (2 + ε)approximation algorithm of [11] to obtain the
claim of the theorem. Because y is at least a 1/3approximation and because the optimal
fractional matching size is at least Pe∈E we/Δ, we directly round down matching values
that are smaller than ε/(12Δ), i.e., if ye ≤ ε/(12Δ), we set ye := 0. This reduces the value
of the weighted fractional matching y at most by a factor (1 − ε/4).
Using Lemma 7, we now first move to the bipartite double cover of G and by using
Lemma 11, we create a multigraph in which all matching values are negative powers of 2.
Assume that the smallest matching value is 2−k. Because all matching values of y are
at least ε/(12Δ), we have k = O(log(Δ/ε)). We apply k iterations of the basic rounding,
each time, we round the edges of the currently smallest values. In order to lose at most
another (1 − ε/4)factor throughout the k phases of rounding, we make sure that in each
of the k iterations, we only lose a (1 − O(ε/k))factor. In Lemma 12, we therefore have to
set δ = O(ε/k) = O(ε/ log(Δ/ε)). Because Bk0 is a 2colored bipartite graph, Lemma 13
implies that the matching of Bk0 which is necessary by Lemma 12 can be computed in time
O(1/δ) = O(log(Δ/ε)/ε). After the k steps of rounding, we therefore obtain a matching
of the bipartite double cover H of G of size at least (1 − ε/2) times the value of the given
fractional matching of H. When using Lemma 7 to transform this matching back to G, we
only obtain a fractional matching of G. However, this fractional matching is halfintegral
and rounding it to an integer matching can therefore be achieved by another application of
Lemma 13. However, this time, we do not have a 2coloring of the graph and G might also
not be bipartite. The time for this last rounding step is therefore O(log∗ n/ε) and we lose a
factor (1 − O(ε)) · g −g1 . J
4 Note that if G is bipartite, we have g = ∞.
Lower Bound
In this section we show that computing a (1 − O(1/√n))approximation to the maximum
fractional matching requires Ω(√n) rounds, even in bipartite graphs of diameter O(log n),
and even for randomized algorithms which may err with constant probability.
Our graph construction is based on [27]: it is a collection of Θ(√n) long paths, of
length Θ(√n), connected to each other by a tree, which reduces the diameter to O(log n).
The lower bound is by reduction from a 2party communication complexity problem that
we introduce for this purpose. Our lower bound is, very informally speaking, “all about”
distinguishing even paths from odd paths; the communication complexity problem reflects
this, and it asks the players to distinguish “odd inputs” from “even inputs”.
One might wonder why we do not simply reduce from Set Disjointness, as is usually done
(e.g., in [27]). The reason is that Set Disjointness is a decision problem: given sets X, Y ⊆ [n],
the players must decide whether X ∩ Y = ∅. This suffices for [27], because the typical setup
there is that the input graph has some marked edges in it, and the goal is to decide whether
the subgraph induced by the marked edges satisfies some property. In contrast, here we are
interested in a search problem: unlike [27], we do not have a set of marked edges as part of
the input; there is only the network graph, on which the algorithm must approximate the
maximum fractional matching.
Another difficulty that we must overcome is that our reduction does not allow both
players to compute the same output. Instead, the players may output different bits, and we
view their answer is the Boolean AND of their output bits.
The 2Player Communication Problem
Let XORtoAnd, or XA for short, be the following problem: the players receive input bits
x, y ∈ {0, 1}, respectively, and their goal is to output bits a, b ∈ {0, 1}, respectively, such
that a ∧ b = x ⊕ y. That is, if x ⊕ y = 1, then both players should output 1, but if x ⊕ y = 0,
then at least one player should output 0.
For n ≥ 1, let PXAn,δ (“promise XORtoAnd”) be the following problem: the players are
given n copies of XA, x1, y1, . . . , xn, yn, with the promise that for at least n/3 copies i we
have xi ⊕ yi = 1, and for at least (2/5)n copies i we have xi ⊕ yi = 0. The goal is to solve at
least δn of the copies correctly; that is, the players should produce outputs a1, b1, . . . , an, bn
such that for at least δn coordinates i we have ai ∧ bi = xi ⊕ yi. The players are not charged
for writing their outputs, only for the communication between them.
I Theorem 14. The randomized communication complexity of PXAn,δ is Ω((1 − δ)n).
We omit the proof of the communication lower bound here, as it uses standard techniques
in information complexity [4]; see the full version [1] for this proof.
The Reduction
Given a CONGEST algorithm A that computes a (1 − Θ(1/√n))multiplicative
approximation to the maximum fractional matching, we construct a 2party protocol for PXAΘ(√n,δ)
(for a small constant δ).
Fix a parameter k = Θ(√n), and assume for simplicity that n/k is an integer. Assume
that the algorithm A runs in time at most n/k − 1 = O(√n).
On inputs x, y ∈ {0, 1}k, Alice and Bob construct a graph Gx,y = (V, Ex,y), consisting of
k paths, each of length 2n/k, denoted π0, . . . , πk−1, where πi = (i, 0), (i, 1), . . . , (i, 2n/k)
for each i ∈ [k].
A complete binary tree, with n/k + 1 leaves denoted `0, . . . , `n/k. Each leaf `i is connected
to each path node (j, 2i) for j = 0, . . . , n/k. The edges {{`i, (j, 2i)}}j∈[k],i∈[n/k+1] are
called bridges.
An additional n/k + 1 nodes denoted x0, . . . , xn/k, with an edge {`i, xi} connecting xi to
the tree leaf `i for each i ∈ [n/k + 1]. Nodes x0, . . . , xn/k are called spines.
For each i ∈ [k], if xi = 1, Alice prepends an edge eiA = {(i, A), (i, 0)} at the beginning of
the path πi.
For each i ∈ [k], if yi = 1, Bob appends an edge eiB = {(i, B), (i, 2n/k)} at the end of the
path πi.
Let πix,y be the extended path πi, after Alice or Bob either add or do not add their edge
to their respective endpoints of πi. The length of each extended path πix,y is 2n/k + 1 if
xi ⊕ yi = 1, and either 2n/k or 2n/k + 2 if xi ⊕ yi = 0. We argue that a good approximate
matching algorithm must distinguish between these two cases on a noticeable fraction of the
paths, allowing the players to solve PXA.
The players simulate the execution of A for n/k − 1 rounds, until it terminates. The
simulation is very similar to the one in [27], with each player initially simulating almost all
nodes of the graph, but simulating fewer and fewer nodes as the execution of the algorithm
progresses. Specifically, at each time t ≤ n/k − 1, let VAt = [k] × {A, 0, 1, . . . , 2n/k − t} and
VBt = [k] × {B, t, t + 1, . . . , 2n/k} be the path nodes simulated by Alice and Bob, respectively,
at time t. At each time t, each player can compute the messages that the nodes in V t+1
A
(resp. V t+1) will receive in the current round from their neighbors on the path, because it
B
knows the neighbors’ local states at time t. In addition to the path nodes, the players also
simulate the tree nodes and the spine nodes, fewer and fewer in each round. This part of the
simulation is again very similar to [27], and we omit it here.
When A terminates, both players know the states of nodes (i, n/k − 1), (i, n/k), (i, n/k + 1)
for each i ∈ [k]. This overlap is important for our reduction.
Let EA be the set of edges such that at the end of the simulation, Alice has the local
states of both endpoints of the edge, and therefore knows the value the algorithm assigned
to this edge. Similarly define EB for Bob. Let M be the fractional matching computed by
the algorithm.
Producing Outputs
After the simulation ends, the players examine the fractional matching produced by the
algorithm, and use it to produce outputs, as follows.
For a path π = u0, . . . , uk−1, let π−1 = uk−1, . . . , u0 be the inverse path, and let
oddedges(π) = {{u2i, u2i+1}  2i + 1 < k} be the set of oddnumbered edges along the path
(the first edge, the third edge, and so on). Note that if π has odd length (an odd number
of edges), then oddedges(π) = oddedges(π−1), but if π has even length, then oddedges(π)
and oddedges(π−1) are a partition of the edges of π.
For each i ∈ [k], Alice outputs ai = 1 iff from her perspective, every oddnumbered
edge “that she can still see” has value greater than 1/2. That is, ai = 1 iff for every
e ∈ oddedges(πix,y) ∩ EA we have M (e) > 1/2. Bob does the same, but he views the
path in reverse, because he is at the other end of it: he outputs bi = 1 iff for every
e ∈ oddedges((πix,y)−1) ∩ EB we have M (e) > 1/2. We argue that this oddlooking decision
rule indeed captures the fact that M “looks different” on oddlength and evenlength paths.
Correctness of the Deduction
First, note that we can effectively ignore the bridge edges, and assume that they have weight
zero: If M assigns nonzero weight to some bridge edge {`i, (j, 2i)}, we can “shift” this
weight onto the corresponding spine edge {`i, xi} and zero out the weight of the bridge edge.
The resulting matching M 0 agrees with M on all the path edges, but since it now induces
disconnected components consisting of the k paths and the tree (the bridges have value 0), it
must “solve each path individuallly”. We can also ignore the tree and spines, because they
do not contribute too much to the total value. For simplicity, let us assume here that M
is a (1 − Θ(1/√n))multiplicative approximation to the maximum matching on the paths
π1x,y, . . . , πkx,y.
Next, observe that if M is a (1 − Θ(1/√n))multiplicative approximation to the maximum
fractional matching, then for a constant fraction of our k = Θ(√n) paths, M must be an
O(1)additive approximation to the maximum fractional matching on the path: the optimal
fractional matching has total value at most 2n on all the paths (this is a coarse upper
bound), so missing even a constant value α ∈ (0, 1) on β√n paths leads to a multiplicative
approximation of only 1 − αβ/(2√n).
We set the constants so that for a δfraction of the k paths, M is at least a
1/3additive approximation. Then we show that for any path πix,y, if M achieves a 1/3additive
approximation to the maximum matching on πix,y, then the players correctly solve coordinate i,
that is, ai ∧ bi = xi ⊕ yi.
The heart of the lower bound is the following simple observation:
I Lemma 15. Let π be a path with 2r + 1 edges, r ≥ 0, and let M be a 1/3additive
approximation to the maximum fractional matching on π. Then for all e ∈ oddedges(π) we
have M (e) > 1/2.
Proof. Suppose not, and let e ∈ oddedges(π) be an edge with M (e) ≤ 1/2. Removing
edge e from π splits the path into two evenlength paths (the suffix and the prefix), with
combined length 2r. On an even path of 2i edges, the maximum fractional matching has
total value i, and therefore the total value of M on the two evenlength paths is at most r.
Because M (e) ≤ 1/2, the total value of M on π is at most r + 1/2. But the maximum
fractional matching on π has total value r + 1, so M is not a 1/3additive approximation. J
I Corollary 16. If M is a 1/3additive approximation on πix,y, and xi ⊕ yi = 1 (so πix,y has
odd length), then for every oddnumbered edge e ∈ oddedges(πix,y) we have M (e) > 1/2.
This shows that for oddlength paths that are wellapproximated by M , the players do indeed
solve XA correctly. What about evenlength paths? Here the situation is even simpler:
I Lemma 17. If xi ⊕ yi = 0, then there exists an edge
e ∈ (oddedges(πix,y) ∩ EA) ∪ oddedges((πix,y)−1) ∩ EB
with M (e) ≤ 1/2.
Proof. Recall that when xi ⊕ yi = 0, the length of πix,y is even, and therefore oddedges(πix,y)
and oddedges((πix,y)−1) form a partition of the path edges. Recall also that the overlap of
the edges simulated by the players at the end, EA ∩ EB, contains at least two adjacent edges
on each path. Because M is feasible, it assigns value ≤ 1/2 to at least one of these edges,
and since the edge is either in oddedges(πix,y) or in oddedges((πix,y)−1), at least one of the
players will output 0. J
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
25
26
27
28
29
M. Ahmadi , F. Kuhn , and R. Oshman . Distributed approximate maximum matching in the congest model . Technical Report 286 , U. Freiburg, Dept. of Computer Science, 2018 . URL: http://tr.informatik.unifreiburg.de/reports/report286/report00286.pdf.
N. Alon , L. Babai , and A. Itai . A fast and simple randomized parallel algorithm for the maximal independent set problem . Journal of Algorithms , 7 ( 4 ): 567  583 , 1986 .
R. BarYehuda , K. CensorHillel , M. Ghaffari , and G. Schwartzman . Distributed approximation of maximum independent set and maximum matching . In Proceedings of the ACM Symposium on Principles of Distributed Computing (PODC) , pages 165  174 , 2017 .
Ziv BarYossef , T. S. Jayram , Ravi Kumar, and D. Sivakumar . An information statistics approach to data stream and communication complexity . J. Comput. Syst. Sci. , 68 ( 4 ): 702  732 , 2004 .
L. Barenboim , M. Elkin , S. Pettie , and J. Schneider. The locality of distributed symmetry breaking . In Proceedings of 53th Symposium on Foundations of Computer Science (FOCS) , 2012 .
A. Czygrinow and M. Hańćkowiak . Distributed algorithm for better approximation of the maximum matching . In 9th Annual International Computing and Combinatorics Conference (COCOON) , pages 242  251 , 2003 .
J. Edmonds . Maximum matching and a polyhedron with 0, 1 vertices . Canadian Journal of mathematics , pages 449  467 , 1965 .
J. Edmonds . Paths, trees, and flowers . J. of Res. the Nat. Bureau of Standards , 69 B: 125  130 , 1965 .
F. Eisenbrand , S. Funke , N. Garg , and J. Könemann . A combinatorial algorithm for computing a maximum independent set in a tperfect graph . In Proceedings of 14th ACMSIAM Symposium on Discrete Algorithms (SODA) , pages 517  522 , 2003 .
G. Even , M. Medina , and D. Ron . Distributed maximum matching in bounded degree graphs . In Proceedings of the 2015 International Conference on Distributed Computing and Networking (ICDCN) , pages 18 : 1  18 : 10 , 2015 .
M. Fischer . Improved deterministic distributed matching via rounding . In Proceedings of 31st Symposium on Distributed Computing (DISC) , pages 17 : 1  17 : 15 , 2017 .
M. Fischer , M. Ghaffari , and F. Kuhn . Deterministic distributed edgecoloring via hypergraph maximal matching . In Proceedings of 58th IEEE Annual Symposium on Foundations of Computer Science (FOCS) , pages 180  191 , 2017 .
M. Ghaffari , D. G. Harris , and F. Kuhn . On derandomizing local distributed algorithms , 2017 . arXiv: 1711 . 02194 .
M. Hańćkowiak , M. Karoński , and A. Panconesi . On the distributed complexity of computing maximal matchings . In Proceedings of the Ninth Annual ACMSIAM Symposium on Discrete Algorithms , pages 219  225 , 1998 .
M. Hańćkowiak , M. Karoński , and A. Panconesi . A faster distributed algorithm for computing maximal matchings deterministically . In Proceedings of the Eighteenth Annual ACM Symposium on Principles of Distributed Computing (PODC) , pages 219  228 , 1999 .
Process. Lett. , 22 ( 2 ): 57  60 , 1986 .
R. M. Karp and J. E. Hopcroft . An n5/2 algorithm for maximum matchings in bipartite graphs . SIAM Journal on Computing , 1973 .
In Proceedings of 19th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) , pages 161  170 , 2007 .
F. Kuhn , T. Moscibroda , and R. Wattenhofer . The price of being nearsighted . In Proceedings of 17th Symposium on Discrete Algorithms (SODA) , pages 980  989 , 2006 .
F. Kuhn , T. Moscibroda , and R. Wattenhofer . Local computation: Lower and upper bounds . J. of the ACM , 63 ( 2 ), 2016 .
In Proceedings of the 20th Annual ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) , pages 129  136 , 2008 .
Z. Lotker , B. PattShamir , and A. Rosén . Distributed approximate matching . SIAM Journal on Computing , 39 ( 2 ): 445  460 , 2009 .
M. Luby . A simple parallel algorithm for the maximal independent set problem . SIAM Journal on Computing , 15 : 1036  1053 , 1986 .
Andrew McGregor . Finding graph matchings in data streams . In Approximation, Randomization and Combinatorial Optimization . Algorithms and Techniques , pages 170  181 , 2005 .
D. Peleg . Distributed Computing: A LocalitySensitive Approach . SIAM, 2000 .
S. Plotkin , D. Shmoys , and E. Tardos . Fast approximation algorithms for fractional packing and covering problems . Mathematics of Operations Research , 20 : 257  301 , 1995 .
Atish Das Sarma , Stephan Holzer, Liah Kor, Amos Korman, Danupon Nanongkai, Gopal Pandurangan, David Peleg, and Roger Wattenhofer . Distributed verification and hardness of distributed approximation . SIAM J. Comput. , 41 ( 5 ): 1235  1265 , 2012 .
M. Wattenhofer and R. Wattenhofer . Distributed weighted matching . In Proceedings of 18th International Distributed Computing Conference (DISC) , pages 335  348 , 2004 .
Yuichi Yoshida , Masaki Yamamoto, and Hiro Ito . An improved constanttime approximation algorithm for maximum matchings . In STOC '09 , pages 225  234 , 2009 .