A $(2+\epsilon)$-Approximation for Maximum Weight Matching in the Semi-Streaming Model

TL;DR

This paper introduces a simple deterministic algorithm that achieves a near-optimal approximation for maximum weight matching in the semi-streaming model, improving the approximation ratio significantly with efficient space usage.

Contribution

It presents the first deterministic single-pass $(2+ ext{epsilon})$-approximation algorithm for maximum weight matching in semi-streaming, utilizing a novel variation of the local-ratio theorem.

Findings

Achieves a $(2+ ext{epsilon})$-approximation ratio.

Uses $O(n ext{log}^2 n)$ bits of space.

Improves upon the previous $(4+ ext{epsilon})$ approximation.

Abstract

We present a simple deterministic single-pass $(2+\epsilon)$-approximation algorithm for the maximum weight matching problem in the semi-streaming model. This improves upon the currently best known approximation ratio of $(4+\epsilon)$. Our algorithm uses $O(n\log^2 n)$ bits of space for constant values of $\epsilon$. It relies on a variation of the local-ratio theorem, which may be of use for other algorithms in the semi-streaming model as well.

Equations

$$x_i^{\ast }{w}_i$$

$$\le x_{i+1}^{\ast }{w}_{i+1}+{\bar{x}}_{i+1}^{\ast }{\bar{w}}_{i+1}$$

$$\le p\cdot x_i{w}_{i+1}+p\cdot x_i{\bar{w}}_{i+1}$$

$$=p\cdot x_i{w}_i,$$

