Distributed Algorithms for Matching in Hypergraphs

As massive graphs become more ubiquitous, the need for scalable parallel and distributed algorithms that solve graph problems grows as well. In recent years, we have seen progress in many graph problems (e.g. spanning trees, connectivity, shortest paths [4, 5]) and, most relevant to this work, matchings [27, 22]. A natural generalization of matchings in graphs is to matchings in hypergraphs. Hypergraph Matching is an important problem with many applications such as capital budgeting, crew scheduling, facility location, scheduling airline flights [53], forming a coalition structure in multi-agent systems [50] and determining the winners in combinatorial auctions [49] (see [56] for a partial survey). Although matching problems in graphs are one of the most well-studied problems in algorithms and optimization, the NP-hard problem of finding a maximum matching in a hypergraph is not as well understood.

In this work, we are interested in the problem of finding matchings in very large hypergraphs, large enough that we cannot solve the problem on one computer. We develop, analyze and experimentally evaluate three parallel algorithms for hypergraph matchings in the MPC model. Two of the algorithms are generalizations of parallel algorithms for matchings in graphs. The third algorithm develops new machinery which we call a hyper-edge degree constrained subgraph (HEDCS), generalizing the notion of an edge-degree constrained subgraph (EDCS). The EDCS has been recently used in parallel and dynamic algorithms for graph matching problems [16, 17, 6]. We will show a range of algorithm tradeoffs between approximation ratio, rounds, memory and computation, evaluated both as worst case bounds, and via computational experiments.

More formally, a hypergraph $G$ is a pair $G=(V,E)$ where $V$ is the set of vertices and $E$ is the set of hyperedges. A hyperedge $e\in E$ is a nonempty subset of the vertices. The cardinality of a hyperedge is the number of vertices it contains. When every hyperedge has the same cardinality $d$, the hypergraph is said to be $d$-uniform. A hypergraph is linear if the intersection of any two hyperedges has at most one vertex. A hypergraph matching is a subset of the hyperedges $M\subseteq E$ such that every vertex is covered at most once, i.e. the hyperedges are mutually disjoint. This notion generalizes matchings in graphs. The cardinality of a matching is the number of hyperedges it contains. A matching is called maximum if it has the largest cardinality of all possible matchings, and maximal if it is not contained in any other matching. In the $d$-Uniform Hypergraph Matching Problem (also referred to as Set Packing or $d$-Set Packing), a $d$-uniform hypergraph is given and one needs to find the maximum cardinality matching.

We adopt the most restrictive MapReduce-like model of modern parallel computation among [40, 29, 11, 4], the Massively Parallel Computation (MPC) model of [11]. This model is widely used to solve different graph problems such as matching, vertex cover [44, 2, 7, 6, 27], independent set [27, 34], as well as many other algorithmic problems. In this model, we have $k$ machines (processors) each with space $s$. $N$ is the size of the input and our algorithms will satisfy $k\cdot s=\tilde{O}(N)$, which means that the total space in the system is only a polylogarithmic factor more than the input size. The computation proceeds in rounds. At the beginning of each round, the data (e.g. vertices and edges) is distributed across the machines. In each round, a machine performs local computation on its data (of size $s$), and then sends messages to other machines for the next round. Crucially, the total amount of communication sent or received by a machine is bounded by $s$, its space. For example, a machine can send one message of size $s$, or $s$ messages of size 1. It cannot, however, broadcast a size $s$ message to every machine. Each machine treats the received messages as the input for the next round. Our model limits the number of machines and the memory per machine to be substantially sublinear in the size of the input. On the other hand, no restrictions are placed on the computational power of any individual machine. The main complexity measure is therefore the memory per machine and the number of rounds $R$ required to solve a problem, which we consider to be the “parallel time” of the algorithm. For the rest of the paper, $G(V,E)$ is a $d$-uniform hypergraph with $n$ vertices and $m$ hyperedges, and when the context is clear, we will simply refer to $G$ as a graph and to its hyperedges as edges. $MM(G)$ denotes the maximum matching in $G$, and $\mu(G)=|MM(G)|$ is the size of that matching. We define $d_{G}(v)$ to be the degree of a vertex $v$ (the number of hyperedges that $v$ belongs to) in $G$. When the context is clear, we will omit indexing by $G$ and simply denote it $d(v)$.

We design and implement algorithms for the $d$-UHM in the MPC model. We will give three different algorithms, demonstrating different trade-offs between the model’s parameters. Our algorithms are inspired by methods to find maximum matchings in graphs, but require developing significant new tools to address hypergraphs. We are not aware of previous algorithms for hypergraph matching in the MPC model. First we generalize the randomized coreset algorithm of [7] which finds an 3-rounds $O(1)$-approximation for matching in graphs. Our algorithm partitions the graph into random pieces across the machines, and then simply picks a maximum matching of each machine’s subgraph. We show that this natural approach results in a $O(d^{2})$-approximation. While the algorithmic generalization is straightforward, the analysis requires several new ideas.

