Fast Distributed Approximation for Max-Cut
Keren Censor-Hillel Rina Levy Hadas Shachnai
cs.DS cs.DC

 


Computer Science Department, Technion, Haifa 3200003, Israel. 

Fast Distributed Approximation for Max-Cut
    Keren Censor-Hillel1The research is supported in part by the Israel Science Foundation (grant 1696/14). Rina Levy1 Hadas Shachnai1
    December 30, 2023
======================================================================================================================================




	

Finding a maximum cut is a fundamental task in many computational settings. Surprisingly, it has been insufficiently studied in the classic distributed settings, where vertices communicate by 
synchronously sending messages to their neighbors according to the underlying graph, known as the ℒ𝒪𝒞𝒜ℒ or 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 models. 
We amend this by obtaining 
almost optimal algorithms for Max-Cut on a wide class of  graphs in these models.
In particular, for any  ϵ > 0, we develop randomized 
approximation algorithms achieving a ratio of (1-) to the optimum
 for Max-Cut  on bipartite graphs in the  
𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model, and on general graphs in the 
ℒ𝒪𝒞𝒜ℒ model.

We further present efficient deterministic algorithms, including a
1/3-approximation for Max-Dicut in 
our models, thus improving the best known (randomized) ratio of 1/4.
Our algorithms make
non-trivial use of the greedy approach of Buchbinder et al. (SIAM
Journal on Computing, 2015) for maximizing an unconstrained (non-monotone)
submodular function, which may be of independent interest.
	





Introduction
Max-Cut is one of the fundamental problems in theoretical computer science. A cut in an undirected graph is a bipartition of the vertices, whose size is the number of edges crossing the bipartition. Finding cuts of maximum size in a given graph is among Karp's famous 21 NP-complete problems <cit.>. Since then, Max-Cut has received considerable attention,
in approximation algorithms <cit.>, parallel computation <cit.>, parameterized complexity (see, e.g., <cit.> and the references therein), and streaming algorithms (see, e.g., <cit.>). 

Max-Cut has a central application in wireless mesh networks (WMNs).
The capacity of WMNs
that operate over a single frequency can be increased significantly by enhancing each router with multiple transmit (Tx)
or receive (Rx) (MTR) capability. Thus, a node will not experience collision when two or more neighbors transmit to it. Yet, interference occurs if a node transmits and receives
simultaneously. This is known as the no mix-tx-rx constraint. The set of links activated in each time slot, defining the capacity of an MTR WMN,
 is governed by a link scheduler. As shown in <cit.>, link scheduling 
is equivalent to finding Max-Cut in each time slot. A maximum cut contains the set of 
non-conflicting links that can be activated at the same time, i.e, they adhere to the no mix-tx-rx constraint. The induced bipartition of the vertices at each time slot defines
a set of transmitters and a set of receivers in this slot.  
Link scheduling algorithms based on approximating Max-Cut, and other applications in wireless networks, can be found
in <cit.>.[Max-Cut naturally arises also in  VLSI <cit.>, statistical physics <cit.> and machine learning <cit.>.]


Surprisingly, Max-Cut has been insufficiently studied in the classic distributed settings, where vertices communicate by synchronously sending messages to their neighbors according to the underlying graph, known as the ℒ𝒪𝒞𝒜ℒ or 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 models.
Indeed, 
there are known distributed algorithms for Max-Cut using MapReduce techniques <cit.>. In this setting, the algorithms partition the ground set among m machines and obtain a solution using all the outputs. However, despite a seemingly similar title, our distributed setting is completely different.

In this paper we address Max-Cut in the classic distributed network models, where the graph represents a synchronous communication network. At the end of the computation, each vertex decides locally whether it joins the subset S or S̅, and outputs 1 or 0, respectively, so as to obtain a cut of largest possible size.

It is well known that choosing a random cut, i.e., assigning each vertex to S or S̅ with probability 1/2, yields a 1/2-approximation for Max-Cut, and a 1/4-approximation for Max-Dicut, defined on directed graphs (see, e.g., <cit.>).[In Max-Dicut we seek the maximum size edge-set crossing from 
S to S̅.]
Thus, a local algorithm, where each vertex outputs 0 or 1 with probability 1/2, yields the above approximation factors with no communication required.
On the other hand, we note that a single vertex can find an optimal solution, once it has learned the underlying graph. However, this requires a number of communication rounds that depends linearly on global network parameters (depending on the exact model considered). This defines a tradeoff between time complexity and the approximation ratio obtained by distributed Max-Cut algorithms. The huge gap between the above results raises the following natural questions: How well can Max-Cut be approximated in the distributed setting, using a bounded number of communication rounds?
Or, more precisely: How many communication rounds are required for obtaining an approximation ratio strictly larger than half, or even a deterministic 1/2-approximation for Max-Cut?

To the best of our knowledge, these questions have been studied in our distributed network models only for a restricted graph class. Specifically, the paper <cit.> suggests a distributed algorithm for Max-Cut on d-regular triangle-free graphs, that requires a single communication round and provides a (1/2+0.28125/√(d))-approximation.

The key contribution of our paper is in developing two main techniques for approximating Max-Cut and Max-Dicut in distributed networks, with any communication graph. Below we detail the challenges we face, and our methods for overcoming them.


The Challenge
In the ℒ𝒪𝒞𝒜ℒ model, where message sizes and the local computation power are unlimited, every standard graph problem can be solved in O(n) communication rounds. For Max-Cut it also holds that finding an optimal solution requires Ω(n) communication rounds. This lower bound follows from Linial's seminal lower bound <cit.> for finding a 2-coloring of an even-sized cycle. In an even cycle, the maximum cut contains all edges. Therefore, finding a Max-Cut is equivalent to finding a 2-coloring of the graph.

