Optimal Distributed Covering Algorithms

TL;DR

This paper introduces a time-optimal deterministic distributed algorithm for approximating minimum weight vertex cover in hypergraphs, achieving improved running times and approximation factors in the CONGEST model, with applications to integer covering-programs.

Contribution

It presents the first distributed algorithm with running time independent of vertex weights or number of vertices for this problem.

Findings

Achieves $(f+ ext{epsilon})$-approximation in $O(rac{ ext{log}\Delta}{ ext{log} ext{log}\Delta})$ rounds.

Improves running time over previous algorithms for constant $f$ and $ ext{epsilon}$.

Matches the best randomized time for weighted vertex cover with a deterministic algorithm.

Abstract

We present a time-optimal deterministic distributed algorithm for approximating a minimum weight vertex cover in hypergraphs of rank $f$. This problem is equivalent to the Minimum Weight Set Cover problem in which the frequency of every element is bounded by $f$. The approximation factor of our algorithm is $(f+\epsilon)$. Our algorithm runs in the CONGEST model and requires $O(\log\Delta/ \log\log\Delta)$ rounds, for constants $\epsilon\in(0,1]$ and $f\in N^+$. This is the first distributed algorithm for this problem whose running time does not depend on the vertex weights nor the number of vertices. For constant values of $f$ and $\epsilon$, our algorithm improves over the $(f+\epsilon)$-approximation algorithm of KMW06 whose running time is $O(\log \Delta + \log W)$, where $W$ is the ratio between the largest and smallest vertex weights in the graph. Our algorithm also achieves an $f$-approximation for the problem in $O(f\log n)$ rounds, improving over the classical result of KVY94 that achieves a running time of $O(f\log^2 n)$. Finally, for weighted vertex cover ($f=2$) our algorithm achieves a \emph{deterministic} running time of $O(\log n)$, matching the \emph{randomized} previously best result of KY11. We also show that integer covering-programs can be reduced to the Minimum Weight Set Cover problem in the distributed setting. This allows us to achieve an $(f+\epsilon)$-approximate integral solution in $O(\frac{\log\Delta}{\log\log\Delta}+(f\cdot\log M)^{1.01}\log\epsilon^{-1}(\log\Delta)^{0.01})$ rounds, where $f$ bounds the number of variables in a constraint, $\Delta$ bounds the number of constraints a variable appears in, and $M=\max \{1, 1/a_{\min}\}$, where $a_{min}$ is the smallest normalized constraint coefficient. This improves over the results of KMW06 for the integral case, which runs in $O(\epsilon^{-4}\cdot f^4\cdot \log f\cdot\log(M\cdot\Delta))$ rounds.

Tables

Table 1. Table 1: Previous distributed algorithms for mwvc . In the table, n = | V | 𝑛 𝑉 n=|V| and ε ∈ ( 0 , 1 ) 𝜀 0 1 \varepsilon\in(0,1) . Some of the algorithms hold only for the unweighted case and some are randomized. For randomized algorithms the running times hold in expectation or with high probability.

det.	weighted	approximation	time	algorithm
yes	no	3	$O\left(\Delta \right)$	[PS09]
yes	no	2	$O\left({\Delta }^2\right)$	[AFP+09]
yes	yes	2	$O\left(1\right)$ for $\Delta \le 3$	[AFP+09]
yes	yes	2	$O\left(\Delta +{\log }^{\ast }n\right)$	[PR01]
yes	yes	2	$O\left(\Delta +{\log }^{\ast }W\right)$	[AS10]
yes	yes	$2$	$O\left({\log }^{2}n\right)$	[KVY94]
yes	yes	2	$O\left(\log n\log \Delta /{\log }^2\log \Delta \right)$	[BEKS18]
no	yes	2	$O\left(\log n\right)$	[GKP08, KY11]
yes	yes	2	$𝑶\left(\mathrm{𝐥𝐨𝐠}𝒏\right)$	This work
yes	yes	$2+\epsilon$	$O\left({\epsilon }^{-4}\log \left(W\cdot \Delta \right)\right)$	[Hoc82, KMW06]
yes	yes	$2+\epsilon$	$O\left(\log {\epsilon }^{-1}\log n\right)$	[KVY94]
yes	yes	$2+\epsilon$	$O\left({\epsilon }^{-1}\log \Delta /\log \log \Delta \right)$	[BCS17, EGM18]
yes	yes	$2+\epsilon$	$O\left(\frac{\log \Delta }{\log \log \Delta }+\frac{\log {\epsilon }^{-1}\log \Delta }{{\log }^2\log \Delta }\right)$	[BEKS18]
yes	yes	$\mathrm{𝟐}+𝜺$	$𝑶\left(\frac{\mathrm{𝐥𝐨𝐠}𝚫}{\mathrm{𝐥𝐨𝐠}\mathrm{𝐥𝐨𝐠}𝚫}+\mathrm{𝐥𝐨𝐠}{𝜺}^{-\mathrm{𝟏}}\cdot {\left(\mathrm{𝐥𝐨𝐠}𝚫\right)}^{0.001}\right)$	This work
yes	yes	$2+\frac{\log \log \Delta }{c\cdot \log \Delta }$	$O\left(\log \Delta /\log \log \Delta \right)$	[BCS17], $\forall c=O\left(1\right)$
yes	yes	$2+{\left(\log \Delta \right)}^{-c}$	$O\left(\log \Delta /\log \log \Delta \right)$	[BEKS18], $\forall c=O\left(1\right)$
yes	yes	$\mathrm{𝟐}+{\mathrm{𝟐}}^{-𝒄\cdot {\left(\mathrm{𝐥𝐨𝐠}𝚫\right)}^{0.99}}$	$𝑶\left(\mathrm{𝐥𝐨𝐠}𝚫/\mathrm{𝐥𝐨𝐠}\mathrm{𝐥𝐨𝐠}𝚫\right)$	This work, $\forall c=O\left(\mathrm{𝟏}\right)$

Table 2. Table 2: Previous distributed algorithms for mwhvc . In the table, n = | V | 𝑛 𝑉 n=|V| and ε ∈ ( 0 , 1 ) 𝜀 0 1 \varepsilon\in(0,1) . All algorithms are deterministic. Note that [ EGM18 ] holds only for unweighted hypergraphs.

weighted	approximation	time	algorithm
yes	$f$	$O\left(f^2{\Delta }^2+f\Delta {\log }^{\ast }W\right)$	[AS10]
yes	$f$	$O\left(f{\log }^{2}n\right)$	[KVY94]
yes	$𝒇$	$𝑶\left(𝒇\mathrm{𝐥𝐨𝐠}𝒏\right)$	This work
no	$f+\epsilon$	$O\left({\epsilon }^{-1}\cdot f\cdot \frac{\log \left(f\Delta \right)}{\log \log \left(f\Delta \right)}\right)$	[EGM18]333The authors state their result for an $f\left(1+\epsilon \right)$-approximation which removes the $f$ factor from the runtime.
yes	$f+\epsilon$	$O\left(f\cdot \log \left(f/\epsilon \right)\cdot \log n\right)$	[KVY94]
yes	$f+\epsilon$	$O\left({\epsilon }^{-4}\cdot f^4\cdot \log f\cdot \log \left(W\cdot \Delta \right)\right)$	[KMW06]
yes	$𝒇+𝜺$	$𝑶\left(𝒇\cdot \mathrm{𝐥𝐨𝐠}\left(𝒇/𝜺\right)\cdot {\left(\mathrm{𝐥𝐨𝐠}𝚫\right)}^{0.001}+\frac{\mathrm{𝐥𝐨𝐠}𝚫}{\mathrm{𝐥𝐨𝐠}\mathrm{𝐥𝐨𝐠}𝚫}\right)$	This work
no	$f+1/c$	$O\left(\log \Delta /\log \log \Delta \right)$	[EGM18], $\forall f,c=O\left(1\right)$
yes	$𝒇+{\mathrm{𝟐}}^{-𝒄\cdot {\left(\mathrm{𝐥𝐨𝐠}𝚫\right)}^{0.99}}$	$𝑶\left(\mathrm{𝐥𝐨𝐠}𝚫/\mathrm{𝐥𝐨𝐠}\mathrm{𝐥𝐨𝐠}𝚫\right)$	This work, $\forall 𝒇,𝒄=𝑶\left(\mathrm{𝟏}\right)$