Our second result concerns the MPC model with per-machine memory $O(d\cdot n)$. We adapt the sampling technique and post-processing strategy of [44] to construct maximal matchings in hypergraphs, and are able to show that in $d$-uniform hypergraphs, this technique yields a maximal matching, and thus a $d$-approximation to the $d$-UHM problem in $O(\log{n})$ rounds.

Our third result generalizes the edge degree constrained subgraphs (EDCS), originally introduced by Bernstein and Stein [16] for maintaining large matchings in dynamic graphs, and later used for several other problems including matching and vertex cover in the streaming and MPC model [6, 17]. We call these generalized subgraphs hyper-edge degree constrained subgraphs (HEDCS). We show that they exist for specific parameters, and that they contain a good approximation for the $d$-UHM problem. We prove that an HEDCS of a hypergraph $G$, with well chosen parameters, contain a fractional matching with a value at least $\frac{d}{d^{2}-d+1}\mu(G)$, and that the underlying fractional matching is special in the sense that for each hyperedge, it either assigns a value of $1$ or a value less than some chosen $\epsilon$. We call such a fractional matching an $\epsilon$-restricted fractional matching. For Theorem 6.15, we compute an HEDCS of the hypergraph in a distributed fashion. This procedure relies on the robustness properties that we prove for the HEDCSs under sampling.

Table 1 summarizes our results.

The majority of our technical innovation is contained in Theorem 6.4 and 6.15. Our general approach is to construct, in parallel, an HEDCS that will contain a good approximation of the maximum matching in the original graph and that will fit on one machine. Then we can run an approximation algorithm on the resultant HEDCS to come up with a good approximation to the maximum matching in this HEDCS and hence in the original graph. In order to make this approach work, we need to generalize much of the known EDCS machinery [16, 17] to hypergraphs. This endeavor is quite involved, as almost all the proofs do not generalize easily and, as the results show, the resulting bounds are weaker than those for graphs. We first show that HEDCSs exist, and that they contain large fractional matchings. We then show that they are useful as a coreset, which amounts to showing that even though there can be many different HEDCSs of some fixed hypergraph $G(V,E)$, the degree distributions of every HEDCS (for the same parameters) are almost identical. In other words, the degree of any vertex $v$ is almost the same in every HEDCS of $G$. We show also that HEDCS are robust under edge sampling, in the sense that edge sampling from a HEDCS yields another HEDCS. These properties allow to use HEDCS in our coresets and parallel algorithm in the rest of the paper.

Hypergraph Matching. The problem of finding a maximum matching in $d$-uniform hypergraphs is NP-hard for any $d\geq 3$ [41, 48], and APX-hard for $d=3$ [39]. The most natural approach for an approximation algorithm for the hypergraph matching problem is the greedy algorithm: repeatedly add an edge that doesn’t intersect any edges already in the matching. This solution is clearly within a factor of $d$ from optimal: from the edges removed in each iteration, the optimal solution can contain at most $d$ edges (at most one for each element of the chosen edge). It is also easy to construct examples showing that this analysis is tight for the greedy approach. All the best known approximation algorithms for the Hypergraph Matching Problem in $d$-uniform hypergraphs are based on local search methods [13, 15, 20, 30, 36]. The first such result by Hurkens and Schrijver [36] gave a $(\frac{d}{2}+\epsilon)$-approximation algorithm. Halldorsson [30] presented a quasi-polynomial $(\frac{d+2}{3})$-approximation algorithm for the unweighted $d$-UHM. Sviridenko and Ward [54] established a polynomial time $(\frac{d+2}{3})$-approximation algorithm that is the first polynomial time improvement over the $(\frac{d}{2}+\epsilon)$ result from [36]. Cygan [21] and Furer and Yu [26] both provide a $(\frac{d+1}{3}+\epsilon)$ polynomial time approximation algorithm, which is the best approximation guarantee known so far. On the other hand, Hazan, Safra and Schwartz [35] proved that it is hard to approximate $d$-UHM problem within a factor of $\Omega(d/\log{d})$.

In this section, we generalize the randomized composable coreset algorithm of Assadi and Khanna [7]. They used a maximum matching as a coreset and obtained a $O(1)$-approximation. We use a hypergraph maximum matching and we obtain a $O(d^{2})$-approximation. We first define a $k$-partitioning and then present our greedy approach.

Let $G(V,E)$ be any $d$-uniform hypergraph and $G^{(1)},\ldots,G^{(k)}$ be a random $k$-partitioning of $G$. We describe a simple greedy process for combining the maximum matchings of $G^{(i)}$, and prove that this process results in a $O(d^{2})$-approximation of the maximum matching of $G$.