An approach that proved successful in many computational settings - in 
 tackling hard problems - is to relax the optimality requirement and settle for approximate solutions. Indeed, in the distributed setting, many approximation algorithms have been devised to overcome the costs of finding exact solutions (see, e.g., <cit.>, and the survey of Elkin <cit.>). Our work can be viewed as part of this general approach. However, we face crucial hurdles attempting to use the known sequential toolbox for approximating Max-Cut in the distributed setting.

As mentioned above, a 1/2-approximation for Max-Cut can be obtained easily with no need for communication. While this holds in all of the above models, improving the ratio of 1/2 is much more complicated.
In the sequential setting, an approximation factor strictly larger than 1/2 was obtained in the mid-1990's using semidefinite programming <cit.> (see Section <ref>). 
Almost two decades later, the technique was applied by <cit.> to obtain a parallel randomized algorithm for Max-Cut, achieving a ratio of (1-ϵ) 0.878 to the optimum, 
for any > 0. Adapting this algorithm to our distributed setting seems non-trivial, as it
relies heavily on global computation.
Trying to apply other techniques, such as local search, unfortunately leads to 
linear running time, 
 because of the need to compare values of global solutions.

Another obstacle that lies ahead is the lack of locality in Max-Cut, due to strong dependency between the vertices. The existence of an edge in the cut depends on the assignment of both of its endpoints. This results in a chain of dependencies and raises the question whether cutting the chain can still guarantee a good approximation ratio.

Our Contribution
We develop two main techniques for approximating Max-Cut, as well as Max-Dicut. Our first technique relies on the crucial observation that the cut value is additive for edge-disjoint sets of vertices. 
Exploiting this property, we design clustering-based algorithms, in which we decompose the graph into small-diameter clusters, find an optimal solution within each cluster, and prove that the remaining edges still allow the final solution to meet the desired approximation ratio. 
An essential component in our algorithms is efficient graph decomposition to such small-diameter clusters connected by few edges (also known as a padded partition), inspired by
a parallel algorithm of <cit.> (see also <cit.>).

For general graphs, this gives (1-ϵ)-approximation algorithms for Max-Cut and Max-Dicut, requiring O(log n/ϵ) communication rounds in the ℒ𝒪𝒞𝒜ℒ model. For the special case of a bipartite graph, we take advantage of the graph structure to obtain an improved
clustering-based algorithm, which does not require large messages. The algorithm achieves a (1-ϵ)-approximation for Max-Cut in O(log n/ϵ) rounds, in the more restricted 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model. 



For our second technique, we observe that the contribution of a specific vertex to the cut depends only on the vertex itself and its immediate neighbors. 
We leverage this fact to make multiple decisions in parallel by independent sets of vertices. We find such sets using distributed coloring algorithms. 
Our coloring-based technique,
which makes non-trivial use of the greedy approach of <cit.>  for maximizing an unconstrained 
submodular function, yields
deterministic 1/2-approximation and 1/3-approximation algorithms for Max-Cut and Max-Dicut, respectively, and a randomized 1/2-approximation algorithm for Max-Dicut. Each of these algorithms requires Õ(Δ +log^*n) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model, where Δ is the maximal degree of the graph, and Õ ignores polylogarithmic factors in Δ. 

Finally, we present ℒ𝒪𝒞𝒜ℒ algorithms which combine both of our techniques. Applying the coloring-based technique to low-degree vertices, and the clustering-based technique to high-degree vertices, allows as to design faster deterministic algorithms with approximation ratios of 1/2 and 1/3 for Max-Cut and Max-Dicut, respectively, requiring min{Õ(Δ +log^*n),O(√(n))} communication rounds. 
Table <ref> summarizes our results.









Background and Related Work
The weighted version of Max-Cut is one of Karp's NP-complete problems <cit.>. The unweighted version that we study here is also known to be NP-complete <cit.>. 

While there are graph families, such as planar and bipartite graphs, in which a maximum cut can be found in polynomial time <cit.>, in general graphs, even approximating the problem is NP-hard. In the sequential setting, one cannot obtain an approximation ratio better than 16/17 for Max-Cut, or an approximation ratio better than 12/13 for Max-Dicut, unless P=NP <cit.>.

Choosing a random cut, i.e., assigning each vertex to S or S̅ with probability 1/2, yields a 1/2-approximation for Max-Cut, and 1/4-approximation for Max-Dicut. In the sequential setting there are also deterministic algorithms yielding the above approximation ratios <cit.>.
For 20 years there was no progress in improving the 1/2 constant in the approximation ratio for Max-Cut, until in 1995, Goemans and Williamson <cit.> achieved the currently best known approximation ratio for Max-Cut, using semidefinite programming. They present a 0.878-approximation algorithm, which is optimal assuming the Unique Game Conjecture holds <cit.>. In the same paper, Goemans and Williamson also give a 0.796-approximation algorithm for Max-Dicut. This ratio was improved later by Matuura et al. <cit.>, to 0.863.
Using spectral techniques, a 0.53-approximation algorithm for Max-Cut was given by Trevisan <cit.>. 
In <cit.> Kale and Seshadhri present a combinatorial approximation algorithm for Max-Cut using random walks, which gives a (0.5+δ)-approximation, where δ is some positive constant which appears also in 
the running time of the algorithm. In particular, for Õ(n^1.6),Õ(n^2) and Õ(n^3) times, the algorithm achieves approximation factors of 0.5051, 0.5155 and 0.5727, respectively.

Max-Cut and Max-Dicut can also be viewed as special cases of submodular maximization, which has been widely studied. It is known that choosing  a solution set S uniformly at random yields a 1/4-approximation, and a 1/2-approximation for a general and for symmetric submodular function, respectively <cit.>. This corresponds to the known random approximation ratios for Max-Cut and Max-Dicut. Buchbinder et al. <cit.> present determinstic 1/2-approximation algorithms for both symmetric and asymmetric submodular functions.
These algorithms assume 
that the submodular function is accessible through a black box returning f(S) for any given set S (known as the value oracle model).