Equations

$$O\left(f\cdot \log (f/\epsilon )+\frac{\log \Delta }{\log \log \Delta }+\min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{0.001}\right\}\right)$$

$$w(v)(1-0.5^{{\ell }_i(v)})\le \sum _{e\in E(v)}{\delta }_{i-1}(e)\le (1-0.5^{{\ell }_i(v)+1})\cdot w(v).$$

$$\sum _{e\in E(v)}{\delta }_i(e)$$

$${\delta }_i(e)$$

$$\sum _{e\in E(v)}{\delta }_{i-1}(e)$$

$$O\left(f\cdot \log (f/\epsilon )+\frac{\log \Delta }{\gamma \cdot \log \log \Delta }+\min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{\gamma }\right\}\right).$$

$$O\left({\log }_{\alpha }\Delta +f\cdot z\cdot \alpha \right)=O\left({\log }_{\alpha }\Delta +f\cdot \log (f/\epsilon )\cdot \alpha \right).$$

$$\alpha$$

$$T(f,\Delta ,\epsilon )=O\left(f\cdot \log (f/\epsilon )+\frac{\log \Delta }{\log \log \Delta }+\min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{\gamma }\right\}\right).$$

$$\log \Delta \le \min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{\gamma /2}\cdot \log \log \Delta \right\}=O\left(\min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{\gamma }\right\}\right).$$

$$O\left(\log \Delta +f\cdot \log (f/\epsilon )\right)=O\left(f\cdot \log (f/\epsilon )+\min \left\{\log \Delta ,f\cdot \log (f/\epsilon )\cdot (\log \Delta {)}^{\gamma }\right\}\right).\text{qed}$$

$$\text{minimize: }\sum _{v\in V}w(v)\cdot x(v)$$

$$\begin{array}{rlr}\sum _{v\in e}x(v)& \ge 1,& \forall e\in E\\ x(v)& \ge 0,& \forall v\in V\end{array}$$

$$\text{maximize: }\sum _{e\in E}\delta (e)$$

$$\begin{array}{rlr}\sum _{e\ni v}\delta (e)& \le w(v),& \forall v\in V\\ \delta (e)& \ge 0,& \forall e\in E\end{array}$$

$$T_{\epsilon }$$

$$w(T_{\epsilon })$$

$$\le \frac{1}{1-\beta }\cdot \left(\sum _{v\in T_{\epsilon }}\sum _{e\ni v}\delta (e)\right)$$

$$\le \frac{f}{1-\beta }\sum _{e\in E}\delta (e)\le (f+\epsilon )\cdot \text{opt}.$$

$$\begin{gathered} \text{vspace}-3mm\sum _{e\in E(v)}{\delta }_{i-1}(e)=\sum _{e\in E(v)}\left({\delta }_{i-2}(e)+{\mathrm{deal}}_{i-1}(v)/2\right) \\ \le \left(1-0.5^{{\ell }_{i-1}(v)+1}+0.5^{{\ell }_{i-1}(v)+2}\right)\cdot w(v)=\left(1-0.5^{({\ell }_{i-1}(v)+1)+1}\right)\cdot w(v). \end{gathered}$$

Full text

\NewEnviron

problem \BODY

        Input:

        Output:

        Objective:

Optimal Distributed Covering Algorithms

Ran Ben-Basat Harvard University, ran@seas.harvard.edu   

Guy Even Tel Aviv University, guy@eng.tau.ac.il   

Ken-ichi Kawarabayashi NII, Japan, k_keniti@nii.ac.jp, greg@nii.ac.jp   

Gregory Schwartzman††footnotemark:

We present a time-optimal deterministic distributed algorithm for approximating a minimum weight vertex cover in hypergraphs of rank $f$. This problem is equivalent to the Minimum Weight Set Cover problem in which the frequency of every element is bounded by $f$. The approximation factor of our algorithm is $(f+\varepsilon)$. Let $\Delta$ denote the maximum degree in the hypergraph. Our algorithm runs in the congest model and requires $O(\log{\Delta}/\log\log\Delta)$ rounds, for constants $\varepsilon\in(0,1]$ and $f\in\mathbb{N}^{+}$. This is the first distributed algorithm for this problem whose running time does not depend on the vertex weights nor the number of vertices. Thus adding another member to the exclusive family of provably optimal distributed algorithms.

For constant values of $f$ and $\varepsilon$, our algorithm improves over the $(f+\varepsilon)$-approximation algorithm of [KMW06] whose running time is $O(\log\Delta+\log W)$, where $W$ is the ratio between the largest and smallest vertex weights in the graph. Our algorithm also achieves an $f$-approximation for the problem in $O(f\log n)$ rounds, improving over the classical result of [KVY94] that achieves a running time of $O(f\log^{2}n)$. Finally, for weighted vertex cover ($f=2$) our algorithm achieves a deterministic running time of $O(\log n)$, matching the randomized previously best result of [KY11].

We also show that integer covering-programs can be reduced to the Minimum Weight Set Cover problem in the distributed setting. This allows us to achieve an $(f+\varepsilon)$-approximate integral solution in $O\left((1+f/\log n)\cdot\left(\frac{\log\Delta}{\log\log\Delta}+\left(f\cdot\log M\right)^{1.01}\cdot\log\varepsilon^{-1}\cdot(\log\Delta)^{0.01}\right)\right)$ rounds, where $f$ bounds the number of variables in a constraint, $\Delta$ bounds the number of constraints a variable appears in, and $M=\max\left\{1,\lceil 1/a_{\min}\rceil\right\}$, where $a_{\min}$ is the smallest normalized constraint coefficient. This improves over the results of [KMW06] for the integral case, which combined with rounding achieves the same guarantees in $O\left(\varepsilon^{-4}\cdot f^{4}\cdot\log f\cdot\log(M\cdot\Delta)\right)$ rounds.

1 Introduction

In the Minimum Weight Hypergraph Vertex Cover (mwhvc) problem, we are given a hypergraph $G=(V,E)$ with vertex weights $w:V\to\left\{1,\ldots,W\right\}$.111Let $n\triangleq|V|$. We assume that $|E|=n^{O(1)}$ and $W=n^{O(1)}$. The goal is to find a minimum weight cover $U\subseteq V$ such that $\forall e\in E:e\cap U\neq\emptyset$. In this paper we develop a distributed approximation algorithm for mwhvc in the congest model. The approximation ratio is $f+\varepsilon$, where $f$ denotes the rank of the hypergraph (i.e., $f$ is an upper on the size of every hyperedge). The mwhvc problem is a generalization of the Minimum Weight Vertex Cover (mwvc) problem (in which $f=2$). The mwhvc problem is also equivalent to the Minimum Weight Set Cover Problem (the rank $f$ of the hypergraph corresponds to the maximum frequency of an element). Both of these problems are among the classical NP-hard problems presented in [Kar72].