$${\bar{w}}_{i+1}[e^{\prime }]=\{\begin{array}{ll}{w}_i[e]& e^{\prime }\in N^{+}(e);\\ 0& \text{otherwise,}\end{array}$$

$${\bar{w}}_{i+1}[e^{\prime }]=\{\begin{array}{ll}{w}_i[e]& e^{\prime }=e;\\ \alpha w[e]\text{ or }w[e]& e^{\prime }\in N(e);\\ 0& \text{otherwise,}\end{array}$$

$$x_i^{\ast }{w}_i$$

$$\le x_{i+1}^{\ast }{w}_{i+1}+{\bar{x}}_{i+1}^{\ast }{\bar{w}}_{i+1}$$

$$\le \beta x_{i+1}{w}_{i+1}+(1/p)x_{i+1}{w}_{i+1}$$

$$=(\beta +1/p)x_{i+1}{w}_{i+1}$$

$$\le (\beta +1/p)x_{i+1}{w}_i,$$

$${\beta }_{i+1}+{\beta }_{i+1}/\gamma$$

$$=2\alpha (1+1/\gamma {)}^{k+1-i}={\beta }_i.$$

$${\varphi }_j(v)$$

$$\ge {\varphi }_{j-1}(v)+(\alpha -1)({\varphi }_{j-1}(v)+{\varphi }_{j-1}(u))$$

$$\ge {\varphi }_{j-1}(v)+(\alpha -1){\varphi }_{j-1}(v)$$

$$=\alpha {\varphi }_{j-1}(v)$$

$$\ge \alpha \cdot {\alpha }^{c_{j-1}(v)-c_i(v)}{\varphi }_i(v)$$

$$={\alpha }^{c_j(v)-c_i(v)}{\varphi }_i(v),$$

$${\bar{w}}_{i+1}[e^{\prime }]=\{\begin{array}{ll}{w}_i[e_i]& e^{\prime }=e_i;\\ w_i[e_i]& e^{\prime }\in N(e_i)\text{ and e′ is heavy};\\ \alpha w_i[e_i]& e^{\prime }\in N(e_i)\text{ and e′ is light};\\ 0& \text{otherwise.}\end{array}$$

$$w_{i+1}[e_j]$$

$$\ge (\alpha -1){\varphi }_{j-1}(v)$$

$$\ge (\alpha -1){\alpha }^{c_{j-1}(v)-c_i(v)}{\varphi }_i(v)$$

$$\ge (\alpha -1){\alpha }^{c_{j-1}(v)-c_i(v)}{w}_i[e_i]$$

$$=(\alpha -1){\alpha }^{c_j(v)-c_i(v)-1}{w}_i[e_i]$$

$$w_{i+1}[e_j]\ge (\alpha -1){\alpha }^{c_j(v)-c_i(v)-1}{w}_i[e_i]\ge 2\alpha \gamma w_i[e_i].$$

$${\bar{w}}_{i+1}[e^{\prime }]=\{\begin{array}{ll}{w}_i[e_i]& e^{\prime }=e_i;\\ \alpha w_i[e_i]\text{ or }{w}_i[e_i]& e^{\prime }\in N(e_i);\\ 0& \text{otherwise.}\end{array}$$

$$({\beta }_{i+1}/\gamma )x_{i+1}{w}_{i+1}\ge 2\alpha w_i[e_i]\ge x^{\ast }{\bar{w}}_{i+1}$$

$${\varphi }_{i-1}(u)=\sum _{\left\{e_j|\begin{array}{c}u\in e_j\\ j\le i-1\end{array}\right\}}{w}_j[e_j],$$

$$w_i[e]=w_1[e]-\alpha \sum _{\left\{e_j|\begin{array}{c}{e}_j\in N(e)\\ j\le i-1\end{array}\right\}}{w}_j[e_j].$$

$${\beta }_1$$

$$=2\alpha {\left(1+(\ln \alpha )/n^2\right)}^{n^2}$$

$$\le 2\alpha e^{\ln \alpha }=2+ϵ.$$

$$\left|E(v)\right|$$

$$\le \frac{\log \frac{2n^2{\alpha }^2}{(\alpha -1{)}^2}}{\log \alpha }+2$$

$$=\frac{\log (2n^2)+2\log \alpha -2\log (\alpha -1)}{\log \alpha }+2$$

$$\le 6\frac{\log (2n^2)-2\log (ϵ/6)}{ϵ}+4$$

$$=O\left(\frac{\log n+\log (1/ϵ)}{ϵ}\right)$$

Full text

Our algorithm uses $O(n\log^{2}n)$ bits of space for constant values of $\epsilon$. It relies on a variation of the local-ratio theorem, which may be of use for other algorithms in the semi-streaming model as well.

1 Introduction

We present a simple $(2+\epsilon)$-approximation algorithm for the maximum weight matching (MWM) problem in the semi-streaming model. Our algorithm is deterministic, single-pass, requires only $O(1)$ processing time per incoming edge, and uses $O(n\log^{2}n)$ bits of space for any constant $\epsilon>0$. This improves upon the previously best known approximation algorithm of Crouch and Stubbs [CS14], which achieves an approximation ratio of $(4+\epsilon)$ and takes $O(\log n)$ time to process an edge. Our main result is as follows.

Theorem 1**.**

There exists an algorithm in the semi-streaming model computing a $(2+\epsilon)$-approximation for MWM, using $O(\epsilon^{-1}n\log n\cdot(\log n+\log(1/\epsilon)))$ bits and having an $O(1)$ processing time.

The MWM problem is a classical problem in graph theory. Its first efficient solution is due to Edmonds [Edm65], which was later improved by Micali and Vazirani [MV80]. The MWM problem was one of the first to be considered in the semi-streaming model when this model was first presented [FKM*+*05], and apparently the most studied problem in this model since (see “Related Work”).

In the first algorithms for the MWM problem in the semi-streaming model, a matching is maintained at all times, and is being updated according to the incoming edges. More recent algorithms sort the edges into weight classes, keep a subset of each class, and then find a matching in the union of these subsets.

Like previous algorithms, our algorithm maintains a set of edges from which the final matching is constructed; however, unlike some of the previous algorithms, we do not maintain a matching at all times, but only construct it in a post-processing stage. Our main technical contribution is the adaptation of the local-ratio technique for maximization problems [BYE85, BBF*+*01] to the semi-streaming model, in a novel and simple manner. Our work presents a significantly better approximation ratio for the MWM problem, along with a new approximation technique for optimization problems in the semi-streaming model.

For the maximum unweighted matching problem, a simple greedy algorithm yields a $2$-approximation. This was observed in the very first paper on the semi-streaming model [FKM*+*05], and not improved since. Any future improvement of the approximation factor to a constant smaller than $2$ will also solve this long-standing problem.

Our Contribution

When developing an algorithmic framework for a new model, it is natural to first address the most fundamental algorithmic problems. Finding a large matching in a graph is indeed a fundamental problem, which has been extensively studied in the model of semi-streaming graph algorithms. Our algorithm uses an extension of a well studied approximation framework, the local-ratio technique, while previous algorithm used clever ideas which were specifically crafted for the problem and model.

As noted, a simple greedy algorithm gives a 2-approximation for MWM in the unweighted case. In the weighted case, a 2-approximation can be achieved by first sorting the edges from the heaviest to the lightest, and then adding them greedily to form a matching. However, in the semi-streaming model it is impossible to keep a list of all the edges in the memory in order to sort them. Instead, the local-ratio technique allows us to ignore some of the edges, and run a greedy algorithm on the remaining edges, in an arbitrary order. In this work, we extend the local-ratio technique, in a way that allows us to discard all but $O(n\log n)$ of the edges, complying with the memory restrictions of the model.

A simple local-ratio algorithm for the MWM problem in the sequential model of computation goes roughly as follows: repeatedly select an edge with positive weight; reduce its weight from the edge itself and from all its neighboring edges; push the edge into a stack and continue to the next edge, as long as there is an edge with positive weight; finally, unwind the stack and add the edges greedily to the matching. This procedure results in a 2-approximation for the MWM problem. It can be extended to a $(2\alpha)$-approximation, for $\alpha>1$, if at each step we reduce the weight of the processed edge multiplied by $\alpha$ from its adjacent edges.

The challenge in translating this technique to the semi-streaming model is twofold. First, we have to reduce edge weights from edges that are yet to arrive. This is solved by saving, for each node, the total amount that should be reduced from each arriving edge containing this node, and reducing weight retroactively from incoming stream edges.

The second, more substantial challenge, is limiting the size of the stack, so it can comply with the $O(n\operatorname{polylog}n)$ space bound. It is not hard to come up with an execution of the above algorithm where all edges are eventually stored in the stack, which may take $\Omega(n^{2}\operatorname{polylog}n)$ bits of space. To overcome this problem, we remove edges from within the stack, during the execution of the algorithm. The traditional local-ratio technique was not designed to work under space limitations, and thus does not guarantee any approximation ratio if edges are removed from the stack. The crux of our approach is a variation of the local-ratio technique, which provides conditions under which an edge may be removed from the stack while incurring only a small loss in the approximation ratio.

Specifically, we show that if an edge in the stack is significantly lighter than its neighboring edge, and this neighboring edge is added to the stack, then removing the light edge has only a small effect on the total weight of the solution. In order to use this conclusion, we must first assure a steady increase in the edge weights around each node. This, in turn, requires another adaptation to the classical local-ratio approach for the problem.

To assure the constant growth of the edge weights, we increase the weight an edge reduces from its neighborhood by a multiplicative factor. This results in another deterioration in the approximation ratio, but has the benefit of forcing the weights of edges in the stack to exhibit a geometrical growth pattern. This, in turn, creates the conditions for our modified local-ratio theorem to show its strength, allowing us to keep the size of the stack within the model’s limits. Carefully choosing parameters that manage the trade-off between space and approximation ratio, we achieve a $(2+\epsilon)$-approximation using $O(n\log^{2}n)$ bits.

Finally, we note that the basic structure of the local-ratio technique, namely processing the edges one by one in an arbitrary order and then performing some postprocessing, suits very naturally to the streaming environment. Combined with the machinery we develop here in order to follow the semi-streaming space constraints, we believe this technique can be applied to additional problems in the semi-streaming model and in similar computational models.

Related Work

The study of graph algorithms in the semi-streaming model was initiated by Feigenbaum et al. [FKM*+*05], in order to tackle the problem of processing massive graphs whose edge set cannot be stored in memory. The need for algorithms for such massive graphs is evident, as they become increasingly common: graphs representing social networks, graphs for metabolic interactions used in computational biology and even the communication graph of the Internet, are only a few examples.

Feigenbaum et al. were also the first to study the MWM problem in the semi-streaming model, and presented a $6$-approximation algorithm for it. Their algorithm maintains a matching at all times: when an edge arrives, it checks if the new edge’s weight is more than double the sum of weights of its adjacent edges currently in the matching, and if so, the edge is added to the matching instead of its adjacent edges. This idea was later adapted by McGregor [McG05] to achieve an approximation ratio of $5.828$, by changing the threshold for inserting an edge to the matching (McGregor also presents a $(2+\epsilon)$-approximation algorithm for the problem, but using $O(\epsilon^{-3})$ passes on the input). By using similar ideas, while keeping deleted edges and reviving them later, Zelke [Zel12] achieves a $5.585$-approximation algorithm.

A different approach was taken by Epstein et al. [ELMS11], who achieve a $(4.911+\epsilon)$-approximation algorithm. They use bucketing, i.e., separate the edges into $O(\log n)$ weight classes, find a matching in each bucket, and then find the final matching in the union of these matching. Crouch and Stubbs [CS14] achieve an approximation ratio of $(4+\epsilon)$ using related ideas, but their algorithm uses weight classes which are unbounded from above, and thus are not disjoint. Grigorescu et al. [GMZ16] have presented an improved analysis of the last algorithm, claiming to achieve a $(3.5+\epsilon)$-approximation; unfortunately, this analysis currently seems to contain an error.

The bucketing technique takes a heavy toll on the approximation factor, and Crouch and Stubbs [CS14] prove this technique cannot give an approximation ratio better than $3.5$. To circumvent this bound, we use a different approximation framework, the local-ratio technique. To the best of our knowledge, this is the first application of this technique in a streaming model.

Recently, Ghaffari and Wajc [GW18] have shown a slight modification to our algorithm, that achieves the optimal $O(n\log n)$-bits bound, assuming that the edge weights are integers of size polynomial in $n$.

One related problem is estimating size of the maximum matching in a graph [AKL17, Kap13, KKS14, GKK12] which is known to be related to matrix rank approximation. More general submodular-function matching problems in the semi-streaming model have been considered by Varadaraja[Var11] and by Chakrabarti and Kale [CK14].

The MWM problem was also considered in other streaming models, such as the MapReduce model [CS14, LMSV11], the sliding-window model [CS14, CMS13] and the turnstile stream model (allowing deletions as well as insertions) [Kon15, AKLY16, BS15, CCE*+*16]. Extending our technique to other computational models is a challenge yet to be addressed.

Structure of this Paper

We formally define the MWM problem and the semi-streaming model of computation in Section 2. In Section 3 we introduce the local-ratio theorem, present a sequential 2-approximation local-ratio algorithm for MWM, and discuss our variations to the theorem. In Section 4 we extend the 2-approximation algorithm to a more involved $(2+\epsilon)$-approximation algorithm for MWM, analyze its performance, and finally adapt it to the semi-streaming model.

2 Preliminaries

Let $G=(V,E,w)$ be a simple graph with non-negative edge weights, $w\in\mathop{\mathbb{R}}_{+}^{E}$ (we use vector notation for edge weights). Denote $n=\left|V\right|$ and $m=\left|E\right|$; for an edge $e$ denote $N(e)=\left\{e^{\prime}\mid\left|e\cap e^{\prime}\right|=1\right\}$ called the neighboring edges of $e$, and $N^{+}(e)=N(e)\cup\left\{e\right\}$. We usually assume edge weights and their sums can be represented by $O(\log n)$ bits, and discuss other weight functions at the end of the paper.

Maximum Weight Matching

A matching in $G$ is a set $M\subseteq E$ of edges such that no two edges share a node. A maximum weight matching (MWM) in $G$ is a matching $M$ of maximum weight: for every matching $M^{\prime}$ in $G$, we have $\sum_{e\in M}w[e]\geq\sum_{e\in M^{\prime}}w[e]$.

A matching $M$ is identified with its indicator vector $x$, defined by $x[e]=1$ if $e\in M$, and $x[e]=0$ otherwise. Thus, the weight of a matching $x$ is the value of the inner product of $x$ and $w$, denoted $xw$. A set of feasibility constrains on $x$ is induced by the graph in a straightforward manner: $\forall e,e^{\prime}\in E:\left|e\cap e^{\prime}\right|=1\implies x[e]\cdot x[e^{\prime}]=0$.

Approximation Algorithms

A feasible matching $x$ is said to be a $p$-approximation of a MWM in $G$, for a constant $p\geq 1$, if every matching $x^{\ast}$ satisfies $x^{\ast}w\leq p\cdot xw$. An algorithm returning a $p$-approximation on every input graph is said to be a $p$-approximation algorithm for the MWM problem, and $p$ is called the approximation ratio of the algorithm. Note that if $p^{\prime}>p$ than a $p$-approximation algorithm is also a $p^{\prime}$-approximation algorithm. The definition naturally extends to other optimization problems.

The Semi-Streaming Model

In the semi-streaming model of computation, as in sequential models, the goal is to compute parameters in some given graph. An algorithm in this model proceeds in iterations, where in each iteration it receives an edge from the stream and processes it. Since the number of edges in the graph might be too large to fit in memory, we limit the algorithm to use only $O(n\operatorname{polylog}n)$ bits. In addition, we try to keep the processing times of the edges as short as possible, since a long processing time might result in a queue of later incoming edges, exceeding the space limitations. The algorithm is also allowed to perform pre-processing and post-processing, but minimizing their times is of less importance.

3 Approximating Maximum Weight Matching

In this section we present the local-ratio theorem for maximization problems [BBFR04], and use it to present a sequential 2-approximation algorithm for MWM. We then present extensions of this technique and use them in order to adjust the sequential local-ratio algorithm to the semi-streaming model, incurring only a small loss in the approximation ratio.

3.1 A Simple Local-Ratio Approximation Algorithm for MWM

The basic building blocks of a local-ratio algorithm are iterative weight reduction steps. Weight reduction step number $i$ starts with a graph $G=(V,E,w_{i})$, and defines two new graphs, composed of $(V,E)$ and new edge-weight functions: the reduced graph, which has weight function $w_{i+1}$, and the residual graph, which has weight function $\bar{w}_{i+1}$, such that $w_{i}=w_{i+1}+\bar{w}_{i+1}$. We start with the local-ratio theorem for maximization problems [BBFR04, Theorem 9], which we restate here for completeness. Note that this theorem applies even if $w_{i+1}$ takes negative values.

Theorem 2**.**

Let $w_{i}\in\mathop{\mathbb{R}}^{m}$ be a vector, and consider the problem of maximizing the product $xw_{i}$ under a set of feasibility constraints. Let $w_{i+1},\bar{w}_{i+1}\in\mathop{\mathbb{R}}^{m}$ be vectors such that $w_{i}=w_{i+1}+\bar{w}_{i+1}$. If $x_{i}\in\mathop{\mathbb{R}}^{m}$ is a feasible solution that is a $p$-approximation with respect to $w_{i+1}$ and with respect to $\bar{w}_{i+1}$, then $x_{i}$ is a $p$-approximation with respect to $w_{i}$ as well.

Proof.

Let $x_{i}^{\ast},x_{i+1}^{\ast}$ and $\bar{x}_{i+1}^{\ast}$ be maximum feasible solutions with respect to $w_{i},w_{i+1}$ and $\bar{w}_{i+1}$. Then

[TABLE]

where the first inequality follows from the maximality of $x^{\ast}_{i+1}$ and $\bar{x}^{\ast}_{i+1}$, and the second from the assumption that $x_{i}$ is a $p$-approximation with respect to $w_{i+1}$ and $\bar{w}_{i+1}$. ∎

We apply weight reduction steps iteratively, while ensuring that any $p$-approximate solution to $w_{i+1}$ can be easily extended into a $p$-approximate solution to $\bar{w}_{i+1}$.

For the specific problem of MWM, a weight reduction step is done by picking an arbitrary edge $e\in E$ of positive weight and reducing this weight from every $e^{\prime}\in N^{+}(e)$. This splits the weight vector $w_{i}$ into two vectors, $w_{i+1}$ and $\bar{w}_{i+1}$, by setting

[TABLE]

and $w_{i+1}=w_{i}-\bar{w}_{i+1}$. Any $2$-approximate solution $x_{i+1}$ for the reduced graph can be easily extended into a $2$-approximate solution for the residual graph by making sure that at least one edge $e^{\prime}\in N^{+}(e)$ is in the solution: if this is not the case, we can add $e$ to the solution without violating the constraints. As $w_{i+1}[e]=0$, adding $e$ to the solution does not reduce the solution’s value with respect to $w_{i+1}$. Thus, we get a 2-approximate solution for both $w_{i+1}$ and $\bar{w}_{i+1}$.

This simple technique is realized by Algorithm 1. First, it applies weight reduction steps iteratively using edges of positive reduced weight, splitting a weight function $w_{i}$ into $w_{i+1}$ (reduced) and $\bar{w}_{i+1}$ (residual) and keeping the edge in a stack. When no edge with a positive reduced weight remains, the algorithm unwinds the stack and adds the edges greedily to the matching. While unwinding the stack, it maintains a set of interim solutions $\left\{x_{i}\right\}$; the local-ratio theorem guarantees that every $x_{i}$ is a 2-approximate solution for $w_{i}$. Finally, the algorithm returns $x_{1}$, which is a 2-approximate solution for the original problem.

We note that this algorithm does not work in the semi-streaming model, as the stack can easily grow to contain $\Omega(n^{2})$ edges.

3.2 Extending the Local-Ratio Technique

We now extend the approximation techniques used in Algorithm 1. This allows us to present another sequential approximation algorithm for MWM in the following section, with a worse approximation ratio of $2+\epsilon$. However, from the new algorithm we derive the desired approximation algorithm for the semi-streaming model, with no further increase in the approximation ratio.

If instead of reducing exactly $w_{i}[e]$ from the neighboring edges of $e$, we reduce either $w_{i}[e]$ or $\alpha w_{i}[e]$ from each such edge, for some $\alpha\geq 1$, we get a $(2\alpha)$-approximation, as formalized by the next lemma.

Lemma 3**.**

Let $w_{i},w_{i+1}$ and $\bar{w}_{i+1}$ be weight functions and $e\in E$ an edge such that

[TABLE]

and $w_{i+1}=w-\bar{w}_{i+1}$; the choice between $w_{i}[e]$ and $\alpha w_{i}[e]$ can be arbitrary.

Let $x_{i}\in\{0,1\}^{m}$ be a matching. If $x_{i}[e^{\prime}]\neq 0$ for some $e^{\prime}\in N^{+}(e)$, then $x_{i}$ is a $(2\alpha)$-approximate solution for $\bar{w}_{i+1}$.

Proof.

Let $x_{i}^{\ast}$ be any matching. The definition of $\bar{w}_{i+1}$ guarantees that $x_{i}^{\ast}$ contains at most two edges of non-zero weight in $\bar{w}_{i+1}$, each of weight at most $\alpha w_{i}[e]$, so $x^{\ast}\bar{w}_{i+1}\leq 2\alpha w_{i}[e]$. On the other hand, $x_{i}[e^{\prime}]\neq 0$ for some $e^{\prime}\in N^{+}(e)$, so $w_{i}[e]\leq x_{i}\bar{w}_{i+1}$. Using the last two inequalities, we get $x^{\ast}\bar{w}_{i+1}\leq 2\alpha\cdot x_{i}\bar{w}_{i+1}$, as desired. ∎

Next, we note that if the optimal solution for the reduced graph is greater than the optimal solution for the residual graph by some multiplicative factor $p\geq 1$, then it is also a $(1+1/p)$-approximation for the original graph. For large values of $p$, an approximate solution for the reduced graph gives roughly the same approximation ratio for the original graph, which allows us to ignore the residual graph. We formalize this in the next lemma.

Lemma 4**.**

Let $w_{i},w_{i+1}$ and $\bar{w}_{i+1}$ be weight functions satisfying $w_{i}=w_{i+1}+\bar{w}_{i+1}$ and $w_{i+1}[e]\leq w_{i}[e]$ for all $e\in E$. Let $x_{i+1}$ be a $\beta$-approximate solution for $w_{i+1}$.

If $x_{i+1}w_{i+1}$ is at least $p$ times larger than any matching in $\bar{w}_{i+1}$, then $x_{i+1}$ is a $(\beta+1/p)$-approximate solution for $w_{i}$.

Proof.

Let $x_{i}^{\ast},x_{i+1}^{\ast}$ and $\bar{x}_{i+1}^{\ast}$ be matchings of maximum weights in $w_{i},w_{i+1}$ and $\bar{w}_{i+1}$ respectively.

The assumptions imply $x_{i+1}^{\ast}w_{i+1}\leq\beta x_{i+1}w_{i+1}$ and $p\bar{x}_{i+1}^{\ast}\bar{w}_{i+1}\leq x_{i+1}w_{i+1}$, so

[TABLE]

where the last inequality follows from the fact that $w_{i+1}[e]\leq w_{i}[e]$ for all $e\in E$. ∎

Let $w_{1}$ be a weight vector for the MWM problem, and consider an iterative splitting of $w_{i}$ into $w_{i+1}$ and $\bar{w}_{i+1}$ for $k$ times. The last lemma allowed us to ignore the residual graph once; we now extend it to allow the iterative omission of the residual graph.

Denote $\alpha=\sqrt{1+\epsilon/2}$, $\gamma=n^{2}/\ln(\alpha)$, and $\beta_{i}=2\alpha(1+1/\gamma)^{k+1-i}$ for all $i$.

Lemma 5**.**

Let $G=(V,E,w_{1})$ a graph, and $w_{2},\ldots,w_{k+1}$ and $\bar{w}_{2},\ldots\bar{w}_{k+1}$ sequences of reduced and residual weight functions for $(V,E)$, respectively.

Assume that we generate a sequence of solutions $x_{k+1},\ldots,x_{1}$, such that $x_{k+1}$ is an optimal solution for $w_{k+1}$, and that for $1\leq i\leq k$, if $x_{i+1}$ is a $\beta_{i+1}$-approximate solution for $w_{i+1}$ then $x_{i}$ has the following properties:

$x_{i}$* is a $\beta_{i+1}$-approximate solution for $w_{i+1}$.* 2. 2.

At least one of the following holds:

1. (a)

$x_{i}$* is a $\beta_{i+1}$-approximate solution for $\bar{w}_{i+1}$; or* 2. (b)

$x_{i}w_{i+1}\geq(\gamma/\beta_{i+1})x^{\ast}\bar{w}_{i+1}$* for every solution $x^{\ast}$.*

Then $x_{1}$ is a $\beta_{1}$-approximate solution for $w_{1}$.

Proof.

We prove, by induction on $i$ ranging from $k+1$ down to $1$, that $x_{i}$ is a $\beta_{i}$-approximate solution for $w_{i}$.

The base, $i=k+1$, is trivial by the assumption on $x_{k+1}$.

Assume the claim is true for $x_{i+1}$, then condition $1$ holds for $x_{i}$. If condition $2(a)$ holds, then by condition $1$ and the local-ratio theorem (Theorem 2), $x_{i}$ is a $\beta_{i+1}$-approximate solution for $w_{i}$. Because $\beta_{i}>\beta_{i+1}$, $x_{i}$ is also a $\beta_{i}$-approximate solution for $w_{i}$. If condition $2(b)$ holds, then from condition $1$ and Lemma 4 we deduce that $x_{i}$ is a $(\beta_{i+1}+\beta_{i+1}/\gamma)$-approximate solution for $w_{i}$. The definition of $\beta_{i}$ yields:

[TABLE]

Specifically, $x_{1}$ is a $\beta_{1}$-approximate solution for $w_{1}$, and the proof is complete. ∎

4 A Semi-Streaming Algorithm

We present a $(2+\epsilon)$-approximation algorithm for the MWM problem using our extension of the local-ratio technique. This algorithm is suitable for a streaming model which has no space constraints, but not for the semi-streaming model. We then present a lightweight variant of the algorithm, which obeys the space constraints of the semi-streaming model.

The new algorithm is similar to Algorithm 1: it performs a series of weight reduction steps defining a series of reduced weight functions $\left\{w_{i}\right\}$, and then constructs a series of approximate solutions $\left\{x_{i}\right\}$. To prove the desired approximation ratio is achieved, we use Lemma 5 as a substitute for the local-ratio theorem.

We start by presenting the challenges posed by the semi-streaming model, and the ways in which the new algorithm deals with them. Let $e_{i}$ be the edge considered in iteration $i$.

Retroactive weight reduction

The sequential algorithm constructs $w_{i+1}$ from $w_{i}$ using an edge $e_{i}$, by reducing $w_{i}(e_{i})$ form the weight of every $e^{\prime}\in N^{+}(e_{i})$. This cannot be done directly in the semi-streaming model, as some edges of $N^{+}(e_{i})$ might only arrive after $e_{i}$ is processed. Instead, the algorithm keeps a variable $\phi_{i}(v)=\sum_{j=1}^{i}w_{j}[e_{j}]$ for every node $v\in V$. When a new edge $e=(u,u^{\prime})$ arrives, its reduced weight is first computed, by reducing $\phi_{i-1}(u)$ and $\phi_{i-1}(u^{\prime})$ from its original weight.

Removing edges from the stack

In the sequential algorithm, the stack may grow to hold all of the graph edges. Lemma 5 presents conditions under which an approximate solution for $w_{i+1}$ is also an approximate solution for $w_{i}$. When these conditions are met, we may remove the edge $e_{i}$ from the stack, which we use in order to make sure that the stack’s size does not exceed $O(n\log n)$ edges.

Assuring edge-weight growth

In order to make sure edges are removed from the stack, we force a small but consistent growth in the edge weights around each node. Roughly speaking, the edge weights grow geometrically by a multiplicative $\alpha$ factor; after a logarithmic number of new edges considered, the weights grow large enough to allow the algorithm to neglect the older edges and remove them from the stack.

4.1 Algorithm MWM-seq

Algorithm MWM-seq (Algorithm 2) has two phases: in the first phase, it iterates over the edges and pushes chosen edges into a stack. In the second phase, the edges are popped out of the stack and added greedily to the matching.

The algorithm begins with an edge-weight function $w_{1}$, given as input. For each node $v$, the algorithm explicitly maintains a non-negative weight function $\phi_{i}(v)$, which is used to filter edges (Line 2): an edge $e=(u,u^{\prime})$ processed at iteration $i$ is light if $w_{1}[e]\leq\alpha(\phi_{i-1}(u)+\phi_{i-1}(u^{\prime}))$, and heavy otherwise. In iteration $i$, the algorithm processes the incoming edges, ignoring light edges until a heavy edge is encountered. This edge, denoted by $e_{i}$, is used to update $w_{i}$ and $\phi_{i}(v)$. Eventually, all heavy edges are denoted with sub-indexes ($e_{i}$), while the light edges are left un-tagged ($e$).

When an edge $e=(u,u^{\prime})$ is processed in iteration $i$, the algorithm performs all weight reduction steps on $e$ retroactively using $\phi_{i-1}(u)$ and $\phi_{i-1}(u^{\prime})$, to set the value of $w_{i}[e]$. It decides between reducing $\phi_{i-1}(u)+\phi_{i-1}(u^{\prime})$ or $\alpha(\phi_{i-1}(u)+\phi_{i-1}(u^{\prime}))$ from the weight of $e$, in a way that guarantees a geometric growth of $\phi$, implying a bound on the size of the stack.

For every node $v$, we hold a queue $E_{i}(v)$. This is a list of the heavy edges containing the node $v$ currently present in the stack. Upon the arrival of a heavy edge $e_{i}=(u,u^{\prime})$, we perform a weight reduction step: $\phi_{i-1}(u)$ and $\phi_{i-1}(u^{\prime})$ are increased by $w_{i}[e_{i}]$, and $e_{i}$ is pushed into the stack. We also enqueue $e_{i}$ in $E_{i}(u)$ and $E_{i}(u^{\prime})$. If the size of $E_{i}(u)$ or $E_{i}(u^{\prime})$ exceeds a certain bound, we dequeue an edge from the exceeding queue, and remove it from the stack. For the sake of analysis, we do not remove edges from the stack in Algorithm 2, but only replace them by a $\bot$ sign.

In the second phase, the algorithm unwinds the stack, adding edges greedily to the matching while ignoring $\bot$ symbols. The usage of the $\bot$ symbol is replaced by deletion of the relevant edge in the semi-streaming algorithm, presented in the next subsection.

We start the analysis of Algorithm MWM-seq by proving that the node-weight functions $\phi_{i}(v)$ grow geometrically with $i$. In the algorithm, the variable $c_{i}(v)$ counts the heavy edges containing $v$ that arrive until iteration $i$. Its value is not used in the algorithm itself; we only use it in the proof, to bound from below the growth $\phi(v)$. In various places in the analysis we consider the expression $c_{j}(v)-c_{i}(v)$, which is the number of heavy edges added to $v$ from iteration $i$ until iteration $j$. We eventually show that the reduced weights of heavy edges exhibit a growth pattern exponential in $c_{j}(v)-c_{i}(v)$.

Lemma 6**.**

For every $v\in V$ and $j\geq i$, $\phi_{j}(v)\geq\alpha^{c_{j}(v)-c_{i}(v)}\phi_{i}(v)$.

Proof.

We fix $i$ and prove the lemma by induction on $j$, where $j\geq i$. The base case, $j=i$, is trivial.

For $j>i$, we consider two cases: if $v\notin e_{j}$ then $c_{j}(v)=c_{j-1}(v)$, so $\phi_{j}(v)=\phi_{j-1}(v)\geq\alpha^{c_{j-1}(v)-c_{i}(v)}=\alpha^{c_{j}(v)-c_{i}(v)}$ by the induction hypothesis.

Otherwise, $e_{j}=(v,u)$ for some $u\in V$, and

[TABLE]

as desired. ∎

Consider the sequences of reduced and residual edge-weight functions, $w_{2},\ldots,w_{k+1}$ and $\bar{w}_{2},\ldots,\bar{w}_{k+1}$, induced by the algorithm. Note that these weight functions are defined on the fly: when an edge $e$ arrives, it implicitly sets $w_{j+1}(e)$ and $\bar{w}_{j+1}(e)$ of each of its adjacent heavy edges $e_{j}$, where $e_{j}$ may arrive before or after $e$. Thus, the values of $w_{i}$ and $\bar{w}_{i}$ are completely determined only when the first phase ends, and so does the length $k$ of the sequences.

The weight functions are defined inductively as follows. We formally define $w_{1}=w$, where $w$ is the function given as input. The edge $e_{i}$ is used to split the weight function $w_{i}$ into $w_{i+1}$ and $\bar{w}_{i+1}$, the latter defined by

[TABLE]

and the former by $w_{i+1}=w_{i}-\bar{w}_{i+1}$. The length $k$ is the number of heavy edges encountered in the first phase. Note that $\bar{w}$ is non-negative, so $w_{i}[e]$ is a non-increasing function of $i$, for any fixed edge $e$.

The next lemma focuses on a node $v$ and two heavy edges adjacent to it, $e_{i}$ and $e_{j}$. It asserts that for $j>i$, the reduced weight at iteration $i+1$ of a heavy edge $e_{j}$ grows geometrically with respect to $w_{i}[e_{i}]$.

Lemma 7**.**

Let $e_{i},e_{j}\in E$ such that $j>i$ and $e_{i}\cap e_{j}=\left\{v\right\}$. Then $w_{i+1}[e_{j}]>(\alpha-1)\alpha^{c_{j}(v)-c_{i}(v)-1}w_{i}[e_{i}]$.

Proof.

The lemma follows by a simple computation. As $w_{j}[e]$ is a non-increasing

[TABLE]

as desired. ∎

In the second loop of the algorithm, the edges are taken out of the stack and a solution is greedily constructed. The algorithm’s approximation ratio is the approximation ratio of the solution $x_{1}$ on the original weight function $w_{1}$. To bound this quantity, we prove by induction that every $x_{i}$ is a $\beta_{i}$-approximate solution for $w_{i}$. We break our analysis into cases, for which we need the next three lemmas. First, we consider an edge $e_{i}$ which is evicted from the stack.

Lemma 8**.**

If $x_{i+1}$ is a $\beta_{i+1}$-approximate solution for $w_{i+1}$ and the condition in Line 2 holds for $e_{i}$, then $x_{i}$ is a $\beta_{i}$-approximate solution for $w_{i}$.

Proof.

Since the condition in Line 2 holds, we have $x_{i}=x_{i+1}$. This immediately guarantees that $x_{i}$ is a feasible solution and that condition $1$ of Lemma 5 holds. We show that condition $2(b)$ of Lemma 5 holds as well.

As the condition in Line 2 holds, we know that in some iteration $j$ of the first phase, $j>i$, the condition in Line 2 held. That is, for some endpoint $v$ of $e_{i}$, an edge $e_{j}$ with $e_{i}\cap e_{j}=\left\{v\right\}$ was enqueued into $E_{j}(v)$, the condition $(\alpha-1)\alpha^{\left|E_{j}(v)\right|-2}>2\alpha\gamma$ held, and $e_{i}$ was then dequeued from $E_{j}(v)$.

Every enqueue operation to $E_{i}(v)$ is accompanied by an increases of $c_{i}(v)$ by $1$, so when the condition in Line 2 was checked, $e_{i}$ and $e_{j}$ were the oldest and newest elements in $E_{j}(v)$, respectively, and the size of $E_{j}(v)$ was exactly $c_{j}(v)-c_{i}(v)+1$. Thus, $(\alpha-1)\alpha^{c_{j}(v)-c_{i}(v)-1}\geq 2\alpha\gamma$.

Using this inequality and Lemma 7, we have

[TABLE]

Hence, the single edge $e_{j}$ is a matching of weight at least $2\alpha\gamma w_{i}[e_{i}]$ in $w_{i+1}$. As $x_{i+1}$ is a $\beta_{i+1}$-approximate solution for $w_{i+1}$, we have $\beta_{i+1}x_{i+1}w_{i+1}\geq 2\alpha\gamma w_{i}[e_{i}]$.

The definition of $\bar{w}_{i+1}$ guarantees it has the following structure:

[TABLE]

Thus, any solution $x^{\ast}$ for $\bar{w}_{i+1}$ contains at most two edges, of weight at most $\alpha w_{i}[e_{i}]$, i.e. $2\alpha w_{i}[e_{i}]\geq x^{\ast}\bar{w}_{i+1}$. The last two inequalities guarantee any solution $x^{\ast}$ satisfies

[TABLE]

so $x_{i}w_{i+1}=x_{i+1}w_{i+1}\geq(\gamma/\beta_{i+1})x^{\ast}\bar{w}_{i+1}$, and condition $2(b)$ of Lemma 5 holds. ∎

We now turn to the case of an edge $e_{i}$ that is not evicted from the stack.

Lemma 9**.**

If $x_{i+1}$ is a $\beta_{i+1}$-approximation for $w_{i+1}$ and the condition on Line 2 does not hold for $e_{i}$, then $x_{i}$ is a $\beta_{i}$-approximation for $w_{i}$.

Proof.

If the condition on Line 2 holds, then $x_{i}$ is derived from $x_{i+1}$ by adding $e_{i}$ to $x_{i+1}$. The condition in this line, together with the assumption that $x_{i+1}$ is a matching, guarantee that $x_{i}$ is a matching. Since $\bar{w}_{i+1}[e_{i}]=w_{i}[e_{i}]$ and $w_{i+1}=w_{i}-\bar{w}_{i+1}$, we have $w_{i+1}[e_{i}]=0$. Hence, $x_{i}w_{i+1}=x_{i+1}w_{i+1}$, so $x_{i}$ is also a $\beta_{i+1}$-approximate solution for $w_{i+1}$ and condition $1$ of Lemma 5 holds. By Lemma 3, $x_{i}$ is a $(2\alpha)$-approximate solution for $\bar{w}_{i+1}$, and because $2\alpha\leq\beta_{i+1}$ it is also a $\beta_{i+1}$-approximate solution to $\bar{w}_{i+1}$ and condition $2(a)$ of Lemma 5 holds.

Finally, if the condition in Line 2 does not hold, we set $x_{i}=x_{i+1}$. Then $x_{i}$ is a feasible matching satisfying condition $1$ of Lemma 5. The condition in Line 2 does not hold, so $x_{i+1}[e^{\prime}]\neq 0$ for some $e^{\prime}\in N^{+}[e_{i}]$, and Lemma 3 promises $x_{i}$ is a $(2\alpha)$-approximation for $\bar{w}_{i+1}$. As before, $2\alpha\leq\beta_{i+1}$ proves that condition $2(a)$ of Lemma 5 holds. ∎

Finally, we show that when the first phase ends, none of the reduced edge weights is positive.

Lemma 10**.**

At the end of the first phase, $w_{k+1}[e]\leq 0$ for all $e\in E$.

Proof.

Consider an edge $e$. If $e=e_{i}$ is heavy then $\bar{w}_{i+1}[e_{i}]=w_{i}[e_{i}]$ and $w_{i+1}=w_{i}-\bar{w}_{i+1}$ imply $w_{i+1}[e_{i}]=0$. The monotonicity of $w_{i}[e]$ completes the proof.

If $e=(u,u^{\prime})$ is a light edge considered in iteration $i$, then $w_{1}[e]\leq\alpha(\phi_{i-1}(u)+\phi_{i-1}(u^{\prime}))$. Line 2 guarantees

[TABLE]

and a similar claim holds for $u^{\prime}$. On the other hand, $w_{j+1}=w_{j}-\bar{w}_{j+1}$ and $\bar{w}_{j+1}[e]=\alpha w_{j}[e_{j}]$ for all $e_{j}\in N(e)$. Hence $w_{j+1}[e]=w_{j}[e]-\alpha w_{j}[e_{j}]$, and a simple induction implies

[TABLE]

The last two equalities, together with the definition of $N(e)$, imply $w_{i}[e]=w_{1}[e]-\alpha(\phi_{i-1}(u)+\phi_{i-1}(u^{\prime}))$. The inequality $w_{1}[e]\leq\alpha(\phi_{i-1}(u)+\phi_{i-1}(u^{\prime}))$ implies $w_{i}[e]\leq 0$ for all $e\in E$, and the monotonicity of $w_{i}[e]$ completes the proof. ∎

We are now ready to prove the main theorem of this section.

Theorem 11**.**

Algorithm MWM-seq returns a $(2+\epsilon)$-approximation for the MWM problem.

Proof.

By Lemma 10, the first loop ends when $w_{k+1}\leq\vec{0}$, so $x_{k+1}=\vec{0}$ is indeed an optimal solution for $w_{k+1}$.

Assume $x_{i+1}$ is a $\beta_{i+1}$-approximate solution for $w_{i+1}$. From Lemmas 8 and 9 we conclude that in all cases the conditions of Lemma 5 hold, so $x_{1}$ is a $\beta_{1}$-approximate solution for $w=w_{1}$.

Substitute $\beta_{1}=2\alpha(1+1/\gamma)^{k}$, $\alpha=\sqrt{1+\epsilon/2}$ and $\gamma=n^{2}/\ln(\alpha)$, and note $k\leq m\leq n^{2}$, to get

[TABLE]

The desired approximation ratio is achieved. ∎

4.2 Implementing Algorithm MWM-seq in the Semi-Streaming Model

In the previous section we showed that Algorithm MWM-seq computes a $(2+\epsilon)$-approximation for MWM. In the semi-streaming model, we must obey space constraints in addition to maintaining a good approximation ratio. In the presentation of the sequential algorithm we ignored the space constrains: we did not remove edges from the stack, and we represented the temporary solutions as the vectors $x_{i}$ of size $\Theta(n^{2})$.

In order to follow the space constraints, we replace any insertion of $\bot$ into the stack by a removal of the relevant edge, and the vectors $x_{i}$ by a single set containing the current matching. For the sake of completeness, we present Algorithm MWM-semi (Algorithm 3), an implementation of Algorithm MWM-seq in the semi-streaming model. The correctness of Algorithm MWM-semi is derived directly from the correctness of Algorithm MWM-seq, so we only need to prove it obeys the space constraints.

After omitting notations and auxiliary variables from Algorithm MWM-seq, we are left only with three types of data structures in Algorithm MWM-semi: $M$ is the matching constructed, $S$ is the stack and $E(v)$ is a queue of edges from $S$ that contain node $v$. Every edge $(u,u^{\prime})$ that is added to $S$ is also added to $E(u)$ and $E(u^{\prime})$. When $(u,u^{\prime})$ is removed from $E(u)$ or from $E(u^{\prime})$, it is also removed from $S$, implying $\left|S\right|\leq\sum_{v}\left|E(v)\right|$. The next lemma bounds the size of $E(v)$ for every $v$.

Lemma 12**.**

During the execution of Algorithm MWM-semi, $|E(v)|=O\left(\frac{\log n+\log(1/\epsilon)}{\epsilon}\right)$ for each $v\in V$.

Proof.

After each iteration of the loop in Lines 3–3, we have $(\alpha-1)\alpha^{\left|E(v)\right|-2}\leq 2\alpha\gamma$ for each $v\in V$: this is true at the beginning; $E(v)$ can grow only by 1 at each iteration; and whenever the inequality does not hold, an edge is removed from $E(v)$.

From the above inequality, $\alpha=\sqrt{1+\epsilon/2}$, and $\gamma=n^{2}/\ln(\alpha)$, we derive an asymptotic bound on $\left|E(v)\right|$.

[TABLE]

as desired. ∎

From Lemma 12 we conclude that, for a constant $\epsilon$, Algorithm MWM-semi maintains at most $O(n\log n)$ edges, each represented by $O(\log n)$ bits, giving a total space of $O(n\log^{2}n)$ bits. Our algorithm requires $O(1)$ time to process a new edge arriving from the stream, and $O(n\log n)$ time for the post-processing step. A similar analysis, without assuming $\epsilon$ is constant, implies the main theorem of this paper.

• **Theorem 1 **

There exists an algorithm in the semi-streaming model computing a $(2+\epsilon)$-approximation for MWM, using $O(\epsilon^{-1}n\log n\cdot(\log n+\log(1/\epsilon)))$ bits and having an $O(1)$ processing time.

In our analysis we assume that the edge weights can be represented using $O(\log n)$ bits, which is the case, e.g., for integer edge weights bounded by a polynomial in $n$. If this is not the case, and the weights are integers bounded by some $W$, our algorithm requires $O(n(\log^{2}n+\log W))$ bits, as it keeps a sum of weights for every node, and does not keep edge weights at all.

Acknowledgments

We thank Keren Censor-Hillel and Seri Khoury for helpful discussions, Seffi Naor for useful comments on the presentation, and the anonymous referees of SODA 2017 and ACM TALG for their comments.