In the recent years, there is an ongoing effort to develop distributed algorithms for submodular maximization problems, using MapReduce techniques <cit.>. Often, the inputs consist of large data sets, for which a sequential algorithm may be inefficient. The main idea behind these algorithms is to partition the ground set among m machines, and have each machine solve the problem optimally independently of others. After all machines have completed their computations, they share their solutions. A final solution is obtained by solving the problem once again over a union of the partial solutions. The algorithms achieve performance guarantees close to the sequential algorithms while decreasing the running time, where the running time is the number of communication rounds among the machines. As mentioned above, these algorithms do not apply to our classic distributed settings.



Preliminaries
The Max-Cut problem is defined as follows. Given an undirected graph G=(V,E), one needs to divide the vertices into two subsets, S⊂V and S̅=V∖S, such that the size of the cut, i.e., the number of edges between S and the complementary subset S̅, is as large as possible.
In the Max-Dicut problem, the given graph G=(V,E) is directed, and the cut is defined only as the edges which are directed from S to S̅. As in the Max-Cut problem, the goal is to obtain the largest cut.

Max-Cut and Max-Dicut can be described as the problem of maximizing the submodular function f(S)=|E(S,S̅)|, where for Max-Dicut f(S) counts only the edges directed from S to S̅.
Given a finite set X, a submodular function is a function f:2^X→ℝ, where 2^X denotes the power set of X, which satisfies the equivalent definitions:

	
  * For any S,T⊆X:  f(S∪T)+f(S∩T)≤f(S)+f(T).
	
  * For any A⊆B⊆X and x∈X∖B:  f(B∪{x})-f(B)≤f(A∪{x})-f(A).


For Max-Cut and Max-Dicut, the submodular function also satisfies the following equality:
For every disjoint sets S,T⊆ X such that E_S× T={(u,v)|u∈ S, v∈ T}=∅, we have that f(S)+f(T)=f(S∪ T).
Note that for Max-Cut, the function is also symmetric, i.e., f(S)=f(S̅).

Model 
We consider a distributed system, modeled by a graph G=(V,E), in which the vertices represent the computational entities, and the edges represent the communication channels between them. We assume that each vertex v has a unique identifier id(v) of size O(logn), where n=|V|.

The communication between the entities is synchronous, i.e., the time is divided into rounds. In each round, the vertices send messages simultaneously to all of their neighbors and make a local computation based on the information gained so far. This is the classic ℒ𝒪𝒞𝒜ℒ model <cit.>, which focuses on analyzing how locality affects the distributed computation. Therefore, the messages size and local computation are unlimited, and the complexity is measured by the number of communication rounds needed to obtain a solution. It is also important to study what can be done in the more restricted 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model <cit.>, in which the message size is bounded to O(log n).

We assume that each vertex has preliminary information including the size of the network n=|V|, its neighbors, and the maximal degree of the graph
 Δ.[This assumption is needed only for the (Δ +1)-coloring algorithm <cit.> used in Section <ref>; it can be omitted
 (see <cit.>), increasing the running time by a constant factor.]

Each vertex runs a local algorithm in order to solve the Max-Cut problem. Along the algorithm, each vertex decides locally whether it should be in S or in S̅, and outputs 1 or 0 respectively. We define the solution of the algorithm, as the set of all outputs. Note that each vertex does not hold the entire solution, only local information. The solution value is defined as the size of the cut induced by the solution. We show that this value approximates the size of the maximum cut.




Clustering-Based Algorithms 
In this section we present clustering-based algorithms for Max-Cut and Max-Dicut. Our technique uses the observation that Max-Cut is a collection of edges having their endpoints in different sets; therefore, it can be viewed as the union of cuts in the disjoint parts of the graph.

Given a graph G = (V,E), we first eliminate a small fraction of edges to obtain small-diameter connected components. Then, the problem is solved optimally within each connected component. For general graphs, this is done by gathering the topology of the component at a single vertex. For the special case of a bipartite graph, we can use the graph structure to propagate less information.
Since the final solution, consisting of all the vertices local decisions, is at least as good as the sum of the optimal solutions in the components, and since the fraction of eliminated edges is small, we prove that the technique yields a (1-ϵ)-approximation.

A Randomized Distributed Graph Decomposition
We start by presenting the randomized distributed graph decomposition algorithm. The algorithm is inspired by a parallel graph decomposition by Miller et al. <cit.> that we adapt to the distributed model as we describe next.[Our algorithm can be viewed as one phase of the distributed algorithm presented by Elkin et al. in <cit.> with some necessary changes.]. The PRAM algorithm of <cit.> generates a strong padded partition of a given graph, namely, a partition into connected
 components with strong diameter O(log n/β), for some β≤ 1/2, such that the fraction of edges that cross between different clusters of the partition is 
 at most β.
 As we prove next, the distributed version guarantees the same properties with high probability and requires only O(log n/β) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model.

The distributed version of the graph decomposition algorithm works as follows: Let δ_v be a random value that vertex v chooses from an exponential distribution with parameter β. Define the shifted distance from vertex v to vertex u as dist_δ (u,v) = dist(u,v)-δ_u. Along the algorithm each vertex v finds a vertex u within its klog n/β-neighborhood, where k is a constant, that minimizes dist_δ (u,v). We define this vertex as v's center. This step creates the difference between the parallel and the distributed decomposition, as in the parallel algorithm each vertex chooses its center from the entire ground set V. However as we prove next, the process still generates a decomposition with the desired properties. Furthermore, w.h.p. the distributed algorithm outputs a decomposition identical to the one created by the parallel algorithm.
A pseudocode of the algorithm is given in Algorithm <ref>.







We prove that the fraction of edges between different components is small. In order to do so, we bound the probability of an edge to be between components, i.e., the probability that the endpoints of the edge choose different centers.
We consider two cases for an edge e=(u,v). In the first case, we assume that both u and v choose the center that minimizes their shifted distance, dist_δ, over all the vertices in the graph. In other words, if the algorithm allowed each vertex to learn the entire graph, they would choose the same center as they did in the current algorithm. In the second case, we assume that at least one of u and v chooses differently if given a larger neighborhood.