We consider the following distributed setting for the mwhvc problem. The communication network is a bipartite graph $H(E\cup V,\left\{\left\{e,v\right\}\mid v\in e\right\})$. We refer to the network vertices as nodes and network edges as links. The nodes of the network are the hypergraph vertices on one side and hyperedges on the other side. There is a network link between vertex $v\in V$ and hyperedge $e\in E$ iff $v\in e$. The computation is performed in synchronous rounds, where messages are sent between neighbors in the communication network. As for message size, we consider the congest model where message sizes are bounded to $O(\log|V|)$. This is more restrictive than the local model where message sizes are unbounded.

1.1 Related work

We survey previous results for mwhvc and mwvc. A comprehensive list of previous results appears in Tables 1 and Table 2.

Vertex Cover.

The understanding of the round complexity for distributed mwvc has been established in two papers: a lower bound in [KMW16] and a matching upper bound in [BCS17]. Let $\Delta$ denote the maximum vertex degree in the graph $G$. The lower bound states that any distributed constant-factor approximation algorithm requires $\Omega(\log\Delta/\log\log\Delta)$ rounds to terminate. This lower bound holds for every constant approximation ratio, for unweighted graphs and even if the message lengths are not bounded (i.e., LOCAL model) [KMW16]. The matching upper bound is a $(2+\varepsilon)$-approximation distributed algorithm in the congest model, for every $\varepsilon=\Omega(\log\log\Delta/\log\Delta)$.222Recently, the range of $\varepsilon$ for which the runtime is optimal was improved to $\Omega(\log^{-c}\Delta)$ for any $c=O(1)$ [BEKS18]. In [KY11] an $O(\log n)$-round 2-approximation randomized algorithm for weighted graphs in the congest model is given. We note that [KY11] was the first to achieve this running time with no dependence on $W$, the maximum weight of the nodes.

Hypergraph Vertex Cover.

For constant values of $f$, Astrand et al. [AS10] present an $f$-approximation algorithm for anonymous networks whose running time is $O(\Delta^{2}+\Delta\cdot\log^{*}W)$. Khuller et al. [KVY94] provide a solution that runs in $O(f\log 1/\varepsilon\cdot\log n)$ rounds in the congest model for any $\varepsilon>0$ and achieves an $(f+\varepsilon)$-approximation. Setting $\varepsilon=1/W$ (recall that $W=poly(n)$) results in a $f$-approximation in $O(f\log^{2}n)$-rounds. For constant $\varepsilon$ and $f$ values, Kuhn et al. [Kuh05, KMW06] present an $(f+\varepsilon)$-approximation algorithm that terminates in $O(\log\Delta+\log W)$ rounds.

For the Minimum Cardinality Vertex Cover in Hypergraphs Problem, the lower bound was recently matched by [EGM18] with an $(f+\varepsilon)$-approximation algorithm in the congest model. The round complexity in [EGM18] is $O\left(f/\varepsilon\cdot\frac{\log(f\cdot\Delta)}{\log\log(f\cdot\Delta)}\right)$, which is optimal for constant $f$ and $\varepsilon$. The algorithm in [EGM18] and its analysis is a deterministic version of the randomized maximal independent set algorithm of [Gha16].

1.2 Our contributions

In this paper, we present a deterministic distributed $(f+\varepsilon)$-approximation algorithm for minimum weight vertex cover in $f$-rank hypergraphs, which completes in

[TABLE]

rounds in the congest model. For any constants $\varepsilon\in(0,1)$ and $f\in\mathbb{N}^{+}$ this implies a running time of $O(\log{\Delta}/\log\log\Delta)$, which is optimal according to [KMW16]. This is the first distributed algorithm for this problem whose round complexity does not depend on the node weights nor the number of vertices.

Our algorithm is one of a handful of distributed algorithms for local problems which are provably optimal [CV86, CKP16, BCGS17, BCS17, GS17, EGM18]. Among these are the classic Cole-Vishkin algorithm [CV86] for 3-coloring a ring, the more recent results of [BCGS17] and [BCS17] for mwvc and Maximum Matching, and the result of [EGM18] for Minimum Cardinality Hypergraph Vertex Cover.

Our algorithm also achieves a deterministic $f$-approximation for the problem in $O(f\log n)$ rounds. This improves over the best known result for hypergraphs $O(f\log^{2}n)$ [KVY94] and matches the best known randomized results for weighted vertex cover ($f=2$) of $O(\log n)$-rounds [KY11].

We also show that general covering Integer Linear Programs (ILPs) can be reduced to mwhvc in the distributed setting. That is, LP constraints can be translated into hyperedges such that a cover for the hyperedges satisfies all covering constraints. This allows us to achieve an $(f+\varepsilon)$-approximate integral solution in $O\left((1+f/\log n)\cdot\left(\frac{\log\Delta}{\log\log\Delta}+\left(f\cdot\log M\right)^{1.01}\cdot\log\varepsilon^{-1}\cdot(\log\Delta)^{0.01}\right)\right)$ rounds, where $f$ bounds the number of variables in a constraint, $\Delta$ bounds the number of constraints a variable appears in, and $M=\max\left\{1,\lceil 1/a_{\min}\rceil\right\}$, where $a_{min}$ smallest normalized constraint coefficient. This significantly improves over the results of [KMW06] for the integral case, which combined with rounding achieves the same guarantees in $O\left(\varepsilon^{-4}\cdot f^{4}\cdot\log f\cdot\log(M\cdot\Delta)\right)$ rounds. Note that the results of [KMW06] also include a $(1+\varepsilon)$-approximation for the fractional case, while our result only allows for an integral solution. We also note that plugging $\varepsilon=1/nWM$ into our algorithm, achieves an $f$-approximation for ILPs in polylogarithmic time, a similar result cannot be achieved using [KMW06].

1.3 Tools and techniques

The Primal-Dual schema.

The Primal-Dual approach introduces, for every hyperedge $e\in E$, a dual variable denoted by $\delta(e)$. The dual edge packing constraints are $\forall v\in V,\sum_{v\in e}\delta(e)\leq w(v)$. If for some $\beta\in[0,1)$ it holds that $\sum_{v\in e}\delta(e)\geq(1-\beta)\cdot w(v)$, we say the $v$ is $\beta$-tight. Let $\beta=\varepsilon/(f+\varepsilon)$. For every feasible dual solution, the weight of the set of $\beta$-tight vertices is at most $(f+\varepsilon)$ times the weight of an optimal (fractional) solution. The algorithm terminates when the set of $\beta$-tight edges constitutes a vertex cover.

The challenge.

When designing a Primal-Dual distributed algorithms, the main challenge is in controlling the rate at which we increase the dual variables. On the one hand, we must grow them rapidly to reduce the number of communication rounds. On the other hand, we may not violate the edge packing constraints. This is tricky in the distributed environments as we have to coordinate between nodes. For example, the result of [BCS17] does not generalize to hypergraphs, as hyperedges require the coordination of more than two nodes in order to increment edge variables.

Our algorithm.

