Distributed Half-Integral Matching and Beyond

By prior work, it is known that any distributed graph algorithm that finds a maximal matching requires $\Omega(\log^* n)$ communication rounds, while it is possible to find a maximal fractional matching in $O(1)$ rounds in bounded-degree graphs. However, all prior $O(1)$-round algorithms for maximal fractional matching use arbitrarily fine-grained fractional values. In particular, none of them is able to find a half-integral solution, using only values from $\{0, \frac12, 1\}$. We show that the use of fine-grained fractional values is necessary, and moreover we give a complete characterization on exactly how small values are needed: if we consider maximal fractional matching in graphs of maximum degree $\Delta = 2d$, and any distributed graph algorithm with round complexity $T(\Delta)$ that only depends on $\Delta$ and is independent of $n$, we show that the algorithm has to use fractional values with a denominator at least $2^d$. We give a new algorithm that shows that this is also sufficient.


Introduction
By prior work, it is known that there is a distributed graph algorithm that finds a maximal fractional matching (see Section 1.2) in O(∆) rounds in graphs of maximum degree ∆ [3]; in particular, the running time is independent of n and only depends on ∆. However, the algorithm uses very fine-grained fractional values; when ∆ increases, the denominators grow exponentially fast. In this work we show that this is necessary: any distributed graph algorithm that finds a maximal fractional matching in T (∆) rounds, independently of n, has to use fractional values with a denominator at least 2 d (and this is tight). In particular, there cannot be a T (∆)-rounds algorithm for finding a maximal half-integral matching.

Distributed maximal matching is hard
Maximal matching is one of the classic problems in the field of distributed graph algorithms, studied extensively since the very early days of the field in the 1980s [4, 6-8, 11, 13, 17]. In the maximal matching problem, the task is to find a matching (a set of edges without common vertices) that is not a strict subset of another matching. This is something one can trivially find in a centralized setting (pick independent edges greedily until you are stuck), but this is a challenging coordination task in a distributed setting, for two reasons: 1. One has to break symmetry. For example, if the input graph is a cycle, one has to select some but not all edges-the input is symmetric, but the output is not. The task is not solvable at all without resorting to, e.g., unique identifiers or randomness, and even then we cannot solve the task in constant number of rounds; maximal matching in cycles requires Ω(log * n) rounds [14,16].
2. One has to solve a local coordination task. Even if we have a ∆-regular bipartite graph, with the bipartition given, we still need Ω(∆) rounds to find a maximal matching, at least in sufficiently large graphs [4].
On the positive side, O(∆ + log * n)-round distributed algorithms for finding a maximal matching in a graph of maximum degree ∆ are known [17]; one can also make different trade-offs between dependency on ∆ vs. n [6][7][8], but it is impossible to achieve a running time of T (∆), independent of n [14,16]. All of these results hold in the usual LOCAL model of distributed computing (see Section 2.2 for the details).

Distributed fractional matching is easier
A matching M ⊆ E in a graph G = (V, E) can be interpreted as a function x that assigns value x(e) = 1 to each edge e ∈ M . If we let denote the sum of labels on edges incident to node v ∈ V , then we can define that function Note that any maximal matching is also a maximal fractional matching, but the converse is not necessarily true. However, maximal fractional matchings share many useful properties of maximal matchings. For example, the set of saturated nodes forms a 2-approximation of a minimum vertex cover [5].
When we consider distributed graph algorithms for maximal fractional matchings, one of the obstacles discussed in Section 1.1 goes away: we do not need to break symmetry. For example, if the graph is a cycle, we can simply label all edges with 1/2. More generally, if we have a d-regular graph, we can label all edges with 1/d. The lower bound of Ω(log * n) from [14,16] for symmetry-breaking problems no longer applies. While the case of non-regular graphs is much more challenging, it is nevertheless possible to design distributed algorithms that find a maximal fractional matching in O(∆) rounds, independently of n [3]. It is also known that the local coordination challenge does not disappear; o(∆)-round algorithms do not exist [10].