Define the ideal center of a vertex v as argmin_w∈ Vdist_δ(w,v). In the following lemma we bound from above the probability that a vertex does not choose its ideal center.

	Let v' be the ideal center of vertex v, then the probability that dist(v',v)>klog n/β, i.e., vertex v does not join its ideal center, is at most 1/n^k.



	Since v' is the ideal center of vertex v, we have that dist_δ(v',v) ≤ dist_δ(v,v). Therefore, dist(v',v)-δ_v'≤ dist(v,v)-δ_v = -δ_v ≤ 0, which implies that dist(v',v) ≤δ_v'. That is, the distance between each vertex v to its ideal center v' is bounded from above by δ_v', and hence [dist(v',v)>klog n/β]≤[δ_v'>klog n/β].
	Using the cumulative exponential distribution, we have that
	[δ_v'>klog n/β]=exp(-k·βlog n/β)=exp(-klog n)  ≤1/n^k.
	


	The Distributed Decomposition algorithm generates a decomposition identical to the decomposition created by the parallel decomposition algorithm with probability at least 1-1/n^k-1




	Applying the union bound, 
	we have that the probability that at least one of the vertices does not choose its ideal center is at most 1/n^k-1.

Define an exterior edge as an edge connecting different vertex components, and let F denote the set of exterior edges. Let A_u,v denote the event that both u and v choose their ideal centers.


	The probability that an edge e=(u,v) is an exterior edge, given that u and v choose their ideal centers, is at most β.


The lemma follows directly from <cit.>, where indeed the algorithm assigns to each vertex its ideal center.
We can now bound the probability of any edge to be an exterior edge.


	The probability that an edge e=(u,v) is in F is at most β+2/n^k.









		Note that 
    [(u,v)∈ F] = [(u,v)∈ F|A_u,v][A_u,v]+[(u,v)∈ F|A̅_u,v][A̅_u,v].
 By Lemma <ref>, [(u,v)∈ F|A_u,v]≤β. Applying the union bound on the result of Lemma <ref>, we have that [A̅_u,v] ≤2/n^k.
	Therefore [(u,v)∈ F] = [(u,v)∈ F|A_u,v] [A_u,v]+[(u,v)∈ F|A̅_u,v][A̅_u,v]≤β·[A_u,v]+[(u,v)∈ F|A̅_u,v]·2/n^k≤β + 2/n^k.


We can now prove the guarantees of the Distributed Decomposition algorithm. 
Recall that the weak diameter of a set S={u_1,u_2,...u_l} is defined as max_(u_i,u_j)∈ S dist(u_i,u_j).

 
	The Distributed Decomposition algorithm requires O(log n/β) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model, and partitions the graph into components such that in expectation there are O(β m) exterior edges. Each of the component is of weak diameter O(log n/β), and with high probability also of strong diameter O(log n/β).




	Clearly, as every vertex chooses a center from its klog n/β-neighborhood, the distance between two vertices that choose the same center, i.e., belong to the same component, over the graph G is at most O(log n/β). Therefore, the weak diameter of every component is at most O(log n/β). 
	As we proved in Corollary <ref>, with probability at least 1-1/n^k-1 the algorithm creates a partition identical to the one created by the parallel algorithm, and therefore with the exact same properties, which implies that the strong diameter of every component is at most O(log n/β) as well.
	
	Using the linearity of expectation, and Lemma <ref> we have that 𝔼[|F|]≤∑_e∈ E^(β+2/n^k) = β m+2m/n^k.
	Since m≤ n^2, we have that for every k>2, 𝔼[|F|] ≤ O(β m).
	Finally, as can be seen from the code, the algorithm requires O(log n/β) communication rounds.

A Randomized (1-ϵ)-Approximation Algorithm for Max-Cut on a Bipartite Graph
Clearly, in a bipartite graph the maximum cut contains all of the edges. Such a cut can be found by selecting arbitrarily a root vertex, and then simply putting all the vertices of odd depth in one set and all the vertices of even depth in the complementary set. However, this would require a large computational time in our model, that depends on the diameter of the graph. We overcome this by using the above decomposition,


and finding an optimal solution within each connected component. In each component C, we find an optimal solution in O(D_c) communication rounds, where D_c is the diameter of C.
First, the vertices in each component search for the vertex with the lowest id. [This can be done 
by running a BFS in parallel from all vertices.
Each vertex propagates the information from the root with lowest id it knows so far, and joins its tree. Thus, at the end of the process, we have a BFS tree rooted at the vertex with the lowest id.]Second, the vertex with the lowest id joins S or S̅ with equal probability and sends its decision to its neighbors. When a vertex receives a message from one of its neighbors, it joins the opposite set, outputs its decision, and sends it to its neighbors.
Since finding the optimal solution within each component does not require learning the entire component topology, the algorithm is applicable to the more restricted 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model.
The algorithm yields a (1-ϵ)-approximation for the Max-Cut problem on a bipartite graph in O(log n/ϵ) communication rounds with high probability.


	Bipartite Max-Cut is a randomized (1-ϵ)-approximation for Max-Cut, requiring O(log n/ϵ) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model w.h.p.



	After applying the decomposition algorithm, we have that each connected component C has a diameter D_c of at most O(log n/β)  w.h.p (Theorem <ref>). Building a BFS tree in a component C clearly takes O(D_c) communication rounds. Assigning the vertices to sets after constructing a tree takes O(D_c) as well. Therefore, the algorithm finds an optimal solution in each of the components in O(log n/ϵ) communication rounds. Since every connected component is a bipartite graph itself, all the edges within it are in the cut. Therefore, as there are at most O(β m) exterior edges, the algorithm obtain a cut of at least (1-β)m edges. Since the optimal cut in a bipartite graph contains all the edges, the algorithm achieves a (1-β)-approximation. Choosing β = ϵ proves the theorem.







A Randomized (1-ϵ)-Approximation Algorithm for General Graphs 
We present below a (1-ϵ)-approximation algorithm for Max-Cut in general graphs, using O(log n/ϵ) communication rounds. As before, the algorithm consists of two parts, decomposition and solution. Although the decomposition part itself works even in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model, the algorithm works in the ℒ𝒪𝒞𝒜ℒ model, since for general graphs the components created by the decomposition are not necessarily sparse, and learning the components topology is expensive in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model. 






	Decomposition-Based Max-Cut is a randomized (1-ϵ)-approximation for Max-Cut, requiring O(log n/ϵ) communication rounds in the ℒ𝒪𝒞𝒜ℒ model.



	Let 𝑂𝑃𝑇(G) be the set of edges that belong to some maximum cut in G, and let ALG(G) be the set of edges in the cut obtained by Decomposition-Based Max-Cut. Let S_u be the component induced by the vertices which choose u as their center, and denote by S the set of components that algorithm Distributed Decomposition constructs. Then 𝔼[|ALG(G)|]≥𝔼[∑_S_u∈ S|𝑂𝑃𝑇(S_u)|] ≥ |𝑂𝑃𝑇(G)|-β m ≥ |𝑂𝑃𝑇(G)|-2β |𝑂𝑃𝑇(G)|=(1-ϵ)|𝑂𝑃𝑇(G)|.
	The last inequality follows from the fact that for every graph G it holds that |𝑂𝑃𝑇(G)|≥m/2. 
	
	The graph decomposition requires O(log n/ϵ) communication rounds, and outputs components with weak diameter at most O(log n/ϵ). Therefore, finding the optimal solution within each component takes O(log n/ϵ) as well. The time bound follows.


By taking β=ϵ/4, one can now obtain a (1-ϵ)-approximation algorithm for Max-Dicut. The difference comes from the fact that for Max-Dicut it holds that |𝑂𝑃𝑇(G)|≥m/4 for every graph G. The rest of the analysis is similar to the analysis for Max-Cut. Hence, we have

	Decomposition-Based Max-Dicut is a randomized (1-ϵ)-approximation for Max-Dicut, requiring O(log n/ϵ) communication rounds in the ℒ𝒪𝒞𝒜ℒ model.
 







Coloring-Based Algorithms
Many of the sequential approximation algorithms for Max-Cut perform n iterations. Each vertex, in its turn, makes a greedy decision so as to maximize the solution value.
We present below distributed greedy algorithms which achieve the approximation ratios of the sequential algorithms much faster.
We first prove that the greedy decisions of vertices can be done locally, depending only on their immediate neighbors. Then we show how to parallelize the decision process, such that in each iteration an independent set of vertices completes.
The independent sets are generated using (Δ +1)-coloring; then, for (Δ +1) iterations, all the vertices of the relevant color make their parallel independent decisions.
All algorithms 
 run in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model.











 §.§ A Deterministic 1/2-Approximation Algorithm for Max-Cut

We start by presenting a simple deterministic distributed greedy algorithm that yields a 1/2-approximation for Max-Cut.
The algorithm is inspired by the sequential greedy Max-Cut algorithm of <cit.>. The greedy Max-Cut algorithm iterates through the vertices in some arbitrary order. In iteration i, the algorithm decides whether to assign vertex v_i to S or to S̅, based on which placement maximizes the cut size.
In our algorithm the process is similar, except that, in each iteration, instead of considering a single vertex, we consider an independent set of vertices. As the vertices are independent, their decisions are also independent, and the approximation ratio still holds.

To divide the vertices into independent sets, we color them using (Δ +1)-colors, where Δ is the maximum degree in the graph. The best deterministic (Δ +1)-coloring algorithm known in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model, due to Barenboim <cit.>, requires Õ(Δ^3/4+log^* n) communication rounds, where Õ ignores polylogarithmic factors in Δ [Note that a faster (Δ + 1)-coloring algorithm will not improve the running time of Distributed Greedy Max-Cut, since the running time of the algorithm depends on the number of colors, which is Δ + 1.]. 

Define a coloring C:V→{1,2,...,Δ +1} such that C(v)≠ C(u) for every (u,v)∈ E. Let N_low(v)={u| u∈ N(v) and C(u)<C(v)} denote the neighbors of vertex v with lower colors.
In iteration i, all vertices with color i decide in parallel whether to join S or S̅, depending on the choices their neighbors made in previous rounds. In order to maximize the cut locally, vertex v chooses to join the subset that was chosen by the minority of its neighbors in N_low(v).
As we show next, this guarantees the 1/2-approximation.

Algorithm <ref> gives a pseudocode of the algorithm.





 
	The Distributed Greedy Max-Cut algorithm outputs a 1/2-approximation in Õ(Δ + log^* n) rounds.



	We first show that the algorithm gives a 1/2-approximation. Consider an edge e=(u,v), if C(v)>C(u), then we say that v is responsible for edge e. Denote by E_resp(v) the set of edges vertex v is responsible for. In other words, E_resp(v) contains the edges between v and vertices in N_low(v). Since the color groups are independent, every edge has exactly one responsible vertex, therefore ∑_v∈ V^ |E_resp(v)| = |E|. When vertex v makes its decision, it chooses to join the set that is not chosen by at least half of its neighbors in N_low(v), and hence adds at least half of the edges in E_resp(v) to the cut. Upon termination of the algorithm, we have that |E(S,S̅)|≥∑_v∈ V^1/2|E_resp(v)|=1/2|E|. Since the size of the optimal cut cannot be larger than |E|, the algorithm yields a 1/2-approximation.
	
	The algorithm colors the graph in Õ(Δ^3/4+log^* n) rounds and iterates for O(Δ + 1) rounds, which yields the time bound.



 §.§ A Deterministic 1/3-Approximation Algorithm for Max-Dicut

Next, we turn our attention to the Max-Dicut problem. Buchbinder et al. <cit.> present a sequential deterministic greedy 1/3-approximation algorithm for maximizing unconstrained submodular functions which runs in linear time. Inspired by this algorithm, we present a distributed deterministic 1/3-approximation algorithm for Max-Dicut that requires Õ(Δ + log^*n) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model.



  §.§.§ The sequential Algorithm

We first give a brief overview of the sequential algorithm of <cit.> for Max-Dicut. Given a graph G=(V,E), where |V|=n, the algorithm examines the vertices in an arbitrary order u_1,u_2,...,u_n. In iteration i, the algorithm decides greedily whether to include u_i in the final solution, for 1≤ i ≤ n. The algorithm maintains two sets of vertices, X and Y. Initially, X_0=∅ and Y_0=V. At the begining of the ith iteration, the algorithm defines X_i=X_i-1,Y_i=Y_i-1, then, the algorithm decides whether to add the ith vertex u_i to X_i-1, or to remove it from Y_i-1. The decision is made by calculating the marginal profit of both options and choosing the more profitable one.
By definition, upon termination of the algorithm we have that X_n=Y_n, and this set is output as the solution.
Let f(S) be the size of the directed cut induced by a subset of vertices S⊆ V, i.e., the number of edges directed from S to S̅. Then f is a non-negative submodular function.
Let a_i and b_i denote the marginal profit gained by adding the vertex u_i to X_i-1, or removing it from Y_i-1 respectively.
Algorithm <ref> gives the pseudocode of the sequential algorithm of <cit.>.




We give below a sketch of the analysis [See the details in <cit.>.]. The following lemma implies that in each iteration, one can only increase the value of the solution.

<cit.>
	For every 1≤ i ≤ n, it holds that a_i+b_i ≥ 0.



Let 𝑂𝑃𝑇 denote the set S⊆ V that maximizes the dicut size. Define 𝑂𝑃𝑇_i ≜ (𝑂𝑃𝑇∪ X_i)∩ Y_i. In other words, 𝑂𝑃𝑇_i agrees with X_i and Y_i on the first i elements, and agrees with 𝑂𝑃𝑇 on the rest. Hence, 𝑂𝑃𝑇_0 = 𝑂𝑃𝑇 and 𝑂𝑃𝑇_n = Y_n = X_n. The following lemma shows that in each iteration, the damage to the optimal solution value, i.e., f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i), is bounded.

<cit.>
	For every 1≤ i ≤ n, it holds that f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i) ≤ [f(X_i)-f(X_i-1)] + [f(Y_i)-f(Y_i-1)].


Using Lemmas <ref>,<ref>, one can prove the following theorem.


	The Deterministic Sequential Max-Dicut algorithm gives a 1/3-approximation for the Max-Dicut problem in linear time.




  §.§.§ The Distributed Algorithm

Inspired by the sequential algorithm, we design a distributed algorithm which gives a 1/3-approximation for the Max-Dicut problem.
As in Subsection <ref>, we start by (Δ +1)-coloring the graph. Then, for 1 ≤ i ≤ (Δ +1) iterations, the vertices make their decisions, one color class at a time. In each iteration, the corresponding vertices calculate the marginal profit gained by their two possible decisions, and take the one which maximizes the profit.
As in the sequential algorithm, the distributed algorithm maintains two solutions X and Y; X_0=∅ and Y_0 = V as before. X_i and Y_i represent the state of the solutions after i iterations, and 𝑂𝑃𝑇_i is defined as 𝑂𝑃𝑇_i=(𝑂𝑃𝑇∪ X_i)∩ Y_i).

Define X_i(v) ≜ X_i ∩ N(v), and Y_i(v) ≜ Y_i ∩ N(v). It is easy to see that X_i as defined in the sequential algorithm equals ∪_v∈ V X_i(v). Similarly, Y_i = ∪_v∈ V Y_i(v).
Using this notation, Algorithm <ref> gives the pseudocode of the distributed algorithm.



There are two key ingredients in our analysis. We first prove that the marginal profits a_i and b_i can be computed locally. Then, we need to show that running the procedures in parallel does not affect the approximation ratio.

The next lemma shows that the marginal profits of v's possible decisions depends only on its 1-neighborhood.


	Let A⊆ V be a subset of vertices, and let v be a vertex such that v∉ A. Then f(A+v)-f(A)=f((A∩ N(v)) + v)-f(A∩ N(v)).



	Given A,B⊆ V such that A∩ B = ∅, let |E(A,B)| denote the number of edges directed from vertices in A to vertices in B.
	We start by proving that for every subset A⊆ V and v∉ A it holds that:
	
    ⋆⋆   f(A + v) - f(A) = |E(A+v,V∖(A+v))|-|E(A,V∖ A)|
       =|E(A,V∖(A+v))|+|E(v,V∖(A+v))|-|E(A,V∖(A+v))|-|E(A,v)|
       =|E(v,V∖(A+v))|-|E(A,v)|.

	
	Note that since v is connected by edges only to its neighbors, 
    |E(v,V∖(A+v))|-|E(A,v)| = |E(v,N(v) ∩(V∖(A+v)))|-|E(N(v)∩ A,v)|.

	
	As (A∩ N(v))⊆ V, and v∉(A∩ N(v)), using (⋆⋆) we have that 
	
    f((A∩ N(v)) + v)-f(A∩ N(v))
       = |E(v,V∖(A∩ N(v)+v))|-|E(A∩ N(v),v)|
       =|E(v,N(v) ∩(V∖(A+v)))|-|E((N(v)∩ A),v)|,

	which proves the lemma.
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
 


We now prove that making the decision to join S or S̅ in parallel for independent sets does not affect the approximation ratio.



	For every 1≤ i ≤ (Δ +1), it holds that f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i) ≤ [f(X_i)-f(X_i-1)] + [f(Y_i)-f(Y_i-1)].
	


	Let I={v_1,v_2,...,v_m} be an independent set of color i. We show that iteration i of the distributed algorithm is equivalent to m iterations of the sequential one.
	
	We can simulate the ith iteration of the distributed algorithm as m sequential iterations, where in the jth iteration, vertex v_j makes the exact same decision it makes in the distributed algorithm. Let X_i-1^j,Y_i-1^j,𝑂𝑃𝑇_i-1^j represent the state of X_i-1,Y_i-1 and 𝑂𝑃𝑇_i-1 after the jth iteration of the simulation. Using the above notation, we prove the lemma by showing that: 
	
    ∑_j=1^m[f(𝑂𝑃𝑇_i-1^j-1)-f(𝑂𝑃𝑇_i-1^j)] ≤∑_j=1^m[f(X_i-1^j)-f(X_i-1^j-1)] + ∑_j=1^m[f(Y_i-1^j)-f(Y_i-1^j-1)].

	
	For this, it suffices to show that [f(𝑂𝑃𝑇_i-1^j-1)-f(𝑂𝑃𝑇_i-1^j)] ≤[f(X_i-1^j)-f(X_i-1^j-1)] + [f(Y_i-1^j)-f(Y_i-1^j-1)], for all 1≤ j≤ m.
	
	Since I is an independent set, it holds that X_i-1(v)∩ I = ∅ and Y_i-1(v)∩ I = ∅ for every v∈ I, i.e. the decision of every vertex v∈ I does not depend on the decisions made by the other vertices in I. By Lemma <ref>, f(X_i-1 + v)-f(X_i-1)=f(X_i-1(v) + v)-f(X_i-1(v)), and f(Y_i-1-v)-f(Y_i-1)=f(Y_i-1(v)-v)-f(Y_i-1(v)) for every vertex v∈ V. Therefore, given X_i-1^j-1, Y_i-1^j-1 and v_j, an iteration of the sequential algorithm is equivalent to the jth iteration of the simulation. We now complete the proof using Lemma <ref>.




	The algorithm Distributed Greedy Max-Dicut gives a 1/3-approximation for the Max-Dicut problem in Õ(Δ + log^*n) communication rounds in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model.


 We start by showing the approximation ratio. By Lemma <ref>, f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i) ≤ [f(X_i)-f(X_i-1)] + [f(Y_i)-f(Y_i-1)] for all 1≤ i ≤ (Δ +1). Summing up the inequality for every i gives:
	
    ∑_i=1^Δ + 1[f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i)] ≤∑_i=1^Δ + 1[f(X_i)-f(X_i-1)] + ∑_i=1^Δ + 1[f(Y_i)-f(Y_i-1)].

	
	As we saw in the sequential case, this is a telescopic sum that after cancellation gives:
	f(𝑂𝑃𝑇_0)-f(𝑂𝑃𝑇_Δ + 1) ≤ [f(X_Δ +1)-f(X_0)] + [f(Y_Δ +1)-f(Y_0)]=f(X_Δ +1)+f(Y_Δ +1).
	
	The last equality follows from the fact that in the case of Max-Dicut f(X_0)=f(Y_0)=0.	
	Hence the output f(𝑂𝑃𝑇_Δ + 1) ≥ f(𝑂𝑃𝑇)/3.
	
	We now analyze the number of communication rounds needed. Coloring the graph using the algorithm of <cit.> takes Õ(Δ^3/4+log^* n) communication rounds. After the coloring, the algorithm runs for (Δ + 1) iterations, each one takes O(1) communication rounds, and hence, the time complexity follows.



 §.§ A Randomized 1/2-Approximation Algorithm for Max-Dicut