The algorithm proceeds in iterations, each of which requires a constant number of communication rounds. We initialize the dual variables in a "safe" way so that feasibility is guaranteed. We refer to the additive increase of the dual variable $\delta(e)$ as $\operatorname*{deal}(e)$. Similarly to [BEKS18], we use levels to measure the progress made by a vertex. Whenever the level of a vertex increases, it sends a message about it to all incident edges, which multiply (decrease) their deals by $0.5$. Intuitively, the level of a vertex equals the logarithm of its uncovered portion. Formally, we define the level of a vertex $v$ as $\ell(v)\triangleq\left\lfloor\log\frac{w(v)}{w(v)-\sum_{e\ni v}\delta(e)}\right\rfloor$. That is, the initial level of $v$ is [math] and it is increased as the dual variables of the edges incident to $v$ grow. The level of a vertex never reaches $z\triangleq\lceil\log\beta^{-1}\rceil$ as this implies that it is $\beta$-tight and entered the cover. Loosely speaking, the algorithm increases the increments $\operatorname*{deal}(e)$ exponentially (multiplication by $\alpha$) provided that no vertex $v\in e$ is $(0.5^{\ell(v)}/\alpha)$-tight with respect to the deals of the previous iteration. Here, $\alpha\geq 2$ is a positive parameter that we determine later. The analysis builds on two observations: (1) The number of times that the increment $\operatorname*{deal}(e)$ is multiplied by $\alpha$ is bounded by $\log_{\alpha}\Delta$. (2) The number of iterations in which $\operatorname*{deal}(e)$ is not multiplied by $\alpha$ is bounded by $O(f\cdot z\cdot\alpha)$. Loosely speaking, each such iteration means that for at least one vertex $v\in e$ the sum of deals is at least an $1/(2\alpha)$-fraction of its slack. Therefore, after at most $O(\alpha)$ such iterations that vertex will level up. Since there are $z$ levels per vertex and $f$ vertices in $e$, we have that the number of such iterations is at most $O(f\cdot z\cdot\alpha)$. Hence the total number of iterations is bounded by $O(\log_{\alpha}\Delta+f\cdot z\cdot\alpha)$.

Integer linear programs (ILPs).

We show distributed reductions that allow us to compute an $(f+\varepsilon)$-approximation for general covering integer linear programs (ILPs). To that end, we first show that any Zero-One covering program (where all variables are binary) can be translated into a set cover instance in which the vertex degree is bounded by $2^{f}$ times the bound on the number of constraints each ILP variable appears in. We then generalize to arbitrary covering ILPs by replacing each variable with multiple vertices in the hypergraph, such that the value associated with the ILP variable will be the weighted sum of the vertices in the cover.

2 Problem Formulation

Let $G=(V,E)$ denote a hypergraph. Vertices in $V$ are equipped with positive weights $w(v)$. For a subset $U\subseteq V$, let $w(U)\triangleq\sum_{v\in U}w(v)$. Let $E(U)$ denote the set of hyperedges that are incident to some vertex in $U$ (i.e., $E(U)\triangleq\{e\in E\mid e\cap U\neq\emptyset\}$).

The Minimum Weight Hypergraph Vertex Cover Problem (mwhvc) is defined as follows. {problem}

The mwhvc Problem is equivalent to the Weighted Set Cover Problem. Consider a set system $(X,\mathcal{U})$, where $X$ denotes a set of elements and $\mathcal{U}=\left\{U_{1},\ldots,U_{m}\right\}$ denotes a collection of subsets of $X$. The reduction from the set system $(X,\mathcal{U})$ to a hypergraph $G=(V,E)$ proceeds as follows. The set of vertices is $V\triangleq\left\{u_{1},\ldots,u_{m}\right\}$ (one vertex $u_{i}$ per subset $U_{i}$). The set of edges is $E\triangleq\left\{e_{x}\right\}_{x\in X}$ (one hyperedge $e_{x}$ per element $x$), where $e_{x}\triangleq\left\{u_{i}:x\in U_{i}\right\}$. The weight of vertex $u_{i}$ equals the weight of the subset $U_{i}$.

3 Distributed

Approximation Algorithm for MWHVC

3.1 Input

The input is a hypergraph $G=(V,E)$ with non-negative vertex weights $w:V\rightarrow\mathbb{N}^{+}$ and an approximation ratio parameter $\varepsilon\in(0,1]$. We denote the number of vertices by $n$, the rank of $G$ by $f$ (i.e., each hyperedge contains at most $f$ vertices), and the maximum degree of $G$ by $\Delta$ (i.e., each vertex belongs to at most $\Delta$ edges).

Assumptions.

We assume that

(i) Vertex weights are polynomial in $n\triangleq|V|$ so that sending a vertex weight requires $O(\log n)$ bits.

(ii) Vertex degrees are polynomial in $n$ (i.e., $|E(v)|=n^{O(1)}$) so that sending a vertex degree requires $O(\log n)$ bits. Since $|E(v)|\leq n^{f}$, this assumption trivially holds for constant $f$.

(iii) The maximum degree is at least $3$ so that $\log\log\Delta>0$.

3.2 Output

A vertex cover $C\subseteq V$. Namely, for every hyperedge $e\in E$, the intersection $e\cap C$ is not empty. The set $C$ is maintained locally in the sense that every vertex $v$ knows whether it belongs to $C$ or not.

3.3 Communication Network

The communication network $N(E\cup V,\left\{\left\{e,v\right\}\mid v\in e\right\})$ is a bipartite graph. There are two types of nodes in the network: servers and clients. The set of servers is $V$ (the vertex set of $G$) and the set of clients is $E$ (the hyperedges in $G$). There is a link $(v,e)$ from server $v\in V$ to a client $e\in E$ if $v\in e$. We note that the degree of the clients is bounded by $f$ and the degree of the servers is bounded by $\Delta$.

3.4 Parameters and Variables

• •

The approximation factor parameter is $\varepsilon\in(0,1]$. The parameter $\beta$ is defined by $\beta\triangleq\varepsilon/(f+\varepsilon)$, where $f$ is the rank of the hypergraph.

• •

Each vertex $v$ is assigned a level $\ell(v)$ which is a nonnegative integer.

• •

We denote the dual variables at the end of iteration $i$ by $\delta_{i}(e)$ (see Appendix A for a description of the dual edge packing linear program). The amount by which $\delta_{i}(e)$ is increased in iteration $i$ is denoted by $\operatorname*{deal}_{i}(e)$. Namely, $\delta_{i}(e)=\sum_{j\leq i}\operatorname*{deal}_{j}(e)$.

• •

The parameter $\alpha\geq 2$ determines the factor by which deals are multiplied. We determine its value in the analysis in the following section.

3.5 Notation

• •

We say that an edge $e$ is covered by $C$ if $e\cap C\neq\emptyset$.

• •

Let $E(v)\triangleq\{e\in E\mid v\in e\}$ denote the set of hyperedges that contain $v$.

• •

For every vertex $v$, the algorithm maintains a subset $E^{\prime}(v)\subseteq E(v)$ that consists of the uncovered hyperedges in $E(v)$ (i.e., $E^{\prime}(v)=\{e\in E(v)\mid e\cap C=\emptyset\}$).

3.6 Algorithm MWHVC

Initialization. Set $C\leftarrow\emptyset$. For every vertex $v$, set level $\ell(v)\leftarrow 0$ and uncovered edges $E^{\prime}(v)\leftarrow E(v)$. 2. 2.

Iteration $i=0$. Every edge $e$ collects the weight $w(v)$ and degree $|E(v)|$ from every vertex $v\in e$, and sets: $\operatorname*{deal}(e)=0.5\cdot\min_{v\in e}\{w(v)/|E(v)|$}. The value $\operatorname*{deal}(e)$ is sent to every $v\in e$. The dual variable is set to $\delta(e)\leftarrow\operatorname*{deal}(e)$. 3. 3.

For $i=1$ to $\infty$ do:

1. (a)

Check $\beta$-tightness. For every $v\not\in C$, if $\sum_{e\in E(v)}\delta(e)\geq(1-\beta)w(v)$, then $v$ joins the cover $C$, sends a message to every $e\in E^{\prime}(v)$ that $e$ is covered, and vertex $v$ terminates. 2. (b)

For every uncovered edge $e$, if $e$ receives a message that it is covered, then it tells all its vertices that $e$ is covered and terminates. 3. (c)

For every vertex $v\notin C$, if it receives a message from $e$ that $e$ is covered, then $E^{\prime}(v)\leftarrow E^{\prime}(v)\setminus\{e\}$. If $E^{\prime}(v)=\emptyset$, then $v$ terminates (without joining the cover). 4. (d)

Increment levels and scale deals.