What about half-integral matchings?
The fractional matching polytope is half-integral (see e.g. [19,Section 30.3]). That is, there exists a maximum fractional matching in which x(e) ∈ {0, 1 2 , 1} for every edge e ∈ E. There is also a simple distributed strategy that at first seems to lead to half-integral solutions (see e.g. [2]). First, construct the bipartite double cover G = (V , E ) of the graph G = (V, E): for each node v ∈ V we have two nodes v 1 and v 2 in V , and for each edge {u, v} ∈ E we have two edges {u 1 , v 2 } and {u 2 , v 1 } in E . Now G is bipartite, and we know the bipartition, with nodes v 1 on one side and nodes v 2 on the other side. We can now apply any algorithm that finds a matching x in the bipartite graph G , and this can be mapped into a half-integral matching x by setting Hence, we could use any distributed algorithm designed for bipartite graphs-there is a very simple algorithm that finds a maximal matching in bipartite graphs in O(∆) rounds independently of n. Then by applying (1) we could turn it into a fractional matching. There is, unfortunately, a catch: while (1) will preserve feasibility (given a matching x it will result in a fractional matching x), it will not preserve maximality: even if x is a maximal matching, it is not necessarily the case that x is a maximal fractional matching. Could we nevertheless find a half-integral matching efficiently with a distributed algorithm?
If we consider prior distributed algorithms for maximal fractional matching [2,3], they are very far from being able to produce half-integral matchings. For example, [2] uses fractional values with denominators as large as 2 ∆−1 and [3] is even worse. In this work we show that denominators exponential in ∆ are necessary, but we can still do better than prior work.

Contributions
Our main result is a full characterization of exactly how fine-grained fractional values are necessary: There is a T (∆)-round distributed algorithm that finds a maximal fractional matching in graphs of maximum degree ∆ ≤ 2d+1 using only fractional numbers of the form a/b where a = 0, 1, . . . , 2 d and b = 2 d .

Theorem 1.2 (Lower bound).
There is no T (∆)-round distributed algorithm for any function T that finds a maximal fractional matching in graphs of maximum degree ∆ ≤ 2d+ 2 using only fractional numbers of the form a/b where a = 0, 1, . . . , 2 d and b = 1, 2, . . . , 2 d .
We emphasize that the upper bound only uses multiples of 1/2 d , while the lower bound also excludes the possibility of finding a maximal matching using, e.g., values that are multiples of 1/∆.
As a corollary of these results, we also have a full characterization of the complexity of half-integral matchings: For larger values of ∆, the range of fractional numbers we use is much smaller than in prior work. In our algorithm, the denominators is approximately 2 ∆/2 , while in prior work [2] it is approximately 2 ∆ .

Key new ideas
While the upper bound Theorem 1.1 is a relatively simple adaptation of ideas from prior work, the lower bound Theorem 1.2 requires a development of a new proof strategy.
Prior lower-bound techniques in this area tend to fall in one of these categories, each unsuitable for us: 1. The lower-bound construction is a regular graph [4,12]. In a ∆-regular graphs we can trivially find a fractional matching using the value 1/∆, which is exponentially far from the lower bound in Theorem 1.2 that we aim at proving.
2. The lower-bound result aims at establishing that one needs some specific number of rounds, e.g., Ω(∆) rounds [4,10,12]. However, in Theorem 1.2 we aim at proving that even if the round complexity is, say, exponential in ∆, one cannot avoid using fine-grained fractional values.
Our proof strategy superficially resembles the one used in [10,12] in the sense that we start with one node and k self-loops, which represents the local view of a node in the middle of a regular graph, and then we start unfolding the loops. At each point of the process we see what is the output the algorithm commits to, and then we continue the process until we are left with a concrete lower-bound graph. However, there are major differences; see Fig. 2: • In [10,12] they start with a pair of nodes. The nodes have self-loops, and each self-loop represents an undirected edge; the entire argument relies on the fact that an algorithm cannot break symmetry between two ends of such an edge. At each step they unfold a relevant loop, doubling the number of nodes, and then they mix elements from two instances, resulting in another pair of instances. In each iteration they lose one self-loop but force the algorithm to look one step further.
• In this work we start with a single node. The node has self-loops, but this time each self-loop represents a long directed path; our argument relies on the fact that an algorithm cannot break local symmetry between two nodes near the middle of the path. At each step we unfold a relevant loop, but this will turn one node into a directed path of length Θ(T ). We are interested in the behavior of the algorithm both in the middle of the path and at the endpoints of the path. In each iteration we lose one self-loop but force the algorithm to use at least twice as large denominators.  [10,12], all the heavy lifting is done in a so-called EC model, in which edges are undirected but colored. Self-loops represent undirected edges. For example, a node with 2 self-loops represents a node in the middle of a 2-regular tree, i.e., a long path. (b) In this work, we work in the PO model. Self-loops represent long directed paths. For example, a node with 2 self-loops represents a node in the middle of a 4-regular tree in which all nodes have indegree 2 and outdegree 2.