As shown in <cit.>, using random decisions improves the approximation ratio. The randomized algorithm differs from the deterministic algorithm in the decision making process. Rather than taking the most profitable decision, the algorithm takes each of the possible decisions with a probability proportional to its value. 
A formal description of the algorithm is given in Algorithm <ref>. The variables X_i,Y_i and 𝑂𝑃𝑇_i are defined as in the deterministic distributed algorithm.



We first show the equivalent of Lemma <ref>, and then prove our main theorem for our algorithm.


	For every 1≤ i ≤ (Δ +1), it holds that: 
	
    ⋆𝔼[f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i)] ≤1/2𝔼[f(X_i)-f(X_i-1) + f(Y_i)-f(Y_i-1)].




	As shown in <cit.>, for the sequential randomized algorithm, where in each step only one vertex makes a decision, it holds that 𝔼[f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i)] ≤1/2𝔼[f(X_i)-f(X_i-1) + f(Y_i)-f(Y_i-1)]. Also, as shown in the proof for Lemma <ref>, denoting by I_i the independent set of vertices colored with i, the i-th iteration of the distributed algorithm can be simulated by |I_i| iterations of the sequential algorithm. Since the inequality holds for one iteration of the sequential algorithms, it holds for |I_i| iterations, and therefore holds for the distributed algorithm.


	The algorithm Distributed Randomized Max-Dicut outputs a 1/2-approximation for Max-Dicut in Õ(Δ + log^*n) communication rounds.



	The proof is very similar to the proof of Theorem <ref>. Using (⋆), and taking a summation over all 1 ≤ i ≤Δ +1, we have
	
    ∑_i=1^Δ + 1𝔼[f(𝑂𝑃𝑇_i-1)-f(𝑂𝑃𝑇_i)] ≤1/2∑_i=1^Δ + 1𝔼[f(X_i)-f(X_i-1) + f(Y_i)-f(Y_i-1)].

	Noting that the sum is telescopic, most of the terms cancel out, and we have
	
    𝔼[f(𝑂𝑃𝑇_0)-f(𝑂𝑃𝑇_Δ+1)]    ≤1/2𝔼[f(X_Δ+1)-f(X_0) + f(Y_Δ+1)-f(Y_0)] 
       ≤1/2𝔼[f(X_Δ+1)+f(Y_Δ+1)].

	Therefore, since 𝑂𝑃𝑇_0=𝑂𝑃𝑇, we have that the output satisfies f(X_Δ+1)=f(Y_Δ+1)=f(𝑂𝑃𝑇_Δ+1) ≥ f(𝑂𝑃𝑇)/2.
	The time complexity analysis is identical to the one for the deterministic algorithm.