For every active (that has not terminated) vertex:

          While $\sum_{e\in E(v)}\delta(e)>w(v)(1-0.5^{\ell(v)+1})$ do

1. i.

$\ell(v)\leftarrow\ell(v)+1$ 2. ii.

For every $e\in E^{\prime}(v)$: $\operatorname*{deal}(e)\leftarrow 0.5\cdot\operatorname*{deal}(e)$ 5. (e)

For every active vertex, if $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}(e)\leq\frac{1}{\alpha}\cdot 0.5^{\ell(v)+1}\cdot w(v)$, then send the message “raise” to every $e\in E^{\prime}(v)$; otherwise, send the message “stuck” to every $e\in E^{\prime}(v)$. 6. (f)

For every uncovered edge $e$, if all incoming messages are “raise” $\operatorname*{deal}(e)\leftarrow\alpha\cdot\operatorname*{deal}(e)$. Send $\operatorname*{deal}(e)$ to every $v\in e$, who updates $\delta(e)\leftarrow\delta(e)+\operatorname*{deal}(e)$.

Termination.

Every vertex $v$ terminates when either $v\in C$ or every edge $e\in E(v)$ is covered (i.e., $E^{\prime}(v)=\emptyset$). Every edge $e$ terminates when it is covered (i.e., $e\cap C\neq\emptyset$). We say that the algorithm has terminated if all the vertices and edges have terminated.

Execution in congest.

See Section B in the Appendix for a discussion of how Algorithm mwhvc is executed in the congest model.

4 Algorithm Analysis

In this section, we analyze the approximation ratio and the running time of the algorithm. Throughput the analysis, we attach an index $i$ to the variables $\operatorname*{deal}_{i}(e),\delta_{i}(e)$ and $\ell_{i}(v)$. The indexed variable refers to its value at the end of the $i$’th iteration.

4.1 Feasibility and Approximation Ratio

The following invariants are satisfied throughout the execution of the algorithm. In the following claim we bound the sum of the deals of edges incident to a vertex.

Claim 4.1**.**

If $v\not\in C$ at the end of iteration $i$, then $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}_{i}(e)\leq 0.5^{\ell_{i}(v)+1}\cdot w(v)$.

Proof.

The proof is by induction on $i$. For $i=0$, the claim holds because $\ell_{0}(v)=0$ and $\operatorname*{deal}_{0}(e)\leq 0.5\cdot w(v)/|E(v)|$. The induction step, for $i\geq 1$, considers two cases. (A) If $v$ sends a “raise” message in iteration $i$, then Step 3e implies that $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}_{i}(e)\leq 0.5^{\ell(v)+1}\cdot w(v)$, as required. (B)  Suppose $v$ sends a “stuck” message in iteration $i$. By Step 3d, $\operatorname*{deal}_{i}(e)\leq 0.5^{\ell_{i}(e)-\ell_{i-1}(e)}\cdot\operatorname*{deal}_{i-1}(e)$ for every $e\in E^{\prime}(v)$. The induction hypothesis states that $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}_{i-1}(e)\leq 0.5^{\ell_{i-1}(v)+1}\cdot w(v)$. The claim follows by combining these inequalities.

∎

If an edge $e$ is covered in iteration $j$, then $e$ terminates and $\delta_{i}(e)$ is not set for $i\geq j$. In this case, we define $\delta_{i}(e)=\delta_{j-1}(e)$, namely, the last value assigned to a dual variable.

Claim 4.2**.**

For every $i\geq 1$ and every vertex $v\notin C$ the following inequality holds:

[TABLE]

In addition the dual variables $\delta_{i}(e)$ constitute a feasible edge packing. Namely,

[TABLE]

Proof.

We prove the claim by induction on the iteration number $i$. To simplify the proof, we reformulate the statement of the feasibility of the dual variables to $i-1$. We first prove the induction basis for $i=1$.

Proof of Eq. 1 for $i=1$.

Fix a vertex $v$. At the end of iteration [math], $\ell_{0}(v)=0$ and $0<\operatorname*{deal}_{0}(e)\leq w(v)/(2|E(v)|)$, for every $e\in E(v)$. Hence $0<\sum_{e\in E(v)}\operatorname*{deal}_{0}(e)\leq w(v)/2$. Because $\delta_{0}(e)=\operatorname*{deal}_{0}(e)$, the condition in Step 3d does not hold, and $\ell_{1}(v)=\ell_{0}(v)=0$. We conclude that Eq. 1 holds for $i=1$.

Proof of feasibility of $\delta_{0}(e)$ for $i=1$.

Non-negativity follows from the fact that $\delta_{0}(e)=\operatorname*{deal}_{0}(e)>0$. The packing constraint for vertex $v$ is satisfied because $\sum_{e\in E(v)}\operatorname*{deal}_{0}(e)\leq w(v)/2$. This completes the proof of the induction basis.

We now prove the induction step assuming that Eq. 1 holds for $i-1$.

Proof of Eq. 1 for $i>1$.

Since $v$ is not in the cover it is also not $\beta$-tight. Step 3d in iteration $i$ increases $\ell(v)$ until Eq. 1 holds for $i$.

Proof of feasibility of $\delta_{i-1}(e)$ for $i>1$.

Consider a vertex $v$. If $v$ joins $C$ in iteration $i-1$, then $\delta_{i-1}=\delta_{i-2}$, and the packing constraint of $v$ holds by the induction hypothesis. If $v\notin C$, then by $\delta_{i-1}(e)=\delta_{i-2}(e)+\operatorname*{deal}_{i-1}(e)$, Claim 4.1, and the induction hypothesis for Eq. 1, we have

[TABLE]

Let opt denote the cost of an optimal (fractional) weighted vertex cover of $G$.

Corollary 4.3**.**

Upon termination, the approximation ratio of Algorithm mwhvc is $f+\varepsilon$.

Proof.

Throughout the algorithm, the set $C$ consists of $\beta$-tight vertices. By Claim A.1, $w(C)\leq(f+\varepsilon)\cdot\textsf{opt}$. Upon termination, $C$ constitutes a vertex cover, and the corollary follows. ∎

4.2 Communication Rounds Analysis

In this section, we prove that the number of communication rounds of Algorithm mwhvc is bounded by (where $\gamma>0$ is a constant, e.g., $\gamma=0.001$)

[TABLE]

It suffices to bound the number of iterations because each iteration consists of a constant number of communication rounds.

Let $z\triangleq\lceil\log_{2}{\frac{1}{\beta}}\rceil$. Note that $z=O\left(\log({f}/{\varepsilon})\right)$.

Claim 4.4**.**

The level of every vertex is always less than $z$.

Proof.

Assume that $\ell(v)\geq z$. By Eq. 1, $\sum_{e\in E(v)}\delta_{i-1}(e)\geq w(v)\cdot(1-2^{-z})\geq(1-\beta)\cdot w(v)$. This implies that $v$ is $\beta$-tight and joins the cover in Line 3a before $\ell(v)$ reaches $z$. ∎

4.2.1 Raise or Stuck Iterations

Definition 4.5** ($e$-raise and $v$-stuck iterations).**

An iteration $i\geq 1$ is an $e$-raise iteration if in Line 3f we multiplied $\operatorname*{deal}(e)$ by $\alpha$. An iteration $i\geq 1$ is a $v$-stuck iteration if $v$ sent the message “stuck” in iteration $i$.

Note that if iteration $i$ is a $v$-stuck iteration and $v\in e$, then $\operatorname*{deal}_{i}(e)\leq\operatorname*{deal}_{i-1}(e)$ and $i$ is not an $e$-raise iteration. We bound the number of $e$-raise iterations as follows.

Lemma 4.6**.**

The number of $e$-raise iterations is bounded by $\log_{\alpha}(\Delta\cdot 2^{f\cdot z})$.