Graphs and self-loops
For a graph G = (V, E), we write ∆(G) to denote the maximum degree of the graph. We use just ∆ when G is clear from the context. For any natural number d ∈ N, we use G d to represent the family of graphs such that G ∈ G d if ∆(G) ≤ d. Throughout this work, we will assume that the maximum degree of the input graph G is a globally known constant.
In what follows, we will refer to a self-loop simply as a loop. Each loop counts as one incoming and one outgoing edge (in particular, in G 2d a node can have at most d self-loops). We call a graph loopy if each vertex of the graph has at least one loop.

Model of computing
Our main results Theorems 1.1 and 1.2 hold in the usual LOCAL model [14,18]. For simplicity, we will focus here is on deterministic algorithms (even though the results are not hard to extend to randomized algorithms).
However, to prove the lower bound result, it will be convenient to first prove the lower bound in a weaker model (called PO here, following [10]) and then extend the result from the PO model to the LOCAL model. It will be easiest to define everything we need by starting with the deterministic port-numbering model (PN).
PN model (port numbering) [1,20]. Let G = (V, E) be the input graph. In the PN model, each node v ∈ V is a computer and each edge {u, v} ∈ E is a communication link between two computers. Initially, each computer is only aware of its degree; nodes of the same degree start with the same initial state.
The endpoints of the edges are labeled with port numbers; a node of degree d can refer to its incident edges with the numbers 1, 2, . . . , d; see Fig. 3. The port numbering comes from an adversary; a distributed algorithm in the PN model has to work correctly for any given port numbering.
Computation proceeds in synchronous communication rounds. In each round, each node can 1. send a message to each neighbor, 2. receive a message from each neighbor, and 3. update its local state based on the current state and the messages it received.
After each round, each node can decide whether it stops and announces its own part of the output-in the case of the maximal fractional problem, the output of a node indicates the fractional value assigned to each incident edge. The running time of the algorithm is the number of rounds until all nodes have stopped and announced their local outputs.
PO model (port numbering and orientation) [10,15]. Algorithms in the PO model behave in exactly the same way as in the PN model. However, there is one additional piece of information available to the algorithm: each edge {u, v} ∈ E is oriented (arbitrarily, by the adversary); see Fig. 3. More precisely, each node knows for each incident edge whether it is "outgoing" or "incoming".
While an arbitrary orientation may not seem particularly useful, note that the PO model is strictly stronger than the PN model. For example, if we have a graph G with two nodes and one edge, it is trivial to find a proper 2-coloring of G in the PO model in 0 rounds, while it is impossible to solve in the PN model in any number of rounds.
LOCAL model [14,18]. Algorithms in the LOCAL model also behave in exactly the same way as in the PN model, but there is again one additional piece of information available to the algorithm: each node is labeled (arbitrarily, by the adversary) with a unique identifier from a polynomially-sized set; see Fig. 3. Again, LOCAL model is strictly stronger than the PO model. For example, maximal matching cannot be found in the PO model if the input graph is a cycle that is consistently oriented, while the task is solvable in the LOCAL model in O(log * n) rounds.
However, it turns out that constant-time algorithms in the LOCAL model are not much stronger than algorithms in the PO model, see e.g. [9,10]. This is the idea we will also make use of in this work: our main goal is to prove a lower bound in the LOCAL model, but it will be convenient to first study the PO model.

Applying PO algorithms to loopy graphs
To prove the lower-bound result Theorem 1.2, we will study the output of a PO algorithm A in some loopy graph G. However, when we consider distributed graph algorithms, we usually assume that the input graph is loop-free.
However, the output of A in loopy graphs is nevertheless well-defined. When we refer to the output of A on some edge e in G, we refer to the result of the following thought experiment: Unfold all loops in G, as shown in Fig. 2b, and hence we arrive at a tree G . Then apply A in G (as the running time of A is independent of the size of the input graph, this is well-defined). Edge e in G corresponds to infinitely many edges e in G , but each such edge is symmetric and hence the output of A on each such edge e is the same; hence we can take any such edge e and interpret its label as the output of A on e.
In particular, if A finds a maximal fractional matching in any loop-free graph G , it will also produce a maximal fractional matching in the loopy graph G (the label of the loop is counted twice).