A Deterministic ℒ𝒪𝒞𝒜ℒ Algorithm
Our coloring-based algorithms  
may become inefficient for high degree graphs, due to the strong dependence on Δ. 
Consider a clique in this model. The above algorithms require a linear number of communication rounds, while learning the entire graph and finding an optimal solution requires only O(1) communication rounds in the ℒ𝒪𝒞𝒜ℒ model. Indeed, there is a tradeoff between the graph diameter and the average degree of its vertices. Based on this tradeoff, we propose a faster, two-step, deterministic algorithm for Max-Cut that requires min{Õ(Δ +log^*n),O(√(n))} communication rounds in the 
ℒ𝒪𝒞𝒜ℒ model. The pseudocode is given in Algorithm <ref>.

We call a vertex v a low-degree vertex, if deg(v)<√(n), and a high-degree vertex, if deg(v)≥√(n). Define G_low, and G_high as the graphs induced by the low-degree vertices and the high-degree vertices, respectively. The idea is to solve the problem separately for G_low and for G_high.

In the first step, the algorithm deletes every high-degree vertex, if there are any, and its adjacent edges, creating G_low. The deletion means that the low-degree vertices ignore the edges that connect them to high-degree vertices, and do not communicate over them. Then, the algorithm approximates the Max-Cut on G_low, using one of the coloring-based algorithms described in Section <ref>.