In the rest of the section, we present the proof of Theorem 4.2. Let $c=\frac{1}{3d(d-1)+3}$, we show that $M^{(k)}\geq c\cdot\mu(G)$ w.h.p, where $M^{(k)}$ is the output of Greedy. The randomness stems from the fact that the matchings $M^{(i)}$ (for $i\in\{1,\ldots,k\}$) constructed by Greedy are random variables depending on the random $k$-partitioning. We adapt the general approach in [7] for $d$-uniform hypergraphs, with $d\geq 3$. Suppose at the beginning of the $i$-th step of Greedy, the matching $M^{(i-1)}$ is of size $o(\mu(G)/d^{2})$. One can see that in this case, there is a matching of size $\Omega(\mu(G))$ in $G$ that is entirely incident on vertices of $G$ that are not matched by $M^{(i-1)}$. We can show that in fact $\Omega(\mu(G)/(d^{2}k))$ edges of this matching are appearing in $G^{(i)}$, even when we condition on the assignment of the edges in the first $(i-1)$ graphs. Next we argue that the existence of these edges forces any maximum matching of $G^{(i)}$ to match $\Omega(\mu(G)/(d^{2}k))$ edges in $G^{(i)}$ between the vertices that are not matched by $M^{(i-1)}$. These edges can always be added to the matching $M^{(i-1)}$ to form $M^{(i)}$. Therefore, while the maximal matching in Greedy is of size $o(\mu(G))$, we can increase its size by $\Omega(\mu(G)/(d^{2}k))$ edges in each of the first $k/3$ steps, hence obtaining a matching of size $\Omega(\mu(G)/d^{2})$ at the end. The following Lemma 4.3 formalizes this argument.

Before proving the lemma, we define some notation. Let $M^{*}$ be an arbitrary maximum matching of $G$. For any $i\in[k]$, we define $M^{*<i}$ as the part of $M^{*}$ assigned to the first $i-1$ graphs in the random $k$-partitioning, i.e., the graphs $G^{(1)},\ldots G^{(i-1)}$. We have the following concentration result:

We conclude this section by stating that computing a maximum matching on every machine is only required for the analysis, i.e., to show that there exists a large matching in the union of coresets. In practice, we can use an approximation algorithm to obtain a large matching from the coresets. In our experiments, we use a maximal matching instead of maximum.

In this section, we show how to compute a maximal matching in $O(\log{n})$ MPC rounds, by generalizing the algorithm in [44] to $d$-uniform hypergraphs. The algorithm provided by Lattanzi el al. [44] computes a maximal matching in graphs in $O(\log n)$ if $s=\Theta(n)$, and in at most$\lfloor c/\epsilon\rfloor$ iterations when $s=\Theta(n^{1+\epsilon})$, where $0<\epsilon<c$ is a fixed constant. Harvey et al. [34] show a similar result.

The algorithm first samples $O(s)$ edges and finds a maximal matching $M_{1}$ on the resulting subgraph (we will specify a bound on the memory $s$ later). Given this matching, we can safely remove edges that are in conflict (i.e. those incident on nodes in $M_{1}$) from the original graph $G$. If the resulting filtered graph $H$ is small enough to fit onto a single machine, the algorithm augments $M_{1}$ with a matching found on $H$. Otherwise, we augment $M_{1}$ with the matching found by recursing on $H$. Note that since the size of the graph reduces from round to round, the effective sampling probability increases, resulting in a larger sample of the remaining graph.

Next we present the proof of Theorem 5.1. We first show that after sampling edges, the size of the graph $G[I]$ induced by unmatched vertices decreases exponentially with high probability, and therefore the algorithm terminates in $O(\log{n})$ rounds. Next we argue that $M$ is indeed a maximal matching by showing that if after terminating, there is an edge that’s still unmatched, this will yield a contradiction. This is formalized in the following lemmas.

We are now ready to show that Iterated-Sampling can be implemented in $O(\log n)$ MPC rounds.

In graphs, edge degree constrained subgraphs (EDCS) [16, 17] have been used as a local condition for identifying large matchings, and leading to good dynamic and parallel algorithms [16, 17, 6]. These papers showed that an EDCS exists, that it contains a large matching, that it is robust to sampling and composition, and that it can be used as a coreset.

In this section, we present a generalization of EDCS for hypergraphs. We prove that an HEDCS exists, that it contains a large matching, that it is robust to sampling and composition, and that it can be used as a coreset. The proofs and algorithms, however, require significant developments beyond the graph case. We first present definitions of a fractional matching and HEDCS.

We show via a constructive proof that a hypergraph contains an HEDCS when the parameters of this HEDCS satisfy the inequality $\beta-\beta^{-}\geq d-1$.

The main result in this section shows that an HEDCS of a graph contains a large $\epsilon$-restricted fractional matching that approximates the maximum matching by a factor less than $d$.

In order to prove Theorem 6.4, we will need the following two lemmas. The first lemma we prove is an algebraic result that will help us bound the contribution of vertices in the $\epsilon$-restricted fractional matching. The second lemma identifies additional structure on the HEDCS, that we will use to construct the fractional matching of the theorem. For proofs of both lemmas, see Appendix A.2

We are now ready to prove Theorem 6.4.