Lower bound result
In this section we prove the lower-bound result, Theorem 1.2. It turns out that the critical resource is the number of factors of 2 in the denominators. We start by defining sets of rational numbers that will precisely capture how fine-grained values are needed.

Sets of rational numbers
Any natural number x ≥ 1 can be written as x = 2 n · m where n ≥ 0 and m ≡ 1 mod 2. We refer to e(x) = 2 n as the even part of x and o(x) = m as the odd part of x. For x = 0, we define e(x) = 0 and o(x) = 1.
Note that for each rational number x ∈ [0, 1] there exists exactly one n such that x ∈ R n . For m < n, we have R ≤m R ≤n .

High-level plan
In Section 3.3 we prove the following lemma, which essentially shows that we can without loss of generality focus on the PO model: If there exists a t-time algorithm that solves the maximal fractional matching problem using values in a set R in the LOCAL model on any graph with maximum degree ∆, then there exists a t-time algorithm that solves the maximal fractional matching problem using values in set R in the PO model for any loopy graph G with maximum degree ∆.
Then in Section 3.4 we prove the following lemma, which captures exactly how finegrained rational values are needed in the PN model: Then, for any natural number T ∈ N, there does not exist any algorithm in the PO model that uses T rounds and computes a valid solution for the maximal fractional matching problem using the values from R ≤(d−1) for loopy graphs in graph family G 2d .
By putting together Lemma 3.1 and Lemma 3.2, we obtain:

Proof of Lemma 3.1
In [10], a similar result is shown with the exception that the edge labels are arbitrary. However, the same proof follows when we add the restriction that the edge labels come from R. This result is a simple extension of [10, Sections 5.3-5.4], where we can see that the simulation argument does not make changes in the value used for the PO model.

Proof of Lemma 3.2
Preliminary Observations. We first make a few observations regarding our problem. First recall the way in which we use loops to represent a node in the middle of a directed path (Fig. 2).
Observation 3.4. If a node has a loop then it must be saturated.
Proof. If a node with a loop was not saturated, we would have a directed path of unsaturated nodes and, in particular, edges with unsaturated endpoints.
In a saturated node, the labels of incident edges have to sum up to 1. The following observation captures a key property related to how the even parts of the denominators behave when rational numbers sum up to 1.
Observation 3.5. Let n ≥ 1 and k m·2 n ∈ R n . Consider the equation where each i and x i can be any non-negative rational number. Then, either i ∈ R >n or x i ∈ R ≥n for some i. Put otherwise, either some i has the even part of denominator larger than 2 n or some x i has the even part of denominator at least 2 n .
Proof. First consider the equation k m · 2 n = 1 in which each x i can be any non-negative rational number. We show that there exists an index i for which x i ∈ R ≥n . We can rewrite it as solving the equation where m·2 n −k m·2 n ∈ R n . If each x i had the even part of the denominator less than 2 n , then x 1 + . . . + x q would also have the even part of the denominator less than 2 n . This is because when we add two rationals a 1 b 1 and a 2 b 2 we get , the least common multiple of b 1 and b 2 . The even part of will be bounded above by the maximum of the even parts of b 1 and b 2 . However, if x 1 + . . . + x q has the even part of the denominator less than 2 n , then it contradicts the fact that the sum equals m·2 n −k m·2 n . Now, in order to prove the original statement of Observation 3.5, it is sufficient to replace x r +i by 2 i . If x r +i ∈ R ≥n then i ∈ R >n .
Assumptions. We now proceed to prove Lemma 3.2 by contradiction. For the sake of contradiction we assume that for any natural number d ∈ N, there exists a natural number T ∈ N such that the following holds: there exists a PO algorithm A that solves the maximal fractional matching solution in T rounds using values from the set R ≤(d−1) for graph family G 2d .
Properties. Now, our lower bound construction observes the behavior of A on different kinds of graphs in G 2d to reason about the set of values that is used. We will construct a sequence of loopy graphs G 0 , G 1 , . . . , G d−1 to argue that the further we go, the more fine-grained value must be used by our algorithm.
For each i = 0, 1, . . . d − 1, we will maintain the following properties: P2 Graph G i without loops forms a tree.
P3 Each node of G i has at least d − i loops.