Proof.

Let $v^{*}$ denote a vertex with minimum normalized weight in $e$ (i.e., $v^{*}\in\text{argmin}_{v\in e}\{w(v)/|E(v)|$}). The first deal satisfies $\operatorname*{deal}_{0}(e)=0.5\cdot w(v^{*})/|E(v^{*})|\geq 0.5\cdot w(v^{*})/\Delta$. By Claim 4.1, $\operatorname*{deal}_{i}(e)\leq 0.5\cdot w(v^{*})$. The deal is multiplied by $\alpha$ in each $e$-raise iteration and is halved at most $f\cdot z$ times. The bound on the number of halvings holds because the number of vertices in the edge is bounded by $f$, and each vertex halves the deal each time its level is incremented. The lemma follows. ∎

We bound the number of $v$-stuck iterations as follows.

Lemma 4.7**.**

For every vertex $v$ and level $\ell(v)$, the number of $v$-stuck iterations is bounded by $\alpha$.

Proof.

Notice that when $v$ reached the level $\ell(v)$, we had $\sum_{e\in E(v)}\delta(e)\geq w(v)(1-0.5^{\ell(v)})$. The number of $v$-stuck iterations is then bounded by the number of times it can send a "stuck" message without reaching $\sum_{e\in E(v)}\delta(e)>w(v)(1-0.5^{\ell(v)+1})$. Indeed, once this inequality holds, the level of $v$ is incremented. Every stuck iteration implies, by Line 3e, that $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}(e)>\frac{1}{\alpha}\cdot 0.5^{\ell(v)+1}\cdot w(v)$. Therefore, we can bound the number of iteration by $\frac{w(v)(1-0.5^{\ell(v)+1})-w(v)(1-0.5^{\ell(v)})}{\frac{1}{\alpha}\cdot 0.5^{\ell(v)+1}\cdot w(v)}=\alpha.$∎

4.2.2 Putting it Together

Theorem 4.8**.**

For every $\alpha\geq 2$, the number of iterations of Algorithm $\operatorname*{\textup{{mwhvc}}}$ is

[TABLE]

Proof.

Fix an edge $e$. We bound the number of iterations until $e$ is covered. Every iteration is either an $e$-raise iteration or a $v$-stuck iteration for some $v\in e$. Since $e$ contains at most $f$ vertices, we conclude that the number of iterations is bounded by the number of $e$-stuck iterations plus the sum over $v\in e$ of the number of $v$-stuck iterations. The theorem follows from Lemmas 4.6 and 4.7. ∎

In Theorem 4.9 we assume that all the vertices know the maximum degree $\Delta$ and that $\Delta\geq 3$. The assumption that the maximal degree $\Delta$ is known to all vertices is not required. Instead, each hyperedge $e$ can compute a local maximum degree $\Delta(e)$, where $\Delta(e)\triangleq\max_{u\in e}|E(u)|$. The local maximum degree $\Delta(e)$ can be used instead of $\Delta$ to define local value of the multiplier $\alpha=\alpha(e)$. Let $T(f,\Delta,\varepsilon)$ denote the round complexity of Algorithm mwhvc. By setting $\alpha$ appropriately, we bound the running time as follows.

Theorem 4.9**.**

444The statement of the theorem is asymptotic. This means that for every constant $\gamma$, it holds that either $\log^{\gamma/2}\Delta\geq\log\log\Delta$ or $\Delta$ is bounded by constant (determined by $\gamma$) in which case expressions involving $\Delta$ can be omitted from the asymptotic expression.

Let $\gamma>0$ denote a constant and

[TABLE]

Then, the round complexity of Algorithm mwhvc satisfies:

[TABLE]

Proof.

First, consider the case where $\alpha=\frac{\log\Delta}{f\cdot\log(f/\varepsilon)\cdot\log\log\Delta}\geq 2$ and $\alpha\geq(\log\Delta)^{\gamma/2}$. This means that the runtime is bounded by $O\left(\log_{\alpha}\Delta+f\cdot\log(f/\varepsilon)\cdot\alpha\right)=O\left(\frac{\log\Delta}{\gamma\cdot\log\log\Delta}\right)\;.$

Second, assume that $\alpha=2$ and $2>\frac{\log\Delta}{f\cdot\log(f/\varepsilon)\cdot\log\log\Delta}\geq(\log\Delta)^{\gamma/2}$. Then, the round complexity of Algorithm mwhvc is bounded by $O\left(\log_{2}\Delta+f\cdot\log(f/\varepsilon)\right)=O\left(f\cdot\log(f/\varepsilon)\cdot\log\log\Delta\right)=O\left(f\cdot\log(f/\varepsilon)\right),\;$ where the last transition is correct as $2>(\log\Delta)^{\gamma/2}$ implies that $\Delta$ is constant.

Finally, assume that $\frac{\log\Delta}{f\cdot\log(f/\varepsilon)\cdot\log\log\Delta}<(\log\Delta)^{\gamma/2}$ which implies that

[TABLE]

Therefore, since $\alpha=2$ in this case, the runtime is bounded by

[TABLE]

Let $W\triangleq\max_{v}w(v)/\min_{v}w(v)$. By setting $\varepsilon=1/(nW)$, we conclude the following result for an $f$-approximation (recall that we assume that vertex degrees and weights are polynomial in $n$):

Corollary 4.10**.**

Algorithm mwhvc computes an $f$-approximation in $O(f\log n)$ rounds.

Additionally, we get the following range of parameters for which the round complexity is still optimal:

Corollary 4.11**.**

Let $f=O\left((\log\Delta)^{0.99}\right)$ and $\varepsilon=(\log\Delta)^{-O(1)}$. Then, Algorithm mwhvc computes an $(f+\varepsilon)$-approximation in $O\left(\frac{\log\Delta}{\log\log\Delta}\right)$ rounds.

For $f=O(1)$ we also get an extension of range of parameters for which the round complexity is optimal. This extension is almost exponential compared to the allowed $\varepsilon=(\log\Delta)^{-O(1)}$ in [BEKS18].

Corollary 4.12**.**

Let $f=O(1)$ and $\varepsilon=2^{-O\left((\log\Delta)^{0.99}\right)}$. Then our algorithm computes an $(f+\varepsilon)$-approximation and terminates in $O\left(\frac{\log\Delta}{\log\log\Delta}\right)$ rounds.

5 Approximation of Covering ILPs

In this section, we present a reduction from solving covering integer linear programs (ILPs) to mwhvc. This reduction implies that one can distributively compute approximate solutions to covering ILPs using a distributed algorithm for mwhvc.

Notation.

Let $\mathbb{N}$ denote the set of natural numbers. Let $A$ denote a real $m\times n$ matrix, $\vec{b}\in\mathbb{R}^{n}$, and $\vec{w}\in\mathbb{R}^{n}$. Let $LP(A,\vec{b},\vec{w})$ denote the linear program $\min~{}\vec{w}^{T}\cdot\vec{x}$ subject to $A\cdot\vec{x}\geq\vec{b}$ and $\vec{x}\geq 0$. Let $ILP(A,\vec{b},\vec{w})$ denote the integer linear program $\min~{}\vec{w}^{T}\cdot\vec{x}$ subject to $A\cdot\vec{x}\geq\vec{b}$ and $\vec{x}\in\mathbb{N}^{n}$.

Definition 5.1**.**

The linear program $LP(A,\vec{b},\vec{w})$ and integer linear program $ILP(A,\vec{b},\vec{w})$ are covering programs if all the components in $A,\vec{b},\vec{w}$ are non-negative.

5.1 Distributed Setting

We denote the number of rows of the matrix $A$ by $m$ and the number of columns by $n$. Let $f(A)$ (resp., $\Delta(A)$) denote the maximum number of nonzero entries in a row (resp., column) of $A$.