In the second step, the problem is solved optimally within each connected component in G_high. However, the high-degree vertices are allowed to communicate over edges which are not in G_high.
As we prove next, the distance in the original graph G between any two vertices which are connected in G_high is bounded from above by O(√(n)). Hence, the number of rounds needed for this part of the algorithm is bounded as well by O(√(n)). 





 
	Assume u,v are connected in G_high, then the distance between u and v in the original graph G is at most 3√(n).


 
	Let dist_G(v_1,v_2) denote the distance between the vertices v_1,v_2∈ V in the original graph G. Let u,v be two connected vertices in G_high, and assume, toward a contradiction, that dist_G(u,v)>3√(n).
	Let {A_i}_i=0^m=(u=a_0,a_1,...,a_m=v) be a sequence of vertices that lie on a shortest path from u to v in G_high. For each pair of vertices (a_i,a_i+1),i=0,..,m-1 on the path, it holds that |dist_G(a_i,u)-dist_G(a_i+1,u)|≤ 1. Therefore, there is a subsequence {A_i_j}_j=0^k for k>3√(n), which starts with u and ends with v, such that for every j=0,..,k-1 it holds that dist_G(a_i_j+1,u)-dist_G(a_i_j,u)=1.
	
	Note that if a_i_j_1 and a_i_j_2 have a common neighbor, then |dist_G(a_i_j_1,u)-dist_G(a_i_j_2,u)|<3.
	Since there are at least k/3 vertices in {A_i_j}_j=0^k, such that the distance between them is at least 3, and each of them is of degree at least √(n), we have that the number of vertices in G is at least k/3·√(n)>n. This contradicts the assumption that dist_G(u,v)>3√(n).

	Fast Distributed Greedy Max-Cut yields a 1/2-approximation to Max-Cut, using min{Õ(Δ +log^*n),O(√(n))} communication rounds in the ℒ𝒪𝒞𝒜ℒ model.



	We first prove the approximation ratio. Since Distributed Greedy Max-Cut is applied on G_low, at least half of the edges of G_low are in the cut.
	Given the decisions of vertices in G_low, the algorithm finds an optimal solution for all vertices in G_high. Note that running Distributed Greedy Max-Cut on the high-degree vertices of G, would give at least half of the remaining edges. This is due to the fact that the algorithm makes sequential greedy decisions. Therefore, an optimal solution for the high-degree vertices guarantees at least half of the edges in G∖ G_low, implying the approximation ratio.
	
	Applying Distributed Greedy Max-Cut on G_low requires Õ(Δ_low +log^*n) communication rounds, where Δ_low=min{Δ,√(n)}. Using Lemma <ref> we have that each high degree vertex can communicate with every high-degree vertex connected to it in G_high, using at most O(√(n)) communication rounds. Hence, Steps 2.-4. of the algorithm take O(√(n)) communication rounds. We note that when Δ<√(n), the algorithm terminates after the first step. Thus,
	the algorithm requires min{Õ(Δ +log^*n),O(√(n))} communication rounds.