P4
There is an integer j(i) > i and a node v i in G i such that A labels at least one loop of v i with a rational value x ∈ R j(i) .
Base Case. Our first graph G 0 consists of a single node v 0 with d oriented self loops (see Fig. 4).
Graph G 0 satisfies properties P1, P2 and P3 by construction, so we now need to verify only P4. Consider that A assigns values a 1 , . . . , a d to the loops of v 0 . Since v 0 has loops, it must be saturated (recall Observation 3.4), and hence it must satisfy that 2a 1 + 2a 2 + . . . + 2a d = 1. This is equivalent to solving a 1 + a 2 + . . . + a d = 1/2 and by Observation 3.5 we know that there exists an i with a i ∈ R ≥1 . G' 0 : Figure 4: Construction for d = 2 and T = 3. Graph G 0 consists of d self-loops. When we apply A to G 0 , at least one of the loops will get labeled by a value in R ≥1 ; in this example the value was 0.5 ∈ R 1 . To construct G 1 , we remove this loop to arrive at graph G 0 , take 2T + 3 copies of G 0 , and connect them with a directed path. The key observation is that given the output of A in G 0 we also know the output of A around the node in the middle of G 1 -this node is called the root node of G 1 .

Inductive
Step. Given G i−1 , we construct G i as follows; see Fig. 4: S3 For each k = 1, 2, . . . , 2T + 2, connect node v i−1 in copy number k to node v i−1 in copy number k + 1; these new edges are called path edges.

S4
Node v i−1 in copy number T + 2 is called the root node of G i .
This way we form a directed path of length 2T + 3, with the root node in the middle of the path, as shown in Fig. 4. The key observation is that the output of algorithm A on the root node of G i is the same as the output of A for v i−1 in G i−1 , due to the fact that the radius-T neighborhood of the root node in G i is isomorphic to the radius-T neighborhoods of v i−1 in G i−1 (once we conceptually unfold all loops). This property is illustrated in Fig. 4: compare the radius-T neighborhood of the black node in the unfolding of G 0 with the radius-T neighborhoods of the root node of G 1 .
Given G i−1 satisfies all the properties, we need to show that the same is true for G i . P1, P2 and P3 are satisfied by construction. To prove P4, consider the root node of G i . Since its behavior is completely characterized, we know that it will label the incident path edges with values from R j(i−1) .
Recall that by P2 graph G i without loops forms a tree. We will navigate in this tree, starting from the root node, and moving away from it until we satisfy P4. We maintain the following invariant; see Fig. 5: If v is the current node, and P is the unique path from v to the root, we have already concluded that A labels each edge of P with a value from R ≥j(i−1) . . We have already concluded that all edges in the path between v and the root node are labeled with values from R ≥1 . We now ask how algorithm A will label the other edges around v. (a) One possible solution: edge x 1 is labeled with a value 0.9 ∈ R 1 . We did not yet establish property P4, but we can extend the R 1 -labeled path further away from the root nodeeventually we will encounter a leaf node. (b) Another possible solution: we managed to label x 1 with a less fine-grained value 0.8 ∈ R 0 . However, this means that loop 1 is labeled with a more fain-grained value 0.05 ∈ R 2 . We have established P4.
To get started, let e be one of the path edges incident to the root node, and let v be the other end of e. As we discussed earlier, we know that e is labeled with a value from R j(i−1) . Now assume that we have reached some node v this way. Let P be the path from v to the root, and let e be the first edge of P , let L be the set of loops incident to v, and let X be the set of non-loop edges incident to v that are different from e. That is, we already know the label of edge e, but we do not yet know how A will label L and X.
Node v is loopy, so it must be saturated. The saturation condition for v is equivalent to solving the equation where n ≥ j(i − 1), values i represent the values assigned to the loops in L, values x i represent the values assigned to the edges in X, and k m·2 n refers to the value from R ≥j(i−1) assigned to edge e. With the help of Observation 3.5, we know that one of the two cases must be true: 1. One of the loops in L has the even part of denominator 2 n for n > n. In this case, we have established P4.
2. One of the edges {u, v} ∈ X has the even part of denominator at least 2 n . We have found another edge labeled with a value from R ≥j(i−1) , and we can extend the path P by moving from v to u, still satisfying the path invariant.
Note that this process will eventually terminate, as G i without loops is a (finite) tree, and hence we will eventually reach a leaf node with X = ∅. We have established that our construction of graph G i satisfies properties P1-P4.