Given a covering ILP, $ILP(A,\vec{b},\vec{w})$, the communication network $N(ILP)$ over which the ILP is solved is the bipartite graph $N=(X\times C,E)$, where: $X=\{x_{j}\}_{j\in[n]}$, $C=\{c_{i}\}_{i\in[m]}$, and $E=\{(x_{j},c_{i})\mid A_{i,j}\neq 0\}$. We refer to the nodes in $X$ as variable nodes, and to those in $C$ as constraint nodes. Note that the maximum degree of a constraint node is $f(A)$ and the maximum degree of a variable node is $\Delta(A)$.

We assume that the local input of every variable node $x_{j}$ consists of $w_{j}$ and the $j$’th column of $A$ (i.e., $A_{i,j}$, for $i\in[m]$). Every constraint vertex $c_{i}$ is given the value of $b_{i}$ as its local input. We assume that these inputs can be represented by $O(\log(nm))$ bits. In $(f+1)$ rounds, every variable node $v_{j}$ can learn all the components in the rows $i$ of $A$ such that $A_{i,j}\neq 0$ as well as the component $b_{i}$.

5.2 Zero-One Covering Programs

The special case in which a variable may be assigned only the values [math] or $1$ is called a zero-one program. We denote the zero-one covering ILP induced by a matrix $A$ and vectors $\vec{b}$ and $\vec{w}$ by $ZO(A,\vec{b},\vec{z})$. Every instance of the mwhvc problem is a zero-one program in which the matrix $A$ is the incidence matrix of the hypergraph. The following lemma deals with the converse reduction.

Lemma 5.2**.**

Every feasible zero-one covering program $ZO(A,\vec{b},\vec{w})$ can be reduced to an mwhvc instance with rank $f^{\prime}<f(A)$ and degree $\Delta^{\prime}<2^{f(A)}\cdot\Delta(A)$.

Proof.

Let $A_{i}$ denote the $i$’th row of the matrix $A$. For a subset $S\subseteq[n]$, let $I_{S}$ denote the indicator vector of $S$. Let $\vec{x}\in\{0,1\}^{n}$ and let $\sigma_{i}\triangleq\{j\in[n]\mid A_{i,j}\neq 0\}$. Feasibility implies that $A_{i}\cdot I_{\sigma_{i}}\geq b_{i}$, for every row $i$. Let $\mathcal{S}_{i}$ denote the set of all subsets $S\subset[n]$ such that the indicator vector $I_{S}$ does not satisfy the $i$’th constraint, i.e., $A_{i}\cdot I_{S}<b_{i}$ The $i$’th constraint is not satisfied, i.e., $A_{i}\cdot\vec{x}<b_{i}$, if and if only there exists a set $S\in\mathcal{S}_{i}$ such that $\vec{x}=I_{S}$. Hence, $A_{i}\cdot\vec{x}<\vec{b}$ if and only if the truth value of the following DNF formula is false: $\varphi_{i}(x)\triangleq\bigvee_{S\in\mathcal{S}_{i}}~{}\bigwedge_{j\in\sigma_{i}\setminus S}\text{not}({x}_{j})$. By De Morgan’s law, we obtain that $\text{not}(\varphi_{i}(x))$ is equivalent to a monotone CNF formula $\psi_{i}(x)$ such that $\psi_{i}(x)$ has less than $2^{f(A)}$ clauses, each of which has length less than $f(A)$. We now construct the hypergraph $H$ for the mwhvc instance as follows. For every row $i$ and every $S\in\mathcal{S}$, add the hyperedge $e_{i,S}=\sigma_{i}\setminus S$. (Feasibility implies that $e_{i,S}$ is not empty.) Given a vertex cover $C$ of the hypergraph, every hyperedge is stabbed by $C$, and hence $I_{C}$ satisfies all the formulae $\psi_{i}(x)$, where $i\in[m]$. Hence, $A_{i}\cdot I_{C}\geq b_{i}$, for every $i$. The converse direction holds as well, and the lemma follows. ∎

How does $N(ILP)$ (a bipartite graph with $m+n$ vertices) simulate the execution of mwhvc over the hypergraph $H$? Each variable node $x_{j}$ simulates all hyperedges $e_{i,S}$, where $j\in\sigma_{i}$ and $S\in\mathcal{S}_{i}$. First, the variable nodes exchange their weights with the variables nodes they share a constraint with in $O(f(A))$ rounds – first every $x_{j}$ broadcasts its own weight and then each $c_{i}$ sends all neighbors the weights it received. At each iteration, the variable node sends a raise/stuck message and whether its level was incremented. 555One needs to modify the mwhvc algorithm slightly so that, in each iteration, the level of every vertex is increased by at most $1$. We defer the details to Appendix C. Notice that the number of rounds required for each such iteration is $O(1+f(A)/\log n)$ (i.e., constant for $f(A)=O(\log n)$). Each edge node $c_{i}$ then broadcasts to all vertices two $f(A)$-bit messages that indicate two subsets of vertices of the edge: those that sent a raise message (the complement sent a stuck message) and those that incremented their level. Each variable node $x_{j}$ knows how to update its deal with every $e_{i,S}$ for which $j\in\sigma_{i}$ and $S\in\mathcal{S}_{i}$.

We summarize the complexity of the distributed algorithm for solving a zero-one covering program.

Claim 5.3**.**

There exists a distributed congest algorithm for computing an $(f+\varepsilon)$-approximate solution for zero-one covering programs with running time of $O({(1+f(A)/\log n)\cdot}T(f(A),2^{f(A)}\cdot\Delta(A),\varepsilon))$, where $T(f,\Delta,\varepsilon)$ is the running time of Algorithm mwhvc.

5.3 Reduction of Covering ILPs to Zero-One Covering

Consider the covering ILP $ILP(A,\vec{b},\vec{w})$. We present a reduction of the ILP to a zero-one covering program.

Definition 5.4**.**

Define $M(A,\vec{b})\triangleq\max_{j}\max_{i}\left\{\frac{b_{i}}{A_{i,j}}\mid A_{i,j}\neq 0\right\}$.

We abbreviate and write $M$ for $M(A,\vec{b})$ when the context is clear.

Proposition 5.5**.**

Limiting $\vec{x}$ to the box $[0,M]^{n}$ does not increase the optimal value of the ILP.

Claim 5.6**.**

Every covering ILP $ILP(A,\vec{b},\vec{w})$ can be solved by a zero-one covering program $ZO(A^{\prime},\vec{b},\vec{w^{\prime}})$, where $f(A^{\prime})\leq f(A)\cdot\lceil\log_{2}(M)+1\rceil$ and $\Delta(A^{\prime})=\Delta(A)$.

Proof.

Let $B=\lceil\log_{2}M\rceil$. Limiting each variable $x_{j}$ by $M$ means that we can replace $x_{j}$ by $B$ zero-one variables $\left\{x_{j,\ell}\right\}_{\ell=0}^{B-1}$ that correspond to the binary representation of $x_{j}$, i.e., $x_{j}=\sum_{\ell=0}^{B-1}2^{\ell}\cdot x_{j,\ell}$. This replacement means that the dimensions of the matrix $A^{\prime}$ are $m\times n^{\prime}$, where $n^{\prime}=n\cdot B$. The $j$’th column $A^{(j)}$ of $A$ is replaced by $B$ columns, indexed [math] to $B-1$, where the $\ell$’th column equals $2^{\ell}\cdot A^{(j)}$. The vector $\vec{w^{\prime}}$ is obtained by duplicating and scaling the entries of $\vec{w}$ in the same fashion. ∎

Combining Claims 5.3 and 5.6, we obtain the following result.

Claim 5.7**.**