Using the above technique, we obtain a fast, deterministic algorithm for the Max-Dicut problem, by replacing the call to Distributed Greedy Max-Cut in Step 1. with a call to Distributed Greedy Max-Dicut.
Using the same arguments as in the analysis for the Max-Cut algorithm, we have:


	Fast Distributed Greedy Max-Dicut yields a 1/3-approximation to Max-Dicut, using min{Õ(Δ +log^*n),O(√(n))} communication rounds in the ℒ𝒪𝒞𝒜ℒ model.




Discussion
In this paper we addressed Max-Cut in the classic distributed network models, where the graph represents a synchronous communication network. Our clustering-based and coloring-based techniques led to the development of the first distributed approximation algorithms for Max-Cut and Max-Dicut on general graphs in these models. We mention below some avenues for future work. It would be interesting to understand how close is the complexity of our algorithms to the true complexity of the problems in each of the distributed models. Moreover, the gap between the best approximation ratio achieved in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model and the best approximation ratio achieved in the ℒ𝒪𝒞𝒜ℒ model raises the immediate question of how congestion affects the ability to approximate the problems.
Another direction is to obtain lower bounds in terms of running times in approximating these problems. In particular: what is the lower bound for achieving an approximation factor strictly better than 1/2 in the 𝒞𝒪𝒩𝒢ℰ𝒮𝒯 model?
Finally, it would be interesting to extend the algorithms for other, and perhaps more general submodular maximization problems.



Acknowledgements
We thank Roy Schwartz and Shay Kutten for stimulating discussions and for helpful comments on the paper.



splncs03















































































































































































































































































































	