Upper bound result
Here, we prove the statement of Theorem 1.1. We will use the notation We need to show that there is a T (∆)-round, independent of n, distributed algorithm that solves maximal fractional matching in graph family G 2d+1 using labels from S(d). We prove the claim by inductions, as follows: • Base case (Lemma 4. We use T (∆) to represent the number of rounds taken by our algorithm for graph family G ∆ . We show that in each of the above steps, T (∆) is just a function of ∆ and is independent of number of nodes n. We will give a PN algorithm, which implies the existence of a LOCAL algorithm. Proof. In this case, we want to pick x(e) ∈ {0, 1 2 , 1} for each e ∈ E. We can achieve a simple distributed algorithm with 1 round of communication. Each vertex v, communicates its degree to its neighbors. Any degree 2 vertex can safely assign the value 1 2 to both of its incident edges. For a degree 1 vertex, it will assign the value 1 2 to the incident edge if the other endpoint has degree 2 and will assign the value 1, if the other endpoint is 1 as well.
We can see that for each vertex v, the sum of the values assigned to its incident edges is at most 1. By the nature of our algorithm, every degree 2 node is saturated. So, every edge which has a degree 2 endpoint satisfy that one of its endpoint is saturated. The only remaining scenario is when both of the endpoints are degree 1. In this setting, our algorithm assigns the edge with value 1 in which case both of its endpoints are saturated as well. Using 1 round of communication, we have obtained a solution for the maximal fraction matching using values {0, 1 2 , 1} when ∆ = 2. This gives us T (2) = 1. Lemma 4.2. Fix d ∈ N. Assuming that S(d) is sufficient to obtain the solution for G 2d , S(d) is sufficient to obtain the solution for G 2d+1 as well.
Proof. Assume that A is a PN algorithm that computes the solution for G 2d using values in S(d). We now describe PN algorithm A that computes the solution for G ∈ G 2d+1 using values in S(d). Algorithm A takes the following steps (see Fig. 6 for an illustration):  Figure 6: (a) A graph G ∈ G 3 , with a port numbering. (b) The subgraph G for label = {1, 2}, with the edge types "End" and "Mid" indicated.
Step 1: Edge labelling. First, we use the port numbers to define a label for each edge. For each edge e = {u, v}, there exists numbers i, j ≤ ∆(G) such that port i of u is connected to port j of v. We label this edge with the set {i, j}. Then L = {{i, j} : 1 ≤ i, j ≤ ∆(G)} denotes the set of possible edge labels. We have |L| = O(∆ 2 ) different edge labels. For each ∈ L, we define the subgraph G of G that contains all the edges labelled . We write deg G (v) for the degree of node v in graph G . A key observation is that for each and v, we have deg G (v) ≤ 2, i.e., each G is a collection of paths and cycles.
Step 2: Edge Classification. We classify each edge into two types: "Mid" and "End". Consider any edge e = {u, v} and say it had label ∈ L. We say that e is of type "Mid" if deg G (u) = 2 and deg G (v) = 2. Put otherwise, all edges that are in the middle of the path or part of a cycle in G are classified with type "Mid". All other edges are classified as "End". Note that each node can determine the types of its incident edges in two rounds of communication.
Step 3: Solve for "Mid" edges. Consider subgraph G of G that contains all edges of type "Mid". We argue that ∆(G ) ≤ 2d. To see this, consider any vertex v ∈ V . If deg G (v) = 2d + 1, there exists ∈ L such that deg G (v) = 1, and therefore at least one edge adjacent to v will receive type "End" and not part of G . Now we have a subgraph G of G with ∆(G ) ≤ 2d, and we can simulate A in G .
Step 4: Extend for "End" edges. We notice that each edge e ∈ G satisfies the maximality condition, i.e., at least one endpoint is saturated. Thus, we now need to ensure the same for edges of type "End". For a label ∈ L, let G End to be set of edges labelled of type "End". We know that edges of type "End" can only be part of paths of length 1 and 2 in G End . We proceed to satisfy the maximality condition for edges of type "End" by considering them sequentially on the labels ∈ L.
Consider an edge e = {u, v} ∈ G End . If we assign x(e) = min{1 − x[u], 1 − x[v]} then we can ensure that e satisfies the maximality condition along with ensuring that both u and v satisfy the feasibility condition. The only issue that can arise here is that some other edge adjacent to u or v is trying to update its value in parallel with edge e. Since we are looking at edge of type "End" and proceeding sequentially based on label ∈ L, the above issue can only be caused by paths of