There exists a distributed congest algorithm for computing an $(f+\varepsilon)$-approximate solution for covering integer linear programs $ILP(A,\vec{b},\vec{w})$ with running time of $O({(1+f(A)/\log n)\cdot}T(f(A)\cdot\log M,2^{f(A)}\cdot M\cdot\Delta(A),\varepsilon))$, where $T(f,\Delta,\varepsilon)$ is the running time of Algorithm mwhvc.

Proof.

Let $f_{HVC},f_{ZO},F_{ILP}$ denote the ranks of the hypergraph vertex cover instance, zero-one covering program, and ILP, respectively. We use the same notation for maximum degrees. The reduction of zero-one programs to mwhvc in Lemma 5.2 implies that $f_{HVC}\leq f_{ZO}$ and $\Delta_{HVC}\leq 2^{f_{ZO}}\cdot\Delta_{ZO}$. The reduction of covering ILPs to zero-one programs in Claim 5.6 implies that $f_{ZO}\leq f_{ILP}\cdot(1+\log M)$ and $\Delta_{ZO}\leq\Delta_{ILP}$. The composition of the reductions gives $f_{HVC}\leq f_{ILP}\cdot(1+\log M)$ and $\Delta_{HVC}\leq 2^{f_{ILP}\cdot(1+\log M)}\cdot\Delta_{ILP}=2^{F_{ILP}}\cdot 2M\cdot\Delta_{ILP}$ ∎

After some simplifications, the running time of the resulting algorithm for $(f+\varepsilon)$-approximate integer covering linear programs is $O\left((1+f/\log n)\cdot\left(\frac{\log\Delta}{\log\log\Delta}+\left(f\cdot\log M\right)^{1.01}\cdot\log\varepsilon^{-1}\cdot(\log\Delta)^{0.01}\right)\right)$.

Acknowledgements

We thank the anonymous reviewers for their helpful remarks.

Appendix A Primal-Dual Approach

The fractional LP relaxation of mwhvc is defined as follows.

[TABLE]

The dual LP is an Edge Packing problem defined as follows:

[TABLE]

The following claim is used for proving the approximation ratio of the mwhvc algorithm.

Claim A.1**.**

Let opt denote the value of an optimal fractional solution of the primal LP (A). Let $\{\delta(e)\}_{e\in E}$ denote a feasible solution of the dual LP (A). Let $\varepsilon\in(0,1)$ and $\beta\triangleq\varepsilon/(f+\varepsilon)$. Define the $\beta$-tight vertices by:

[TABLE]

Then $w(T_{\varepsilon})\leq(f+\varepsilon)\cdot\textsf{opt}$.

Proof.

[TABLE]

The last transition follows from $f/(1-\beta)=f+\varepsilon$ and by weak duality. The claim follows. ∎

Appendix B Adaptation to the CONGEST model

To complete the discussion, we need to show that the message lengths in Algorithm mwhvc are $O(\log n)$.

In round [math], every vertex $v$ sends its weight $w(v)$ and degree $|E(v)|$ to every hyperedge in $e\in E(v)$. We assume that the weights and degrees are polynomial in $n$, hence the length of the binary representations of $w(v)$ and $|E(v)|$ is $O(\log n)$.

Every hyperedge $e$ sends back to every $v\in e$ the pair $(w(v_{e}),|E(v_{e})|)$, where $v_{e}$ has the smallest normalized weight, i.e., $v_{e}=\operatorname*{argmin}_{v\in e}\{w(v)/|E(v)|\}$.

Every vertex $v\in e$ locally computes $\operatorname*{deal}_{0}(e)=\beta\cdot w(v_{e})/|E(v_{e})|$ and $\delta_{0}(e)=\operatorname*{deal}_{0}(e)$. 2. 2.

In round $i\geq 1$, every vertex sends messages. Messages of the sort: “$e$ is covered”, “raise”, or “stuck” require only a constant number of bits. The increment of $v$’s level needs to be sent to the edges in $E(v)$. These increments require $O(\log z)=O(\log n)$ bits. 3. 3.

Every edge $e$ sends to every $v\in e$ the number of times that $\operatorname*{deal}(e)$ is halved in this iteration. This message is $O(\log z)$ bits long. 4. 4.

Every edge sends the final deal to the vertices. Instead of sending the value of the deal, the edge can send a single bit indicating whether the deal was multiplied by $\alpha$. 5. 5.

Finally, if $\alpha=\alpha(e)$ is set locally based on the local maximum degree $\max_{v\in e}|E(v)|$, then every vertex $v$ sends its degree to all the edges $e\in E(v)$. The local maximum degree for $e$ is sent to every vertex $v\in V$, and this parameter is used to compute $\alpha(e)$ locally.

Appendix C Algorithm with At Most One Level-up per Iteration

We propose to do a single change that will ensure that no vertex levels up more than once per iteration. To that end, we modify Line 3f of our mwhvc algorithm to

• •

For every uncovered edge $e$, if all incoming messages are “raise” $\operatorname*{deal}(e)\leftarrow\alpha\cdot\operatorname*{deal}(e)$. Send $\operatorname*{deal}(e)$ to every $v\in e$, who updates $\delta(e)\leftarrow\delta(e)+\operatorname*{deal}(e)/2$.

That is, the algorithm remains intact except that the dual variables $\delta(e)$ are raised by $\operatorname*{deal}(e)/2$ rather than by $\operatorname*{deal}(e)$. Intuitively, this guarantees that a vertex’s slack does not reduce by more than 50% in each iteration and therefore its level may increase by at most one. We now revisit the proof of 4.2, and, specifically, the Proof of feasibility of $\delta_{i-1}(e)$ for $i>1$.

Proof of feasibility of $\delta_{i-1}(e)$ for $i>1$.

Consider a vertex $v$. If $v$ joins $C$ in iteration $i-1$, then $\delta_{i-1}=\delta_{i-2}$, and the packing constraint of $v$ holds by the induction hypothesis. If $v\notin C$, then by $\delta_{i-1}(e)=\delta_{i-2}(e)+\operatorname*{deal}_{i-1}(e)/2$, Claim 4.1, and the induction hypothesis for Eq. 1, we have

[TABLE]

As evident by Eq. 2, the vertex $v$’s level may increase by at most once in each iteration.

Corollary C.1**.**

For any iteration $i\geq 1$ and vertex $v$: $\ell_{i}(v)\leq\ell_{i-1}(v)+1$.

We note that the change to the algorithm does not affect the correctness of claims 4.1, 4.2, 4.4 and Lemma 4.6. Lemma 4.7 changes slightly, as there can now be twice as many $v$-stuck iterations:

Lemma C.2**.**

For every vertex $v$ and level $\ell(v)$, the number of $v$-stuck iterations is bounded by $2\alpha$.

Proof.

Notice that when $v$ reached the level $\ell(v)$, we had $\sum_{e\in E(v)}\delta(e)\geq w(v)(1-0.5^{\ell(v)})$. The number of $v$-stuck iterations is then bounded by the number of times it can send a "stuck" message without reaching $\sum_{e\in E(v)}\delta(e)>w(v)(1-0.5^{\ell(v)+1})$. Indeed, once this inequality holds, the level of $v$ is incremented. Every stuck iteration implies, by Line 3e, that $\sum_{e\in E^{\prime}(v)}\operatorname*{deal}(e)>\frac{1}{\alpha}\cdot 0.5^{\ell(v)+1}\cdot w(v)$. Therefore, we can bound the number of iteration by $\frac{w(v)(1-0.5^{\ell(v)+1})-w(v)(1-0.5^{\ell(v)})}{{\frac{1}{\alpha}\cdot 0.5^{\ell(v)+1}\cdot w(v)/2}}={2\alpha}.$∎

We conclude that the algorithm remains correct and its asymptotic complexity does not change.