Distributed Edge Connectivity in Sublinear Time

TL;DR

This paper introduces the first sublinear-time distributed algorithm to compute exact edge connectivity in networks, leveraging new techniques like expander decomposition and tree packing, significantly improving efficiency over previous methods.

Contribution

It develops novel distributed algorithms for edge connectivity and network decomposition, enabling exact computation in sublinear time for large networks.

Findings

Achieved sublinear-time exact edge connectivity computation.

Devised a distributed algorithm for k-edge connectivity certificates.

Extended tree packing techniques for minimum cut computation.

Abstract

We present the first sublinear-time algorithm for a distributed message-passing network sto compute its edge connectivity $\lambda$ exactly in the CONGEST model, as long as there are no parallel edges. Our algorithm takes $\tilde O(n^{1-1/353}D^{1/353}+n^{1-1/706})$ time to compute $\lambda$ and a cut of cardinality $\lambda$ with high probability, where $n$ and $D$ are the number of nodes and the diameter of the network, respectively, and $\tilde O$ hides polylogarithmic factors. This running time is sublinear in $n$ (i.e. $\tilde O(n^{1-\epsilon})$) whenever $D$ is. Previous sublinear-time distributed algorithms can solve this problem either (i) exactly only when $\lambda=O(n^{1/8-\epsilon})$ [Thurimella PODC'95; Pritchard, Thurimella, ACM Trans. Algorithms'11; Nanongkai, Su, DISC'14] or (ii) approximately [Ghaffari, Kuhn, DISC'13; Nanongkai, Su, DISC'14]. To achieve this we develop and combine several new techniques. First, we design the first distributed algorithm that can compute a $k$-edge connectivity certificate for any $k=O(n^{1-\epsilon})$ in time $\tilde O(\sqrt{nk}+D)$. Second, we show that by combining the recent distributed expander decomposition technique of [Chang, Pettie, Zhang, SODA'19] with techniques from the sequential deterministic edge connectivity algorithm of [Kawarabayashi, Thorup, STOC'15], we can decompose the network into a sublinear number of clusters with small average diameter and without any mincut separating a cluster (except the `trivial' ones). Finally, by extending the tree packing technique from [Karger STOC'96], we can find the minimum cut in time proportional to the number of components. As a byproduct of this technique, we obtain an $\tilde O(n)$-time algorithm for computing exact minimum cut for weighted graphs.

Equations

$$|C_i|\le (1+ϵ)\frac{\tau \ln n}{{ϵ}^{2}k}|C|$$

$$\sum _{i\in B}|C_i|=|C|-\sum _{i\notin B}|C_i|=|C|-\sum _{i\notin B}{F}_i(C)$$

$$|F(C)|$$

$$\ge \sum _{i\in B}\frac{(1+ϵ)\tau \ln n}{{ϵ}^2}+\sum _{i\notin B}|F_i(C)|$$

$$\ge \frac{(1+ϵ)\tau \ln n}{{ϵ}^2}\sum _{i\in B}\frac{|C_i|}{(1+ϵ)\frac{\tau \ln n}{{ϵ}^{2}k}|C|}+x$$

$$=\frac{(1+ϵ)\tau \ln n}{{ϵ}^2}\cdot \frac{|C|-x}{(1+ϵ)\frac{\tau \ln n}{{ϵ}^{2}k}|C|}+x$$

$$=\frac{|C|-x}{\frac{|C|}{k}}+x$$

$$\lambda$$

$$\ge \Phi (X)\cdot {\mathrm{vol}}_{G[X]}(T\cap X)$$

$$\ge \Phi (X)\cdot {\mathrm{vol}}_{G[X]}(T\cap C)$$

$$\ge \Phi (X)\cdot \frac{2}{5}\delta \cdot |T\cap C|$$

$$\ge \frac{c}{n^{\rho }}\cdot \frac{2}{5}\delta \cdot \delta /100$$

$$>\frac{c}{\delta }\cdot \frac{2}{5}\delta \cdot \delta /100$$

$$>\delta$$

$$\delta$$

$$={\mathrm{vol}}_{G[C]}(C\cap T)-|E(C\cap T,C\cap T)|$$

$$\ge (2/5)\cdot \delta \cdot |C\cap T|-|C\cap T{|}^2$$

$$|E(\left\{u\right\},T)|$$

$$=|E(\left\{u\right\},C\setminus U)|$$

$$={\text{indegree}}_C(u)-|E(\left\{u\right\},U\cap C)|$$

$$>\text{degree}(u)/2+1-1$$

$$\ge \text{degree}(u)/2$$

$$\sum _{C\in \mathcal{C}}diam(G[C]$$

$$\le \sum _{\begin{array}{c}C\in \mathcal{C}\\ |C|>1\end{array}}\left(\frac{|C|}{\delta }+1\right)+O(n^{1-ϵ/20})$$

$$\le \frac{n}{\delta }+\sum _{\begin{array}{c}C\in \mathcal{C}\\ |C|>1\end{array}}1+O(n^{1-ϵ/20})$$

$$=O(n^{1-ϵ/20})$$

$$\partial (v^{\downarrow T})\cap \partial (u)$$

$$=\left\{(u,x)|(u,x)\in E,x\in v^{\downarrow T}\right\}$$

$$=\left\{(u,x)|(u,x)\in E,v\in {\mathrm{anc}}_T(x)\right\}$$

$$\partial (v^{\downarrow T})\cap \partial (u)$$

$$=\left\{(u,x)|(u,x)\in E,x\notin v^{\downarrow T}\right\}$$

$$=\left\{(u,x)|(u,x)\in E,v\notin {\mathrm{anc}}_T(x)\right\}.$$

$$\mathrm{mapping}(\overline{T},\overline{G})\triangleq \overline{T}\bigcup _{C\text{ is cluster of }\overline{G}}\overline{T}[C]$$

$$\mathrm{Pr}[\text{\# edges sampled from }C\ge (1+ϵ)p\alpha k]\le e^{-\frac{{ϵ}^{2}p\alpha k}{3}}=e^{-\tau \alpha \ln n}$$

$$\mathrm{Pr}[\text{\# edges sampled from any cut of size at most α⋅k}\ge ((1+ϵ)p\alpha k)]$$

$$=e^{2\alpha \ln n}\cdot e^{-\tau \alpha \ln n}$$

$$=e^{-(\tau -2)\alpha \ln n}$$

$$=n^{-(\tau -2)\alpha }$$

$$\mathrm{Pr}[\text{\# edges sampled from any cut C}\ge ((1+ϵ)p|C|)]\le n^{-(\tau -2)-2}$$

$$a_j\le \frac{1}{12n^{\rho }\log m}\cdot \min \left(\sum _{i=1}^{j-1}{a}_i,\sum _{i=j+1}^D{a}_i\right).$$

$$S_{\lfloor D/4\rfloor }\cdot {\left(1+\frac{1}{12n^{\rho }\log m}\right)}^{D/4}\ge S_{\lfloor D/4\rfloor }\cdot {\left(1+\frac{1}{12n^{\rho }\log m}\right)}^{12n^{\rho }{\log }^{2}m}\ge S_{\lfloor D/4\rfloor }\cdot m,$$

$$\min (|C|,|\bar{C}|)\ge \frac{\tilde{D}}{4}/4\cdot n^{\gamma }/2\ge \frac{\tilde{D}}{32}{n}^{\gamma }.$$

$$V_{\mathrm{vol}}(S)\le (2/3)V_{\mathrm{vol}}(V^{\ast })\text{and}\Phi (S)\le \frac{{\varphi }^3}{19208{\ln }^2(|E^{\ast }|e^4)}.$$

Full text

To achieve this we develop and combine several new techniques. First, we design the first distributed algorithm that can compute a $k$-edge connectivity certificate for any $k=O(n^{1-\epsilon})$ in time $\tilde{O}(\sqrt{nk}+D)$. The previous sublinear-time algorithm can do so only when $k=o(\sqrt{n})$ [Thurimella PODC’95].

In fact, our algorithm can be turned into the first parallel algorithm with polylogarithmic depth and near-linear work. Previous near-linear work algorithms are essentially sequential and previous polylogarithmic-depth algorithms require $\Omega(mk)$ work in the worst case (e.g. [Karger, Motwani, STOC’93]).

Second, we show that by combining the recent distributed expander decomposition technique of [Chang, Pettie, Zhang, SODA’19] with techniques from the sequential deterministic edge connectivity algorithm of [Kawarabayashi, Thorup, STOC’15], we can decompose the network into a sublinear number of clusters with small average diameter and without any mincut separating a cluster (except the “trivial” ones). This leads to a simplification of the Kawarabayashi-Thorup framework (except that we are randomized while they are deterministic). This might make this framework more useful in other models of computation. Finally, by extending the tree packing technique from [Karger STOC’96], we can find the minimum cut in time proportional to the number of components. As a byproduct of this technique, we obtain an $\tilde{O}(n)$-time algorithm for computing exact minimum cut for weighted graphs.

1. 1 Introduction

2. 2 Preliminaries

3. 3 Connectivity Certificate

4. 3.1 Distributed and Parallel Implementation of Algorithm 2

5. 4 Graph Contraction

6. 4.1 Correctness of Algorithm 4

7. 4.2 Distributed implementation of Algorithm 4

8. 5 Min-Cut in Contracted Graph

9. 5.1 Min-Cut in General Graph

10. 5.2 Min-Cut of the Contracted Graph from Theorem 4.2

11. 6 Putting Everything Together

12. 7 Open Problems

13. A Proof of Theorem 3.2

14. B Omitted proofs from section 5

15. B.1 Proof of Lemma 5.13

16. B.2 Proof of Lemma 5.3 and Lemma 5.14

17. C Proof of Theorem 4.4

18. C.1 Subroutines

19. C.2 Proof of Lemma C.1

1 Introduction

Edge connectivity is a fundamental graph-theoretic concept measuring the minimum number of edges to be removed to disconnect a graph $G$. We give a new algorithm for computing this measure in the $\mathsf{CONGEST}$ model of distributed networks. In this model a network is represented by an unweighted, undirected, connected $n$-node graph $G=(V,E)$. Nodes represent processors with unique IDs and infinite computational power that initially only know their incident edges. They can communicate with each other in rounds, where in each round each node can send a message of size $O(\log n)$ to each neighbor. The goal is for nodes to finish some tasks together in the smallest number of rounds, called time complexity. The time complexity is usually expressed in terms of $n$ and $D$, the number of nodes and the diameter of the network. Throughout we use $\tilde{\Theta}$, $\tilde{O}$ and $\tilde{\Omega}$ to hide polylogarithmic factors in $n$. (See Section 2 for details of the model.)

There are two natural objectives for computing a network’s edge connectivity. The first is to make every node knows the edge connectivity of the network, denoted by $\lambda$. The second is to learn about a set $C$ of $\lambda$ edges whose removals disconnect the graph, typically called a mincut. In this case, it is required that every node knows which of its incident edges are in $C$.222Readers who are new to distributed computing may wonder whether it is also natural to have a third objective where every node is required to know about all edges in the mincut. This can be done fairly quickly after we achieve the second objective, i.e. in $O(\min(\lambda,\sqrt{n\lambda})+D)$ rounds [CGK14]. For this reason, we do not consider this objective here. Since our results and other results hold for both objectives, we do not distinguish them in the discussion below.

It is typically desired that distributed algorithms run in sublinear time, meaning that they take $\tilde{O}(n^{1-\epsilon}+D)$ time for some constant $\epsilon>0$.333An exception is when a linear-time lower bound can be proved, e.g. for all-pairs shortest paths and diameter (e.g. [BN19, HNS17, Elk17, LP13, HW12, FHW12, PRT12, ACK16]).. Such algorithms have been achieved for many problems in the literature, such as minimum spanning tree, single-source shortest paths, and maximum flow [Elk17, GL18, FN18, CGK14, BKKL17, Nan14, NS14, GK13, GKK*+*15, KP98, GKP98]. In the context of edge connectivity, the first sublinear-time algorithm, due to Thurimella [Thu95], was for finding if $\lambda=1$ (i.e. finding a cut edge) and takes $O(\sqrt{n}\log^{*}n+D)$ time. This running time was improved to $O(D)$ by Pritchard and Thurimella [PT11], who also presented an algorithm with the same running time for $\lambda=2$ (i.e. they can find a so-called cut pair). More recently, by adapting Thorup’s tree packing [Tho07], Nanongkai and Su [NS14] presented a $O((\sqrt{n}\log^{*}n+D)\lambda^{4})$-time algorithm, achieving sublinear time for any $\lambda=n^{1/8-\epsilon}$.

To compute $\lambda$ when $\lambda\geq n^{1/8}$, we are only aware of approximation algorithms. The state-of-the-art is the $O((\sqrt{n}\log^{*}n+D)\epsilon^{-5}\log^{3}(n))$-time $(1+\epsilon)$-approximation algorithm of Nanongkai and Su [NS14], which is an improvement over the previous approximation algorithms by Ghaffari and Kuhn [GK13]. In fact, both algorithms can approximate the minimum-weight cut, and the running time of $O((\sqrt{n}\log^{*}n+D)\epsilon^{-5}\log^{3}(n))$ matches a lower bound of [DHK*+*12] up to polylogarithmic factors; this lower bound holds even for $\mbox{\rm poly}(n)$-approximation algorithms and on unweighted graphs [GK13] (also see [EKNP14, KKP13, Elk06, PR00]).

Given that approximating edge connectivity is well-understood, a big open problem that remains is whether we can compute $\lambda$ exactly. This question in fact reflects a bigger issue in the field of distributed graph algorithms: While there are plenty of sublinear-time approximation algorithms, many of which are tight, very few sublinear-time exact algorithms are known. This is the case for, e.g., minimum cut, maximum flow, and maximum matching (e.g. [HKN16, BKKL17, Nan14, NS14, GK13, GKK*+*15, AKO18]). To the best of our knowledge, the only exceptions are the classic exact algorithms for minimum spanning tree [GKP98, KP98] and very recent results on exact single-source and all-pairs shortest paths [Elk17, GL18, FN18, BN19, HNS17]. A fundamental question here is whether other problems also admit sublinear-time exact algorithm, and to what extent such algorithms can be efficient.

Our Contributions.

We present the first sublinear-time algorithm that can compute $\lambda$ exactly for any $\lambda$. Our algorithm works on simple graphs, i.e. when the network contains no multi-edge.

Theorem 1.1**.**

There is a distributed algorithm that, after $\tilde{O}(n^{1-1/353}D^{1/353}+n^{1-1/706})$ time, w.h.p. (i) every node knows the network’s edge connectivity $\lambda$, and (ii) there is a cut $C$ of size $\lambda$ such that every node knows which of its incident edges are in $C$.444We say that an event holds with high probability (w.h.p.) if it holds with probability at least $1-1/n^{\epsilon}$, where $\epsilon$ is an arbitrarily large constant.

As a byproduct of our technique, we also obtain a $O(n\text{ polylog}n)$-round algorithm for computing exact minimum cut in weighted graphs (see Theorem 5.1).

To achieve Theorem 1.1, we develop and combine several new techniques from both distributed and static settings. First, note that we can also assume that we know the approximate value of $\lambda$ from [NS14, GK13]. More importantly, the previous algorithm of [NS14] can already compute $\lambda$ in sublinear time when $\lambda$ is small; so, we can focus on the case where $\lambda$ is large here (say $\lambda=\Omega(n^{c})$ for some constant $c>0$). Our algorithm for this case is influenced by the static connectivity algorithm of Kawarabayashi and Thorup (KT) [KT15], but we have to make many detours. The idea is as follows. In [KT15], it is shown that if a simple graph $G=(V,E)$ of minimum degree $\delta$ has edge connectivity strictly less than $\delta$, then there is a near-linear-time static algorithm that partitions nodes in $G$ into $\tilde{O}(n/\delta)$ many clusters in such a way that no mincut separates a cluster; i.e. for any mincut $C\subseteq E$, every edge in $C$ must have two end-vertices in different clusters. Once this is found, we can apply a fast static algorithm on a graph where each cluster is contracted into one node. Since in our case $\delta\geq\lambda=\Omega(n^{\epsilon})$, the KT algorithm gives hope that we can partition our network into $\tilde{O}(n/\delta)=\tilde{O}(n^{1-\epsilon})$ clusters. Then we maybe able to design a distributed algorithm that takes time near-linear in the number of clusters. There are however several obstacles:

1. (i)

The KT algorithm requires to start from a $\lambda$-edge connectivity certificate, i.e. a subgraph of $O(n\lambda)$ edges with connectivity $\lambda$. However, existing distributed algorithms can compute this only for $\lambda=o(\sqrt{n})$. 2. (ii)

The KT algorithm is highly sequential. For example, it alternatively applies the contraction and trimming steps to the graph several times. 3. (iii)

Even if we can get the desired clustering, it is not clear how to compute $\lambda$ in time linear in the number of clusters. In fact, there is even no $\tilde{O}(n)$-time algorithm for computing $\lambda$.

For the first obstacle, the previous algorithm for computing a $\lambda$-edge connectivity certificate is by Thurimella [Thu95]. It takes $O((\sqrt{n}\log^{*}n+D)\lambda)$, which is too slow when $\lambda$ is large. To get around this obstacle, we design a new distributed algorithm that can compute a $\lambda$-edge connectivity certificate in $\tilde{O}(\sqrt{n\lambda}+D)$ time. The algorithm is fairly intuitive: We randomly partition edges into $c=\lambda/\operatorname{polylog}(n)$ groups. Then we compute an $O(\operatorname{polylog}(n))$-edge connectivity certificate for each group simultaneously. This is doable in $\tilde{O}(\sqrt{nc}+D)$ time by fine-tuning parameters of Kutten-Peleg’s minimum spanning tree algorithm [KP98] and using the scheduling of [Gha15], as discussed in [Gha15].

This algorithm also leads to the first parallel algorithm for computing a $2$-edge connectivity certificate with polylogarithmic depth and near-linear work. To the best of our knowledge, previous near-linear work algorithms are essentially sequential and previous polylogarithmic-depth algorithms require $\Omega(mk)$ work in the worst case (e.g. [KM97]).

For the second obstacle, we first observe that the complex sequential algorithm for finding clusters in the KT algorithm can be significantly simplified into a few-step algorithm, if we have a black-box algorithm called expander decomposition. Expander decomposition was introduced by Kannan et al. [KVV00] and is proven to be useful for devising many fast algorithms [ST04, OV11, OSV12, KLOS14, CKP*+*17b, CGP*+*18] and also dynamic algorithms [NS17, NSW17, Wul17]. With this algorithm, we do not need most of the KT algorithm, except some simple procedures called trimming and shaving, which can be done locally at each node. More importantly, we can avoid the long sequence of contraction and trimming steps (we need to apply these steps only once). Unfortunately, there is no efficient distributed algorithm for computing the expander decomposition.555It would be possible to obtain this using the balanced sparse cut algorithm claimed by Kuhn and Molla [KM15], but as noted in [CPZ19], the claim is incorrect. We thank Fabian Kuhn for clarifying this issue. After our paper is announced, an efficient distributed algorithm for computing balanced sparse cut is correctly shown in [CS19]. However, we can slightly adjust a very recent algorithm by Chang et al. [CPZ19] to obtain a weaker variant of the expander decomposition, which is enough for us.

For the third obstacle, our main insight is the observation that the clusters obtained from the KT algorithm (even after our modification) has low average diameter ($O(n^{c})$ for some small constant $c$). Intuitively, if every cluster has small diameter, then we can run an algorithm on a smaller network where we pretend that each cluster is a node. The fact that clusters have lower average degree is not as good, but it is good enough for our purpose: we can adjust Karger’s near-linear-time algorithm [Kar00] to compute $\lambda$ in time near-linear in the number of clusters.

2 Preliminaries

Model

We work in the $\mathsf{CONGEST}$ model [Pel00]. This is a distributed model for networks which allows synchronous message-passing between any two nodes in the network connected by a direct communication link. The bandwidth is considered to be bounded. Also, the links and nodes are considered to be fault resistant. More formally defined, in the $\mathsf{CONGEST}$ model, communication network is modeled as a undirected graph $G=(V,E)$ where each node in $V$ models a processor and each pair of nodes $\{u,v\}\in E\subseteq\binom{V}{2}$ is modeled as a link between the processors corresponding to $u$ and $v$, respectively. In the remainder of this paper, we identify vertices, nodes and processors. Also, we use edges for links. In the $\mathsf{CONGEST}$ model, at the beginning each node $v\in V$ has a unique identifier ${id}(v)$ of size $O(\log{n})$ (where $n=|V|$) which is known to node $v$ itself and all its neighbors, i.e., the nodes to which $v$ is connected with a direct communication link. For brevity we will assume that for all node ${id}(v)\in[n]$. 666This is a restricted property from general $\mathsf{CONGEST}$ model and can be achieved in $O(D)$ rounds. In $\mathsf{CONGEST}$ model, message passing between any two nodes connected with direct links occur in synchronous rounds. Lets fix an arbitrary node $v\in V$. At the beginning of each round, node $v$ may send to each of its neighbors a message of size $\Theta(\log{n})$ to all its neighbors. Before the next round begins node $v$ may perform internal computation based on all messages it has received so far and its local knowledge of the network. In the $\mathsf{CONGEST}$ model, the complexity of any algorithm is a measure of the total number of rounds required before the algorithm terminates. The internal computation is not charged.

Notations

We are given a undirected unweighted simple graph $G=(V,E)$ where $V$ is the vertex set and $E$ is the edge set. We use $n=|V|$ and $m=|E|$. Throughout this paper, we will use $\delta$ to denote the min-degree and $\lambda$ for edge-connectivity of the graph. For $E^{\prime}\subseteq E$, we use $G[E^{\prime}]$ to be the subgraph of $G$ induced by $E^{\prime}$. Similarly $G[V^{\prime}]$ for $V^{\prime}\subseteq V$. Also for any graph $H$, we use $Diam(H)\triangleq\max_{u,v\in V}\operatorname{distance}_{H}(u,v)$ to denote the diameter of graph $G$. For any vertex $v$, $\deg(v)$ is the degree of the vertex. For a $U\subset V$, $\operatorname{vol}(U)=\sum_{u\in U}\deg(u)$. For some subgraph $H$ of $G$ we use $\deg_{H}(v)$ to denote the degree of vertex $v$ in the subgraph $H$. Lack of subscript implies that the degree is considered with respect to given graph $G$. Similarly, we skip subscript for $\operatorname{vol}$. A cut (edge cut) is a set of edges $C$, whose deletion from the graph partitions the vertex set $V$ into two connected components $\left\{U,V\setminus U\right\}$. We will represent a cut as an edge set, in which case we say a cut $C$ of $G$. At times we will use a partition $\left\{U,T=V\setminus U\right\}$ of vertex set $V$ to represent a cut, then we say a cut $(U,T)$ of $G$. For any vertex $v$, we call cuts of the form $(\left\{v\right\},V\setminus\left\{v\right\})$ trivial. We use $\partial(U)$ to mean the edges in the cut $(U,V\setminus U)$. For any $U\subset V$, conductance of the cut $(U,V\setminus{U})$ is defined as $\phi(U)\triangleq\frac{\partial(U)}{\min\left\{\operatorname{vol}(U),\operatorname{vol}(V\setminus U)\right\}}$. Further, conductance of a graph $G$ is defined by $\Phi(G)\triangleq\min_{U\subset V}\phi(U)$. For brevity, for any $X\subset V$, we use $\Phi(X)$ instead of $\Phi(G[X])$ to mean the conductance of the subgraph $G[X]$.

Organization of this paper

In Algorithm 1, we give a high level overview of the min-cut algorithm. In section 3, we find the Sparse Connectivity certificate. In section 4, we give details of our contraction algorithm which guarantees sublinear number of nodes. Lastly, in section 5, we give details of our algorithm that finds min-cut in the contracted graph.

Previously known result for finding Min-Cut

In section 1, we briefly discussed the result from [NS14]. Here we state their main result.

Theorem 2.1** (From [NS14]).**

There exists an algorithm in the $\mathsf{CONGEST}$ model which finds $1+\epsilon$ approximation of the min-cut in $O((\sqrt{n}\log^{*}n+D)\epsilon^{-5}\log^{3}n)$ rounds where $\epsilon>0$. Further, exact value of min-cut can be found exactly in $O((\sqrt{n}\log^{*}n+D)\lambda^{4}\log^{2}n)$ rounds where $\lambda$ is the size of the min-cut.

In this paper, we use Theorem 2.1 to find the approximate value of min-cut value. This is used in finding the connectivity certificate in Section 3. Further, in Section 6, we use the exact version of the algorithm but only limited to restricted values of $\lambda$.

3 Connectivity Certificate

In this section, we give our algorithm for $k$-edge connectivity certificate which significantly reduces the number of edges in the graph. In the resultant sparse connectivity certificate, we sample $O(kn)$ edges from the graph and prove that these edges are enough to guarantee $k$ edge connectivity of the graph.

Theorem 3.1**.**

Let $G=(V,E)$ be an unweighted graph and $k\leq\lambda$. Then in total of $\tilde{O}(\sqrt{nk}+D)$ rounds in the $\mathsf{CONGEST}$ model we can find a $k$-edge connectivity certificate $E^{\prime}$ of size $O(kn)$ such that every vertex $v$ knows all the adjacent edges in $E^{\prime}$ and w.h.p. for every cut $C$ of $G$ we have $E^{\prime}\cap C\geq k$.

The key idea of our sparse connectivity certificate algorithm is as follows: we first pick a set of random “skeletons” based on [Kar99]. We then construct a small set of spanning forests in each random skeleton. Further, we argue that the union of all spanning forests leads to the required connectivity certificate.

Theorem 3.2**.**

Let $G=(V,E)$ be any unweighted, undirected graph. Let $E^{\prime}\subset E$ be such that each edge $e\in E$ is independently included in $E^{\prime}$ with probability $p=O\left(\frac{\ln n}{\epsilon^{2}k}\right)$ for any $k\leq\lambda$. Then w.h.p. all cuts $C$ have less than $(1+\epsilon)p|C|$ edges sampled in $E^{\prime}$.

Theorem 3.2 is a standard argument relating random sampling and the proof is left to appendix A for completeness.

In Algorithm 2, we give the sequential version of our distributed algorithm to find sparse connectivity certificate. Further, in Lemma 3.3, we prove that for every cut $C$ of $G$, w.h.p., at least $k$ edges finally make to the $k$-edge connectivity certificate which implies that the edge connectivity is at least $k$ as shown in Corollary 3.4. Lastly, in Lemma 3.5 we show that the number of edges selected in the $k$-edge connectivity certificate is $O(kn)$ thus completing the correctness argument.

Lemma 3.3**.**

For any $\epsilon\in(0,1)$, let $k\leq(1+\epsilon)\lambda$, let $E^{\prime}$ be the $k$-edge connectivity certificate returned by Algorithm 2. For any cut $C$, let $F(C)=C\cap E^{\prime}$. Then for all cuts $C$ of $G$ we have $|F(C)|\geq\min\left(k,|C|\right)$ w.h.p.

Proof.

Let $H_{1},H_{2},\ldots,H_{c}$ be the set of subgraphs in algorithm 2 of Algorithm 2. For any cut $C$ of $G$, let $C_{i}=H_{i}\cap C$. These are the set of edges sampled in the subgraph $H_{i}$ from the cut $C$ in Algorithm 2. Using the value of $p$ chosen in Algorithm 2 and Theorem 3.2, we know that w.h.p. for all cuts $C$ of $G$ we have

[TABLE]

In this claim, sampling of edges in a subgraph $H_{i}$ is the only randomized part. Let’s fix an arbitrary cut $C$. Since $k\leq\lambda$ thus $|C|\geq k$. In our algorithm, we construct $\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$ spanning forests one after the other in each subgraph $H_{i}$ and aggregate the edges of all these spanning forests in $E_{i}^{\prime}$. Hence, when $|C_{i}|\geq\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$, at least $\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$ of the total edges from $C_{i}$ make it to $E_{i}^{\prime}$. Let $F_{i}(C)=C\cap E_{i}^{\prime}$. These are the edges from $C$ in the subgraph $H_{i}$ which are finally selected to the sparse connectivity certificate. We segregate the subgraphs into two sets based on $|C_{i}|$. Let $B$ be the set of indices corresponding to the subgraphs such that $|C_{i}|\geq\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$. Recall that $C_{i}$ is the set of edges sampled in the subgraph $H_{i}$ from the cut $C$. Also, each edge of $C$ belongs to exactly one subgraph $H_{i}$ by algorithm 2 of Algorithm 2. Thus, we have

[TABLE]

Here the last equality is true because when $|C_{i}|\leq\lceil(1+\epsilon)\frac{\tau\ln n}{\epsilon^{2}}\rceil$ then all the edges from $C_{i}$ make to $E^{\prime}$, thus $F_{i}(C)=C_{i}$. Also $F(C)=\bigcup_{i}F_{i}(C)$ thus,

[TABLE]

If $|C|>k$, then $\frac{|C|-x}{\frac{|C|}{k}}+x>k-x+x=k$ and if $|C|\leq k$ then $\frac{|C|-x}{\frac{|C|}{k}}+x\geq|C|-x+x=|C|$. Also this is true w.h.p for all cuts $C$. Because eq. 1 holds for all cuts w.h.p. ∎

Corollary 3.4**.**

If $k\leq(1+\epsilon)\lambda$, then the $k$-edge connectivity certificate output by Algorithm 2 has edge connectivity at least $\min(k,\lambda)$ w.h.p.

Proof.

For each $C$ of $G$, any edge in $C$ is selected at most once in the edge connectivity certificate output by Algorithm 2. Also, w.h.p., for all cuts $C$ of the graph $G$, from Lemma 3.3, if $|C|>k$, at least $k$ edges are included in the $k$-edge connectivity certificate and if $|C|\leq k$ then all the edges from cut $C$ are included in the $k$-edge connectivity certificate. Hence w.h.p. the edge connectivity of $E^{\prime}$ is $\min(k,\lambda)$. ∎

Lemma 3.5**.**

The number of edges in the $k$-edge connectivity certificate returned by Algorithm 2 is $O(kn)$.

Proof.

In Algorithm 2, we partition edge set into $c=\frac{\epsilon^{2}k}{\tau\ln n}$ subsets. Further, in each partition we construct $\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$ many spanning forest and use them as sparse connectivity certificate. We know that a spanning forest has at most $n-1$ edges. Thus in total we have $O(kn)$ edges in the $k$-edge connectivity certificate. ∎

3.1 Distributed and Parallel Implementation of Algorithm 2

We now show how to implement Algorithm 2 in the $\mathsf{CONGEST}$ and $\mathsf{PRAM}$ model. We start with the $\mathsf{CONGEST}$ model. We give the required algorithm in Algorithm 3. This is a two phase algorithm. In the first phase we randomly partition the edge set and in the second phase construct a connectivity certificate in each partition. For constructing the connectivity certificate, we use a known result about finding a $l$-slot MST. The $l$-slot version of the MST problem is as follows: for a given graph $G=(V,E)$ and $l$ weight functions $W_{1}$ to $W_{l}$, where $W_{i}:E\rightarrow\mathbb{R}$; the $l$-slot MST problem is to find an MST for each of the weight function $W_{i}$ for $1\leq i\leq l$. The following theorem about $l$-slot MST is obtained by fine-tuning parameters of Kutten-Peleg’s minimum spanning tree algorithm [KP98] and using the scheduling of [Gha15]. We refer to the concluding remarks of [Gha15] for details.

Theorem 3.6**.**

The $l$-slot MST problem can be solved in $\tilde{O}(D+\sqrt{nl})$ rounds.

Using the $l$-slot MST algorithm we give a distributed version of Algorithm 2 in Algorithm 3. Here we make $c$ disjoint partitions of the edges set $E$. This is done by assigning $c$ weight functions $W_{1}(e),\ldots,W_{c}(e)$ to each edge $e$ and if an edge $e$ belongs to some partition $i$ then $W_{i}(e)=1$ otherwise $W_{i}(e)=\infty$. We then construct $\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$ spanning forests in each of these partitions. This is done by constructing c-slot MST using these weight functions iteratively $\lceil\frac{(1+\epsilon)\tau\ln n}{\epsilon^{2}}\rceil$ times. Further, in any iteration $j$, while constructing a spanning forest in a partition $i$, an edge $e$ from constructed MST is selected if it belongs to the partition and has not been selected in a spanning forest prior to iteration $j$. This is ensured by appropriately checking the weight $W_{i}(e)=1$ and assigning $W_{i}(e)\leftarrow\infty$.

Lemma 3.7**.**

The distributed $k$-edge connectivity certificate procedure given in Algorithm 3 requires $\tilde{O}(D+\sqrt{nk})$ rounds.

Proof.

In Algorithm 3, we select an arbitrary leader node $v$, which broadcasts the value of $c$ to all nodes. This takes $O(D)$ rounds. To assign a random color to each edge as in algorithm 2, every vertex $x\in V$, assigns an independently drawn uniformly random $\operatorname{color}(e)\in[1,c]$ to all the edges $e$ incident on $x$ such that the other end point of $e$ has smaller ${id}$ than $x$. If node $x$ assigns $\operatorname{color}(e)$ to some incident edge $e$ then it communicates the same to the other endpoint of $e$. This takes $O(1)$ rounds. Lastly we construct $c$-slot MST for $\lceil\frac{(1+\epsilon)1\tau\ln n}{\epsilon^{2}}\rceil$ many times, where $c=\frac{\epsilon^{2}k}{\tau\ln n}$. By Theorem 3.6, we know that to computer $c$-slot MST in $\tilde{O}(D+\sqrt{nc})=\tilde{O}(D+\sqrt{nk})$ rounds. ∎

To prove the correctness of Algorithm 3, we make the following simple observation.

Observation 3.8**.**

Let $G=(V,E)$ be a simple weighted graph with weight function $W$. Let $E^{\prime}\subset E$ such that $w(e)=1\ \forall e\in E^{\prime}$ and $w(e)=\infty\ \forall e\notin E^{\prime}$. Let $T$ be an MST of $G$. Construct a forest $T^{\prime}$ by remove all edges $e$ from $T$ such that $w(e)=\infty$. Then $T^{\prime}$ is a spanning forest of the subgraph $G[E^{\prime}]$.

Lemma 3.9**.**

Algorithm 3* correctly finds the $k$-edge connectivity certificate.*

Proof.

The edge partition established in Algorithm 3 is similar to Algorithm 2. This is because in both cases each edge is assigned an independent random color from $1$ to $c$ which governs which partition an edge is assigned. Let $\mathcal{E}=\left\{E_{1},\ldots,E_{c}\right\}$ be this partition. To complete this proof we have to show that in both the sequential and the distributed algorithm, the way the spanning forests are constructed in each of the partition is the same. Let’s pick an arbitrary edge set $E_{i}$ in $\mathcal{E}$ and let $H_{i}$ be the subgraph induced by $E_{i}$. In Algorithm 2, we iteratively construct $\lceil\frac{\tau\ln n}{\epsilon^{2}}\rceil$ many spanning forests one after another in the subgraph induced by $H_{i}$. In Algorithm 3, we re-weight the edges used earlier in a spanning forest to $\infty$ and compute an MST. This is done $\lceil\frac{\tau\ln n}{\epsilon^{2}}\rceil$ times. By Observation 3.8, this is similar to constructs spanning forests one after the other in the subgraph $H_{i}$ resulting in a sparse connectivity certificate. ∎

Using Theorem 3.1, we give the following corollary which will be used in finding the graph contraction in section 4 where we will call this using $\texttt{Sparse-Connectivity-Certificate}(G,\epsilon)$ for some $\epsilon\in(0,\frac{1}{2})$.

Corollary 3.10** (From Theorem 3.1).**

Let $0<\epsilon<\frac{1}{2}$ be a constant. Let $G=(V,E)$ be an unweighted graph with $\lambda$ being the edge connectivity. Then in total of $\tilde{O}(n^{1-\epsilon}+D)$ rounds in the $\mathsf{CONGEST}$ model, we can find a sparse connectivity certificate $E^{\prime}$ of size $O(\lambda^{\frac{1}{1-2\epsilon}}n)$ such that the induced subgraph $G[E^{\prime}]$ has connectivity $\lambda$ and every vertex $v$ knows all the adjacent edges in $E^{\prime}$.

Proof.

We use [NS14], which for any $\epsilon>0$ finds the $(1+\epsilon)$ approximation of min-cut in $O((\sqrt{n}\log^{*}n+D)\epsilon^{-5}\log^{3}n)$ rounds. Let $\lambda^{\prime}$ be this approximate value thus $\lambda^{\prime}\leq(1+\epsilon)\lambda$. If $\lambda^{\prime}<n^{1-2\epsilon}$, then we output the result of $\texttt{Dist-Sparse-k-Connectivity-Certificate}(G,\lambda^{\prime})$ (see Algorithm 3). By Lemma 3.7, it takes $\tilde{O}(D+n^{1-\epsilon})$ rounds to compute and by Lemma 3.5, it has $O(\lambda n)$ edges. Also, based on Corollary 3.4, the edge connectivity is $\lambda$. If $\lambda^{\prime}\geq n^{1-2\epsilon}$, we output the whole edge set. This is of size $O(n^{2})=O(\lambda^{\frac{1}{1-2\epsilon}}n)$ and has the required edge connectivity. ∎

Parallel Implementation of Algorithm 2

In this subsection, we prove that Algorithm 2 has an efficient parallel implementation to find a $\texttt{Sparse-k-Connectivity-Certificate}(G,k)$ taking $\tilde{O}(1)$ depth and total of $\tilde{O}(m)$ work. Recall that in Algorithm 2, we partition the edge set into $c$ partitions where $c$ depends on $k$. This takes $O(m)$ work and $O(1)$ depth. Now in each partition, we construct $\operatorname{polylog}$ many spanning forests one after the other. This process is done independently in each partition. Also, each edge participates in construction of $\operatorname{polylog}$ many spanning forests thus the total work is $\tilde{O}(m)$.

Theorem 3.11**.**

Let $G=(V,E)$ be an unweighted graph, let $k\leq\lambda$. Then in $\tilde{O}(1)$ depth and total of $\tilde{O}(m)$ work in the $\mathsf{PRAM}$ model we can find a $k$-edge connectivity certificate $E^{\prime}$ of size $O(kn)$ such that every vertex $v$ knows all the adjacent edges in $E^{\prime}$ and w.h.p. for every cut $C$ of $G$ of size at least $k$ we have $E^{\prime}\cap C\geq k$.

4 Graph Contraction

In this section, we describe an algorithm which outputs a contracted graph. It uses the sparse connectivity certificate from section 3 and the graph decomposition from Theorem 4.4. This contracted graph preserves all non-trivial min-cuts and has a sub-linear number of nodes as in [KT15] and [HRW17]. The idea essentially is to pick specialized vertex sets and contract them. Any such contracted vertex set is called as core. We formally define the contraction in the following definition.

Definition 4.1** (Min-Cut preserving Sublinear Graph Contraction ($\operatorname{MSGC}(G,\epsilon)$)).**

Let $G=(V,E)$ be a simple unweighted graph such that $m=|E|$ and $n=|V|$. For $0<\epsilon<1$, an $\operatorname{MSGC}(G,\epsilon)$ partitions the vertex set $V$ into $\mathcal{C}=\left\{C_{1},C_{2},\ldots,C_{O({n}^{1-\Theta(\epsilon)})}\right\}$ and contracts specialized vertex set with the following properties:

For all $C\in\mathcal{C}$ , such that $|C|>1$, we partition $C=\operatorname{Core}(C)\cup\operatorname{Regular}(C)$. $\operatorname{Core}(C)$ is called the core of $C$. $\operatorname{Regular}(C)$ is a set of regular nodes in $C$. If $|C|=1$ (trivial vertex group), we set $C=\operatorname{Regular}(C)$. 2. 2.

For every $C\in\mathcal{C}$, the vertices in $\operatorname{Core}(C)$ can be contracted to form a core vertex $s(C)$ by deleting the edges which have both end points in $\operatorname{Core}(C)$ and collapse the nodes in $\operatorname{Core}(C)$ to one node. The contracted graph thus formed is the $\operatorname{MSGC}(G,\epsilon)$. Here, $s(C)$ is a vertex of $\operatorname{MSGC}(G,\epsilon)$. 3. 3.

$\operatorname{MSGC}(G,\epsilon)$* preserves all non-trivial min-cuts of $G$* 4. 4.

$\sum_{C\in\mathcal{C}}diam(G[C])=O({n}^{1-\Theta(\epsilon)})$** 5. 5.

$\sum_{C\in\mathcal{C}}|\operatorname{Regular}(C)|=O({n}^{1-\Theta(\epsilon)})$**

Theorem 4.2**.**

Let $G=(V,E)$ be a given simple unweighted graph. Let $\epsilon\in(0,\frac{1}{2})$ be such that $\delta=n^{2\epsilon}$, then we can find an $\operatorname{MSGC}(G,\epsilon)$ as given in Definition 4.1 in $O(n^{1-\epsilon/44})$ rounds such that

A partition $\mathcal{C}=\left\{C_{1},C_{2},\ldots,C_{O({n}^{1-\frac{\epsilon}{22}})}\right\}$ of the vertex set $V$ is established where each cluster $C\in\mathcal{C}$ has a unique ${groupId}(C)\in[2n]$. Henceforth, $\mathcal{C}$ is called the set of vertex groups of $\operatorname{MSGC}(G,\epsilon)$. Also, $\sum_{C\in\mathcal{C}}diam(G[C])=O({n}^{1-\epsilon/20})$ and $\sum_{C\in\mathcal{C}}|\operatorname{Regular}(C)|=O({n}^{1-\epsilon/22})$. 2. 2.

Every vertex $v\in V$, knows the ${groupId}(C)$ of the vertex group $C$ it is part of. When, $|C|>1$, then node $v$ also knows if it is part of $\operatorname{Regular}(C)$ or $\operatorname{Core}(C)$

Our definition of graph contraction has similar properties as in [HRW17] and [KT15] (i.e. sublinear number of nodes and preserving min-cuts). We have an additional property regarding the diameter which enables us to give efficient distributed algorithm to find a min-cut (see section 5). The algorithm to find graph contraction given by Definition 4.1 is described in Algorithm 3. Note that our algorithm runs without the “outer loop” of the algorithms in [HRW17] and [KT15]. Thus by using the expander decomposition algorithm in [SW19], also leads to a simplified static algorithm to find min-cuts. For our setting, we find the high-expansion components using a recent result by [CPZ19]. We change the parameters from their presentation leading to a modified definition to suit our requirements. This is given in Definition 4.3.

Definition 4.3**.**

For $0<\rho,\gamma<1$, $\operatorname{Tripartition}(\gamma,\rho)$ of a simple, unweighted, undirected graph $G=(V,E)$ is a partition of the edge set $E$ to $\mathcal{E}=\left\{E_{h},E_{s},E_{r}\right\}$ satisfying the following:

Each connected component induced by $E_{h}$ is such that $\Phi(X)\geq\frac{c}{n^{\rho}}$ for some constant $c>0$. 2. 2.

$E_{s}=\bigcup_{v\in V}E_{s,v}$, where each vertex $v$ knows about each edge in $E_{s,v}$, edges in $E_{s,v}$ are viewed as oriented away from $v$ and the sub-graph induced by $E_{s}$ has arborocity $O(n^{\gamma})$. 3. 3.

$|E_{r}|=O(m^{1-\rho/2})$* and each edge of $E_{r}$ has endpoints in different connected components in the subgraph induced by the edge set $E_{h}$.*

Theorem 4.4**.**

For $0<\gamma,\rho<1$, in $O(n^{1-\gamma+10\rho})$ rounds, we can find the $\operatorname{Tripartition}(\gamma,\rho)$ of a graph $G=(V,E)$ which partitions the edge set $E$ to $\mathcal{E}=\left\{E_{h},E_{s},E_{r}\right\}$ such that every node $v$ knows which of its incident edges belong to $E_{h},E_{s}$ and $E_{r}$.

We use Theorem 4.4 in Algorithm 4. In the remaining part of this sub-section we give an overview of Algorithm 4. We fix the value of $\epsilon$ such that $\delta=n^{2\epsilon}$. In this algorithm, we first find a sparse connectivity certificate (from section 3). Subsequently, in this section, we use $G$ to represent the graph with reduced number of edges received from sparse connectivity certificate. We then use Theorem 4.4 with $\gamma=\epsilon$ and $\rho=\epsilon/11$ resulting in a tripartition of edge set $E$ into $E_{h},E_{s}$ and $E_{r}$. We use the connected components induced by the edge set $E_{h}$, and by Definition 4.3 each of these components has high expansion. We then trim each component followed by shaving. The process of trimming and shaving are same as [KT15] and described below.

Trimming and Shaving

Given $U\subset V$, to be trimmed, such that all $u\in U$ have same ${groupId}$. In trimming process, we repeatedly remove any vertex $u\in U$ if it has less than $2\deg_{G}(u)/5$ neighbours in $U$ until it is not possible to remover a vertex further. We call a set of vertices $U\subseteq V$ trimmed if all vertices $u\in U$ have at least $2\deg_{G}(u)/5$ of their neighbours in $U$. Suppose $U$ is a vertex set to be trimmed, let $U^{\prime}\subset U$ be the set of vertices which are removed from $U$ in this process. Then the set of edges which are lost during the trimming process of the vertex set $U$ are the edges which have one end point in $U^{\prime}$ and the other in $U\setminus U^{\prime}$. Also, each $u^{\prime}\in U^{\prime}$ assigns itself a new distinct ${groupId}(u)$. The trimming phase is followed by a shaving phase in Algorithm 5. Shaving does not induce a modification of vertex groups rather partitions each vertex group $C$ into two sets: $\operatorname{Core}(C)$ and $\operatorname{Regular}(C)$. For any vertex group $C$, during Shaving, all nodes $v\in C$ are put into $\operatorname{Regular}(C)$ if at least $\deg_{G}(v)/2-1$ edges incident on $v$ leave $C$. We call all such nodes shaved. The remaining vertices from $\operatorname{Core}(C)$.

4.1 Correctness of Algorithm 4

Let $\mathcal{C}$ be the set of vertex groups output by Algorithm 4. In this subsection, we first prove that collapsing a $\operatorname{Core}(C)$ of a vertex group $C\in\mathcal{C}$ does not affect a non-trivial min-cut. Then we show that the number of nodes which are trimmed and shaved are bounded. Lastly, we will show that the sum total of diameter of subgraph induced by the vertex groups in $\mathcal{C}$ is bounded.

Clusters and preserving non-trivial cuts in contracted graph

Similar to [KT15], we call $C\subset V$ a cluster if for every min-cut $(U,T)$ of $G$ both $|C\cap T|>2$ and $|C\cap U|>2$ are not true simultaneously. Algorithm 4 establishes a partition $\mathcal{C}$ of the vertex $V$ set by assigning a ${groupId}(v)$ to each vertex $v$, such that each $C\in\mathcal{C}$ is given by $C=\left\{v\mid{groupId}(v)=i\right\}$ for some $i\in[2n]$.

In Algorithm 4, we start with a partition of vertex set $\mathcal{C}$ corresponding to connected components induced by the edge set $E_{h}$ (recieved from $\texttt{Tripartition}(\gamma=\epsilon,\rho=\epsilon/11)$). We assign a unique ${groupId}$ to each $C\in\mathcal{C}$ which is known to every vertex $v\in C$ and thus the vertex group it is part of. We run the distributed algorithm trim_shave on each node which trims each vertex group $C\in\mathcal{C}$ followed by shaving. In the process ${groupId}$ values of some vertices are changed. In Claim 4.5, we give a technical claim which uses the property of high expansion of each component of $G[E_{h}]$ and properties of trimming and shaving. Using this claim, we prove that at the end of Algorithm 4, each vertex group established by these ${groupId}$’s is a cluster. Finally, using the properties of the cluster and shaving process, in Lemma 4.7, we show that the $\operatorname{Core}(C)$ of a cluster can be collapsed without affecting any non-trivial min-cut.

Claim 4.5**.**

Let $(T,U)$ be any arbitrary min-cut of the graph $G$. At the end of Algorithm 4, for any $i\in[2n]$ let $C=\left\{v\mid{groupId}(v)=i\right\}$ be an arbitrary vertex group. Then both $|C\cap T|\geq\frac{\delta}{100}$ and $|C\cap U|\geq\frac{\delta}{100}$ are not true simultaneously.

Proof.

Recall that in Algorithm 4, we use $\texttt{Tripartition}(\gamma=\epsilon,\rho=\epsilon/11)$ resulting in a tripartition of the edge set into $E_{h},E_{r}$ and $E_{s}$. Furthermore each non-trivial cluster $C$ is formed by trimming some vertices from a connected component $X$ in the subgraph $G[E_{h}]$. Note that in Algorithm 5, we set the ${groupId}(v)=n+{id}(v)$ of every trimmed node $v$. Thus at the end of trim_shave, these nodes form a vertex group of single node . When $|C|=1$, this claim is trivial. Each trimmed vertex group $C$ is formed by trimming some vertices from a connected component $X$ in the subgraph $G[E_{h}]$. Thus for every vertex group $C$ there is a connected component $X$ in the subgraph $G[E_{h}]$ such that $C\subseteq X$. WLOG, assume that $\operatorname{vol}_{G[X]}(T\cap X)<\operatorname{vol}_{G[X]}(U\cap X)$, otherwise we use $\operatorname{vol}_{G[X]}(U\cap X)$ in the below equation. For the sake of contradiction, we assume that both $|C\cap T|\geq\frac{\delta}{100}$ and $|C\cap U|\geq\frac{\delta}{100}$. We have

[TABLE]

The above is a contradiction since the size of min-cut can not be larger than the min-degree. Thus both $|C\cap T|\geq\frac{\delta}{100}$ and $|C\cap U|\geq\frac{\delta}{100}$ are not true simultaneously.

∎

Lemma 4.6**.**

Let $(T,U)$ be any min-cut of the graph $G$. At the end of Algorithm 4, for any $i\in[2n]$ let $C=\left\{v\mid{groupId}(v)=i\right\}$ be an arbitrary vertex group. Then both $|C\cap T|>2$ and $|C\cap U|>2$ are not true simultaneously.

Proof.

We know that the size of min-cut is always smaller or equal to the min-degree. WLOG assume that $|C\cap T|\leq|C\cap U|$. Thus

[TABLE]

Here eq. 4 is true for $|C\cap T|\leq 2$, but this equation cannot be true for any $|C\cap T|$ between $3$ and $\delta/100$. Thus, if $|C\cap T|>2$, it must hold that $|C\cap T|>\delta/100$. But then $|C\cap U|\geq|C\cap T|$ implies that both $|C\cap U|$ and $|C\cap T|$ are larger than $\delta/100$, which is not possible by Claim 5.6. It follows that $|C\cap T|\leq 2$. Thus both $|C\cap T|>2$ and $|C\cap U|>2$ are not true simultaneously. ∎

Lemma 4.7**.**

Let $(T,U)$ be any non-trivial min-cut of the graph $G$. Then for every non-trivial cluster $C$ in cluster set of $\operatorname{MSGC}(G,\epsilon)$ either we have $T\cap\operatorname{Core}(C)=\emptyset$ or $U\cap\operatorname{Core}(C)=\emptyset$.

Proof.

Fix an arbitrary vertex group $C$ of $\operatorname{MSGC}(G,\epsilon)$. Suppose $\operatorname{Core}(C)\neq\emptyset$. For each node $r\in\operatorname{Core}(C)$, let us define the indegree of node $r$ w.r.t to $C$ as the number of edges incident on $r$ which have the other endpoint in $C$ and denote this by $\texttt{indegree}_{C}(r)$. By the property of shaving if $r\in\operatorname{Core}(C)$, then we have $\texttt{indegree}_{C}(r)>\texttt{degree}(r)/2+1$. Let $(T,U)$ (here $T\cup U=V$) be a min-cut. From Lemma 4.6 we know that both $|C\cap T|>2$ and $|C\cap U|>2$ are not simultaneously true. Suppose $|C\cap T|>2$, thus $|C\cap U|\leq 2$. We prove that $U\cap\operatorname{Core}(C)=\emptyset$. For the sake of contradiction let’s assume $u\in U\cap\operatorname{Core}(C)$. .

[TABLE]

The contradiction comes from the fact that flipping $u$’s side in the cut $(T,U)$ decreases the size of $(T,U)$, in contradiction to the fact that it is a min-cut. ∎

Number of trimmed and shaved nodes is bounded

Here, we first prove that the number of edges going between the connected components of the subgraph $G[E_{m}]$ is bounded. Then by using counting argument, we show that the number of trimmed and shaved nodes is bounded. This is similar to [KT15, Lemma 17].

Claim 4.8**.**

Let $\epsilon\in(0,1/2)$ be such that $n^{2\epsilon}=\delta$. Let $\mathcal{X}$ be the connected components in the subgraph $G[E_{m}]$ as in Algorithm 4 of Algorithm 4 while finding $\operatorname{MSGC}(G,\epsilon)$. Then the total number of edges going between any $X,Y\in\mathcal{X}$ is $O(\delta n^{1-\epsilon/22})$.

Proof.

From Definition 4.3, we know that the total number of edges which connect any two components is contributed by $E_{r}$ and $E_{s}$. Since the arboricity of sub-graph induced by $E_{s}$ is $O(n^{\gamma})$ thus we have $|E_{s}|=O(n\times n^{\gamma})$. Further, the number of edges in $E_{r}=O(m^{1-\rho/2})$. Thus the total number of edges going between any two components $X,Y$ is $O(n^{1+\gamma}+m^{1-\rho/2})$. In Algorithm 4, we have used the sparse connectivity certificate, thus by Corollary 3.10, we have $m=\lambda^{\frac{1}{1-2\epsilon/44}}n$. Recall that $\rho=\epsilon/11$ and $\delta\geq\lambda$. The total number of trimmed edges is $O(m^{1-\rho/2}+n\cdot n^{\gamma})=O((\lambda^{\frac{1-\rho/2}{1-\epsilon/22}}n^{1-\rho/2}+n^{1-\gamma}\cdot n^{2\gamma})=O(\delta n^{1-\rho/2}+\delta n^{1-\gamma})=O(\delta\cdot n^{1-\epsilon/22})$. ∎

Lemma 4.9**.**

Let $\epsilon\in(0,1/2)$ be such that $n^{2\epsilon}=\delta$. The number of nodes trimmed in Algorithm 4 to find $\operatorname{MSGC}(G,\epsilon)$ is $O(n^{1-{\epsilon/22}})$.

Proof.

By Claim 4.8, the number of edges going between the connected components $\mathcal{X}$ at Algorithm 4 of Algorithm 2 is $O(n^{1-\epsilon/22})$. Whenever a node $v$ is trimmed from a component $X\in\mathcal{X}$ then this splits the component $X$ into $X\setminus\left\{v\right\}$ and $\left\{v\right\}$ thus updating the component set $\mathcal{X}$. For brevity, let,s say that there are total $c$ edges which go between any two components of $\mathcal{X}$ before the start of trimming process. When a node $v$ decides to trim from some component $X$, then based on the properties it uses at least $3\deg_{G}(v)/5$ edges among the $c$ edges going between components. Also node $v$ has at most $2\deg_{G}(v)/5$ edges going to the vertices in $X$, thus when $v$ is trimmed these are added back to the inter component edges. Hence, trimming a node uses at least $\delta/5$ inter component edges. Thus, there are $O(n^{1-{\epsilon/22}})$ nodes which can be trimmed. By definition trimmed edges are the edges which go between connected components of $\mathcal{X}$. ∎

Using similar argument in the above lemma we can prove that the number of nodes which are shaved (removed from a cluster) is bounded by $O(n^{1-\epsilon/22})$. This implies the following lemma.

Lemma 4.10**.**

Let $\epsilon\in(0,1/2)$ be such that $n^{2\epsilon}=\delta$. Let $\mathcal{C}$ be the cluster set of $\operatorname{MSGC}(G,\epsilon)$ then $\sum_{C\in\mathcal{C}}|\operatorname{Regular}(C)|=O({n}^{1-\epsilon/22})$.

Aggregate cluster diameter is bounded

Now, we prove that that the aggregate diameter of all clusters output by Algorithm 2 is bounded. This requires us to show that the number of clusters $C$ in $\operatorname{MSGC}(G,\epsilon)$, such that $|C|>1$ is bounded. We prove this in the following lemma.

Lemma 4.11**.**

Let $\mathcal{C}$ be the vertex groups of $\operatorname{MSGC}(G,\epsilon)$ output by Algorithm 2. The total number of vertex groups $C\in\mathcal{C}$ such that $|C|>1$ are $O({n^{1-2\epsilon}})$.

Proof.

As per the definition of trimming, each node in a non-trivial cluster, at the end of Algorithm 4 has $\frac{2\delta}{5}$ neighbors in the cluster. Since we are dealing with simple graphs, hence the size of cluster is at least $\frac{2\delta}{5}$. Suppose there are more than $3\frac{n}{\delta}$ non-trivial clusters. Thus, the total nodes in the graph would be $\frac{2\delta}{5}\cdot 3\frac{n}{\delta}=\frac{6}{5}n$, which is a contradiction. Then the number of non-trivial clusters in $\operatorname{MSGC}(G,\epsilon)$ are $O(\frac{n}{\delta})=O(n^{1-2\epsilon})$. ∎

Lemma 4.12**.**

Let $\epsilon\in(0,1/2)$ be such that $n^{2\epsilon}=\delta$. Let $\mathcal{C}$ be the cluster set of $\operatorname{MSGC}(G,\epsilon)$ then $\sum_{C\in\mathcal{C}}diam(G[C])=O({n}^{1-\epsilon/20})$.

Proof.

We know by [EPPT89], that a graph of $n$ nodes with min-degree $d$ has a diameter $\lceil\frac{n}{d}\rceil$. From the trimming process, we know that for every non-trivial cluster $C$, each node $v\in C$ has at least $\frac{2}{5}\deg_{G}(v)$ neighbors in $C$. Thus $diam(G[C])=\lceil\frac{C}{\frac{2}{5}\delta}\rceil$. For each trivial cluster $C$, $diam(G[C])=1$. Thus

[TABLE]

Here the last equation is true since $\delta=n^{2\epsilon}$ and since we know by Lemma 4.11 that the number of non-trivial clusters is $O(n^{1-2\epsilon})$. ∎

4.2 Distributed implementation of Algorithm 4

In Algorithm 5, we implement the trimming process in the distributed setting. Initially, each vertex $v$ is assigned a ${groupId}(v)$ establishing disjoint vertex groups (a partition of vertex set $V$). The algorithm then makes sure that each vertex group is trimmed. During this process vertices which do not satisfy the trimmed condition remove themselves from the corresponding vertex group and assign themselves a new distinct ${groupId}$. This is followed by shaving. In Lemma 4.9 we prove that the total numbers of nodes which are trimmed is bounded. This will allow us to bound the run time of Algorithm 5.

Claim 4.13**.**

If total number of nodes that are trimmed is bounded by $O(k)$ then Algorithm 5 runs in $O(k+D\log k)$ rounds.

Proof.

At the start of Algorithm 5, each node is assigned to a vertex group. Trimming is a iterative process. In each iteration, a node $v$ trims itself if it does not have at least $2/5$ of its neighbours in its group. To decide if a node satisfies the property of trimming, each node just needs to locally check the neighbour’s ${groupId}$ which can be done in $O(1)$ rounds. Now if a node $v$ satisfies the criteria of trimming (when it does not have $2/5$ of its neighbours in the same group) then it trims itself from the group and assigns itself a new ${groupId}$, different from other nodes namely $n+{id}(v)$. The node then communicates its trimmed status to all its neighbours. Note that only the neighbors of a node and not all the nodes in a cluster $C$ need to know if a node $v\in C$ is trimmed. All this can be done in $O(1)$ rounds. Further, it is given that at most $O(k)$ nodes could be trimmed. The only difficult part is how to determined when the trimming process has stopped. To do so we use the bound on the number of nodes which can be trimmed as follows: Suppose for some constant $c$ the total number of trimmed nodes is less than $ck$. We assign a leader node $v$ which will track if it is safe to terminate the trimming process. We start by a limit of $l=2$ rounds. At the end of $l$ rounds, by a simple broadcast, the leader node can find if a there was a node trimmed in last round. This takes $O(D)$ rounds. If there was node which was trimmed, then it allows for doubling of the limit such that $l=2l$. This keeps on happening, until it finds that no node was trimmed at the end of the previous process. This coordination takes an extra $O(D\log k)$ overhead. Shaving is a trivial process which requires each node to check the cluster ${id}$ of its neighbors. Thus this can be done locally in $O(1)$ rounds. ∎

Lemma 4.14**.**

The Algorithm 4 runs in total of $\tilde{O}(n^{1-\epsilon/44}+D)$ rounds in the $\mathsf{CONGEST}$ model to find $MSGC(G,\epsilon)$.

Proof.

Firstly from Corollary 3.10 and Theorem 4.4, we know that the sparse connectivity certificate and the tripartition can be found in sublinear rounds. By the choice of the parameters in Algorithm 2, the sparse connectivity certificate algorithm takes $\tilde{O}(n^{1-\epsilon/44}+D)$ rounds and Tripartition procedure takes $\tilde{O}(n^{1-\gamma+10\rho})=\tilde{O}(n^{1-\epsilon/11})$. In procedure Tripartition, we partition the edge set into $E_{h},E_{r}$ and $E_{s}$. Let $\mathcal{X}$ be the set of connected components of the subgraph $G[E_{h}]$. We assign a unique ${groupId}$ to every $X\in\mathcal{X}$ known to every vertex in $X$. This is done in a distributed fashion and takes $\max_{X\in\mathcal{X}}Diam(G[X])$ rounds. By Definition 4.3, we know that for each $X$, $\Phi(X)\geq\frac{c}{n^{\rho}}$. Also, we know that the diameter of any graph with expansion $\Phi$ is ${O}(\log n\frac{1}{\Phi})$. Hence the diameter of any component $X$ is ${O}\left(n^{\rho}\log n\right)$. As per Lemma 4.9 the number of trimmed nodes are $O(n^{1-\epsilon/22})$. Hence, by Claim 4.13, the distributed algorithm for trimming and shaving takes $O(n^{1-\epsilon/22}+D\log n)$ rounds. Thus the overall running time is $\tilde{O}(n^{1-\epsilon/44}+D)$ rounds. ∎

5 Min-Cut in Contracted Graph

In this section, we show that given a contracted graph $\operatorname{MSGC}(G,\epsilon)$ from Theorem 4.2, we can find a min-cut in $O({n}^{1-\eta})$ rounds where $\eta=\Theta(\epsilon)$. Here we use the idea from [Kar00], which gives a near linear time randomized min-cut algorithm for general graph in the centralized setting. Essentially, [Kar00] illustrates that given a graph, we can construct a set of few spanning trees such that at least one of them crosses a min-cut twice. Further, in each tree [Kar00] can find the cut of minimum size which crosses the tree twice.

The main contribution from this section is two folds. First, in section 5.1, we show that [Kar00] can be implemented in distributed setting in $\tilde{O}(n)$ rounds. This is the first ever algorithm which finds exact min-cut in linear time in $\mathsf{CONGEST}$ model. Here, we develop the required machinery which gives a distributed algorithm to do the same in the contracted graph from Theorem 4.2, hence giving a sub-linear running time of the algorithm.

5.1 Min-Cut in General Graph

In this section, we give an algorithm for finding min-cut in weighted graphs. A widely used assumption in the $\mathsf{CONGEST}$ model is that, each edge weight is in $\left\{1,2,\ldots,\mbox{\rm poly}(n)\right\}$. This allows to exchange edge weight between any two nodes in a single round of communication. Further, this limits the size of any cut to $\mbox{\rm poly}(n)$, hence can be represented in $O(\log n)$ bits.

Theorem 5.1**.**

Given a weighted simple graph $G=(V,E)$, with weight function $w:E\rightarrow\left\{1,2,\ldots,\mbox{\rm poly}(n)\right\}$, in $\tilde{O}(n)$ w.h.p. (i) every node knows the network’s edge connectivity $\lambda$, and (ii) there is a cut $C$ of size $\lambda$ such that every node knows which of its incident edges are in $C$.

We replace an edge $e$ with weight $w(e)$ with $w(e)$ parallel edges. But the total communication across all these edges in any given round, is still restricted to $O(\log n)$ bits. Let $T$ be spanning tree of $G$. We say that a cut in $G$, $k$-respects a spanning tree $T$ if it cuts at most $k$ edges of the tree.

Lemma 5.2**.**

Given a graph $G$, in $\tilde{O}(\sqrt{n}+D)$ rounds, we can find a set of spanning trees $\mathcal{T}=\left\{T_{1},\ldots,T_{k}\right\}$ for some $k={\Theta}(\log^{2.2}n)$ such that w.h.p. there exists a min-cut of $G$ which 2-respects at least one spanning tree $T\in\mathcal{T}$. Also each node $v$ knows which edges incident to it are part of the spanning tree $T_{i}$ for $1\leq i\leq k$.

The proof of Lemma 5.2 is based on tree packing, where a set of $\Theta(\log^{2.2}n)$ MSTs are constructed by appropriately assigning weights to the edges. This is based on [Kar99, Tho07] and details of which are left to appendix B. The important step of our algorithm is a sub-routine, which given any spanning tree $T$, finds a minimum-sized cut which 2-respects the tree $T$. We run this sub-routine on all the trees in the set of trees $\mathcal{T}$ received from Lemma 5.2. For all the spanning trees $T$ in $\mathcal{T}$ we fix an arbitrary root denoted by $r_{T}$. For any vertex $v$ other than the root, we use $\pi_{{T}}\left(v\right)$ to denote the parent of vertex $v$ and $e_{{T}}\left(v\right)$ to denote the tree edge $(\pi_{{T}}\left(v\right),v)$. We use ${v}^{\downarrow{T}}$ to denote the set of decedents of the vertex $v$ in tree $T$ and let ${\operatorname{anc}}_{T}\left(v\right)$ be the set of ancestors of a node $v$ in the spanning tree $T$ including $v$ itself and let $\operatorname{children}_{T}(v)$ be the set of child nodes of $v$ in the rooted spanning tree $T$. Also let $Depth(T)$ be the distance from root $r_{T}$ to the furthest node. We give the following lemma which describes high level distributed algorithms in $\mathsf{CONGEST}$ model. These are standard algorithms and details are left to appendix B.

Lemma 5.3**.**

Let $T$ be a rooted spanning tree of $G$ then,

If each node $v$ of $G$ has a message $\texttt{msg}_{v}$ to be sent to each and every node in ${v}^{\downarrow{T}}$, then to deliver all such messages it takes $O(Depth(T))$ rounds. 2. 2.

Let $f:V\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ and $g:V^{2}\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ be some functions. Let $f(v)=\sum_{x\in{v}^{\downarrow{T}}}g(v,x)$ and $g(v,x)$ is precomputed by every node $x$ for all $v\in\operatorname{anc}_{T}(x)$. Then in total of $O(Depth(T))$ rounds $f$ can be computed by all nodes $v$. 3. 3.

Let $f,g:V\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ be some functions. For every node $v$ of $G$, let $f(v)=g(v)+\sum_{c\in\operatorname{children}_{{T}}\left(v\right)}f(c)$. If $g(v)$ is precomputed by every node $v$, then $f$ can be computed in total of $O(Depth(T))$ rounds by every node $v$ of $G$. Further if we have $k$ such functions then every node $v$ of $G$ can compute them in $O(Depth(T)+k)$ rounds.

For any vertex set $A\subset V$, let $\partial(A)$ denote the cut induced by $A$. Further, let $C(A)\triangleq|\partial(A)|$ and $C(A,B)\triangleq|\partial(A)\cap\partial(B)|$ for any $A,B\subset V$. We use the operator $\oplus$ to represent the set symmetric difference. In this section, the vertex sets we focus on will be based on some rooted spanning tree $T$. Recall that for any vertex $v$, ${v}^{\downarrow{T}}$ is the vertex set containing all the decedents of vertex $v$ in the rooted spanning tree $T$. Note that for any two vertices $v,u\in V$, the vertex sets ${v}^{\downarrow{T}}$ and ${u}^{\downarrow{T}}$ are either disjoint or one of them is contained in the other. In most of the proofs given in this section we will have these two cases as illustrated in the fig. 1.

Lemma 5.4**.**

For any rooted spanning tree $T$ and for any two nodes $v,u\in V\setminus\left\{r_{T}\right\}$ we have

$|\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})|=C({v}^{\downarrow{T}})+C({u}^{\downarrow{T}})-2C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$** 2. 2.

$E[T]\cap\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})=\left\{e_{{T}}\left(v\right),e_{{T}}\left(u\right)\right\}$**

Proof.

Here we have two cases ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\phi$ or ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}\neq\phi$. Taking the first case, let’s assume that ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\emptyset$. Since, $\oplus$ is the symmetric difference operator, hence, ${v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}}={v}^{\downarrow{T}}\cup{u}^{\downarrow{T}}$ as given in fig. 1(A). Thus $\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})=\partial({v}^{\downarrow{T}}\cup{u}^{\downarrow{T}})$. And the edges in $\partial({v}^{\downarrow{T}}\cup{u}^{\downarrow{T}})$ have exactly one end-point in the vertex set ${v}^{\downarrow{T}}\cup{u}^{\downarrow{T}}$. As per definition, $C({v}^{\downarrow{T}})=|\partial({v}^{\downarrow{T}})|$ and are the number of edges which have exactly one end point in the vertex set ${v}^{\downarrow{T}}$. Also, since ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\phi$, thus $C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$ is the number of edges which have one end point in ${{v}^{\downarrow{T}}}$ and other end point in ${u}^{\downarrow{T}}$. Thus the number of edges which have exactly one end point in ${v}^{\downarrow{T}}$ and not in ${u}^{\downarrow{T}}$ are $C({v}^{\downarrow{T}})-C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$. Similarly, the number of edges which have exactly one end point in ${u}^{\downarrow{T}}$ and not in ${v}^{\downarrow{T}}$ are $C({u}^{\downarrow{T}})-C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$. Adding these two, the total number of edges which have exactly one end point in either ${v}^{\downarrow{T}}$ or ${u}^{\downarrow{T}}$, but not both are $C({v}^{\downarrow{T}})+C({u}^{\downarrow{T}})-2C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$. Note that there is only one edge $e_{{T}}\left(v\right)$ connecting ${v}^{\downarrow{T}}$ to the tree $T$. Also, this is part of the cut. Similarly for $e_{{T}}\left(u\right)$.

For second case, when ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}\neq\phi$. Since, we have an underlying tree $T$ thus either $v\in{u}^{\downarrow{T}}$ or $u\in{v}^{\downarrow{T}}$. WLOG, let’s assume $u\in{v}^{\downarrow{T}}$ and hence ${u}^{\downarrow{T}}\subset{v}^{\downarrow{T}}$. Thus, we have, ${v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}}={v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}$ as given in fig. 1(B). Hence, the edges that are in the cut $\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})$ have exactly one end point in ${v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}$. Also, $C({v}^{\downarrow{T}},{u}^{\downarrow{T}})=|\partial({v}^{\downarrow{T}})\cap\partial({u}^{\downarrow{T}})|$ are the number edges which have one end point in ${u}^{\downarrow{T}}$ and other in the vertex set $V\setminus{v}^{\downarrow{T}}$ as shown by the arrow in fig. 1(B). Thus $C({v}^{\downarrow{T}})-C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$ is the number of edges with one end point in the vertex set ${v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}$ and other in the vertex set $V\setminus{v}^{\downarrow{T}}$. But the cut $\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})$ also have those edges which have one endpoint in the vertex set ${v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}$ and the other end point in the vertex set ${u}^{\downarrow{T}}$. And the total number of such edges is $C({u}^{\downarrow{T}})-C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$. Hence $|\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})|=C({v}^{\downarrow{T}})+C({u}^{\downarrow{T}})-2C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$. And lastly, similar to the previous case, no other tree edge apart from $\left\{e_{{T}}\left(v\right),e_{{T}}\left(u\right)\right\}$ has one end point in $V\setminus({v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}})$ and the other in ${v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}$. ∎

From Lemma 5.4 it is clear that for any spanning tree $T$ and for any nodes $v,u\in V\setminus T$ the cut $\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})$ shares only two tree edges $\left\{e_{{T}}\left(v\right),e_{{T}}\left(u\right)\right\}$. Hence if we know $|\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})|$ for all $v,u$ then we can find the size of all the cuts which 2-respects the tree $T$ and hence the minimum. In order to find $|\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})|$, for any two nodes $v,u$, we will first ensure that every node $v$ finds $C({v}^{\downarrow{T}})$. Further, for every node $u\in V\setminus{v}^{\downarrow{T}}$ we will make sure that node $v$ finds $C({u}^{\downarrow{T}})$ and $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$. Thus for every pair of tree edges $\left\{e_{{T}}\left(v\right),e_{{T}}\left(u\right)\right\}$, we have at least one node which can find $|\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})|$. For any rooted spanning tree $T$, let $\operatorname{children}_{{T}}\left(v\right)$ be children of node $v$ in $T$. The following simple observation will be handy in finding these information.

Observation 5.5**.**

For any rooted spanning tree $T$, we have

$\forall v\in V\setminus r_{T},\ C({v}^{\downarrow{T}})=\sum_{x\in{v}^{\downarrow{T}}}C(x,{v}^{\downarrow{T}})=C({v}^{\downarrow{T}},\left\{v\right\})+\sum_{c\in\operatorname{children}_{{T}}\left(v\right)}C({v}^{\downarrow{T}},{c}^{\downarrow{T}})$** 2. 2.

$\forall v\in V\setminus r_{T}$* and $u\in V\setminus{v}^{\downarrow{T}},\ C({v}^{\downarrow{T}},{u}^{\downarrow{T}})=\sum_{x\in{v}^{\downarrow{T}}}C(x,{u}^{\downarrow{T}})=C(\left\{v\right\},{u}^{\downarrow{T}})+\sum_{c\in\operatorname{children}_{{T}}\left(v\right)}C({c}^{\downarrow{T}},{u}^{\downarrow{T}})$ .*

Claim 5.6**.**

Let $T$ be a rooted spanning tree. Any node $u$ can locally find $C({v}^{\downarrow{T}},u)$ for all $v\in V\setminus{u}^{\downarrow}$, if the node $u$ knows the set ${\operatorname{anc}}_{T}\left(u\right)$ and ${\operatorname{anc}}_{T}\left(x\right)$ for each of its neighbors $x$.

Proof.

We claim that $u$ can compute $C({v}^{\downarrow{T}},u)$ using Algorithm 6. We will now prove its correctness. Recall that $C({v}^{\downarrow{T}},u)=|\partial({v}^{\downarrow{T}})\cap\partial(u)|$. For each node $v\notin{u}^{\downarrow{T}}$ that $u$ wants to compute $C({v}^{\downarrow{T}},u)$, there are two cases to consider.

Case 1: $v\notin\operatorname{anc}_{T}(u)$, i.e. $v$ is not an ancestor of $u$ (see fig. 1(A) for an illustration). Here we have

[TABLE]

Thus, the first line of Algorithm 6 computes $C({v}^{\downarrow{T}},u)$ correctly in this case.

Case 2: $v\in\operatorname{anc}_{T}(u)$, i.e. $v$ is an ancestor of $u$ (see fig. 1(B) for an illustration). We have

[TABLE]

Thus, the second line of Algorithm 6 computes $C({v}^{\downarrow{T}},u)$ correctly in this case. This completes the proof of Claim 5.6. ∎

Note that Lemmas 5.4, 5.5 and 5.6 hold for any spanning tree $T$. Now, we will give Claims 5.7, 5.8, 5.9 and 5.10 the purpose of which is to prove that every node $v$ can find $C({u}^{\downarrow{T}}),C({v}^{\downarrow{T}})$ and $C({v}^{\downarrow{T}},{u}^{\downarrow{T}})$ for all $u\in V\setminus{v}^{\downarrow{T}}$. These claims are an application of Lemma 5.3. They also use the characterization given in Observations 5.5 and 5.6.

Claim 5.7**.**

Given a rooted spanning tree $T$, in $O(Depth(T))$ rounds, every node $v$ can find ${\operatorname{anc}}_{T}\left(v\right)$ and also for all the non-tree neighbors $u$ of $v$, node $v$ can find ${\operatorname{anc}}_{T}\left(u\right)$.

Proof.

Firstly, in $O(Depth(T))$ rounds, each node $v$ can find ${\operatorname{anc}}_{T}\left(v\right)$ by Lemma 5.3(1). Now, for any node $u$, $|{\operatorname{anc}}_{T}\left(u\right)|\leq Depth(T)$ hence in $O(Depth(T))$ rounds any non-tree neighbor $v$ of $u$ can receive ${\operatorname{anc}}_{T}\left(u\right)$ ∎

Claim 5.8**.**

Let $T$ be a rooted spanning tree. In $O(Depth(T))$ rounds, every node $v\in V$ can find $C({v}^{\downarrow{T}})$.

Proof.

Let us fix a node $v$. As per Observation 5.5, we know that for any node $v$, $C({v}^{\downarrow{T}})=\sum_{x\in{v}^{\downarrow{T}}}C(\left\{x\right\},{v}^{\downarrow{T}})$. Based on Claim 5.6 and Claim 5.7, we know that, in $O(Depth(T))$ rounds, each node $x$ can find $C(x,{v}^{\downarrow{T}})$ for all the ancestors $v\in{\operatorname{anc}}_{T}\left(x\right)$. Hence computing $C({v}^{\downarrow{T}})$ takes $O(Depth(T))$ rounds by Lemma 5.3(2). ∎

Claim 5.9**.**

Let $T$ be a rooted spanning tree. In $O(n)$ rounds, every node $v\in V$ can find $C({u}^{\downarrow{T}})$ and $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ for all $u\in V\setminus{v}^{\downarrow{T}}$.

Proof.

Every node $v$ broadcasts $C({v}^{\downarrow{T}})$ computed from Claim 5.8. Since there are $O(n)$ many such messages, this can be done in $O(n+D)$ rounds.

Let us fix a node $u$, we will show that for all $v$ such that $u\in V\setminus{v}^{\downarrow{T}}$, node $v$ can find $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ in $O(Depth(T))$ rounds.

By Observation 5.5(2), we know that $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})=\sum_{x\in{v}^{\downarrow{T}}}C({u}^{\downarrow{T}},\left\{x\right\})$. Let choose an arbitrary $x\in{v}^{\downarrow{T}}$. Since $u\in V\setminus{v}^{\downarrow{T}}$ thus $u\in V\setminus{x}^{\downarrow{T}}$; this allows us to invoke Claim 5.6 and Claim 5.7 to make sure that each $x\in{v}^{\downarrow{T}}$ can find $C({u}^{\downarrow{T}},\left\{x\right\})$ in $O(Depth(T))$ rounds. Thus by Lemma 5.3(3), we can find $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ for all $u\in V\setminus{v}^{\downarrow{T}}$ in $O(Depth(T))$. There could be at most $n$ such nodes $u$. Thus every node $v\in V$ can find $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ for all $u\in V\setminus{v}^{\downarrow{T}}$ in $O(Depth(T)+n)$ rounds. ∎

Claim 5.10**.**

Let $T$ be a rooted spanning tree. In $O(n)$ rounds, for any two nodes $v,u\in V\setminus\left\{r_{T}\right\}$, one of $v$ or $u$ can find $|\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})|$.

Proof.

Firstly, for any two nodes $u$ and $v$, by Claim 5.9, in $O(n)$ rounds both of them know $C({v}^{\downarrow{T}})$ and $C({u}^{\downarrow{T}})$. In this proof we will show that at least one of $v$ or $u$ will be able to find $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ in $O(n)$ rounds using Claim 5.9. Thus the same node can also find $|\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})|$ by Lemma 5.4(1).

Here again we will consider the two cases illustrated in fig. 1 that is either ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\emptyset$ or ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}\neq\emptyset$. Firstly, lets consider ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\emptyset$. In this case, $u\in V\setminus{v}^{\downarrow{T}}$ and $v\in V\setminus{u}^{\downarrow{T}}$, thus both of them know $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$ by Claim 5.9. Secondly, when ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}\neq\emptyset$, here WLOG consider that $v\in{u}^{\downarrow{T}}$. Hence, $u\in V\setminus{v}^{\downarrow{T}}$. Again from Claim 5.9, node $v$ can find $C({u}^{\downarrow{T}},{v}^{\downarrow{T}})$. ∎

From Claims 5.7, 5.8, 5.9 and 5.10 we get the following lemma.

Lemma 5.11**.**

Let $u,v\in V$ be two nodes, let $T$ be any spanning tree $G$, if any node $x\in V$ knows $\operatorname{anc}_{T}(x)$ and $\operatorname{anc}_{T}(y)$ then it can find the edges incident to it which are part of the cut $\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})$ in $O(D)$ rounds.

Proof.

Some leader node $z$ broadcasts a message to every node to find the edges incident to them which are part of the cut $\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})$. Node $u,v$ also receives such a message. On receiving such a message, node $v$ broadcast to all the nodes if $u$ is in $\operatorname{anc}_{T}(v)$ set. Similarly, $u$ broadcasts if $v$ is in $\operatorname{anc}_{T}(u)$. We consider two cases illustrated in fig. 1. Firstly let ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}=\emptyset$. Here the cut is given by $({v}^{\downarrow{T}}\cup{u}^{\downarrow{T}},V\setminus{v}^{\downarrow{T}}\cup{u}^{\downarrow{T}})$. Here both $u$ and $v$ broadcasts that the other node is not in its ancestor set. For any two nodes $x,y$ such that $(x,y)\in E$, then the edge $(x,y)\in\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})$ iff one of $u$ or $v$ is an ancestor of $x$ and not of $y$ or vice versa. This can be determined by both $x,y$ using $\operatorname{anc}_{T}(x)$ and $\operatorname{anc}_{T}(y)$.

In the second case when ${v}^{\downarrow{T}}\cap{u}^{\downarrow{T}}\neq\emptyset$, then WLOG let ${u}^{\downarrow{T}}\subset{v}^{\downarrow{T}}$. Here node $u$ broadcasts that $v$ is in $\operatorname{anc}_{T}(u)$. And $v$ broadcasts that $u$ is not in $\operatorname{anc}_{T}(v)$. The cut, in this case, is given by $({v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}},V\setminus({v}^{\downarrow{T}}\setminus{u}^{\downarrow{T}}))$. For any two nodes $x,y$ such that $(x,y)\in E$, then the edge $(x,y)\in\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})$ iff exactly one of $x$ or $y$ has $v$ in its ancestor set and not $u$. This also be determined by both $x,y$ using $\operatorname{anc}_{T}(x)$ and $\operatorname{anc}_{T}(y)$. ∎

Proof of Theorem 5.1.

Firstly, from Lemma 5.2 we can find a set of spanning trees $\mathcal{T}$ of size $O(\log^{2.2}n)$ such that at least one of them 2-respects a min-cut. Having received a set of spanning trees, our task is to find the size of minimum cut in each one of them which shares at most two edges with the tree. Let us fix a tree $T$ in the set of spanning trees $\mathcal{T}$. Our goal is to find the size of the minimum cut which shares two edges with the tree $T$. Firstly, by Lemma 5.4(2), we know that for any two nodes $u,v\in V\setminus\left\{r_{T}\right\}$, $E[T]\cap\partial({v}^{\downarrow{T}}\oplus{u}^{\downarrow{T}})=\left\{e_{{T}}\left(v\right),e_{{T}}\left(u\right)\right\}$. Hence the value of the minimum cut which 2-respects the tree $T$ is $\min_{\forall u,v}|\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})|$. From Claim 5.10, for a fixed rooted spanning tree $T$, in $O(n)$ rounds for any two nodes $u,v$ at least one of them know $|\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})|$. Hence, $\min_{\forall u,v}|\partial({u}^{\downarrow{T}}\oplus{v}^{\downarrow{T}})|$ can be found in $O(D)$ rounds. We do this across all the trees. Thus we can find the size of the minimum among all cuts which 2-respects the trees in the set $\mathcal{T}$ in $O(n\log^{2.2}n)$ rounds. Also, by Lemma 5.11, all the edges incident to any node $x$ in this min-cut can be found locally by node $x$. ∎

5.2 Min-Cut of the Contracted Graph from Theorem 4.2

In this section, our goal is to find the min-cut in the contracted graph $\overline{G}=\operatorname{MSGC}(G,\epsilon)$ given by Theorem 4.2. We will follow the same idea as in the previous subsection; that is use Lemma 5.2 to find a set of spanning trees such that a min-cut shares only two edges in one of them. Further we will give a lemma similar to Lemma 5.3 for contracted graph $\overline{G}$ and spanning trees $\overline{T}$.

Theorem 5.12**.**

For any $\epsilon\in(0,\frac{1}{2})$ such that $\delta=n^{2\epsilon}$, let $\overline{G}=\operatorname{MSGC}(G,\epsilon)$ as given by Theorem 4.2. Then w.h.p. $\tilde{O}(D+{n}^{1-\epsilon/22})$ rounds (i) every node knows the edge connectivity $\lambda$ of $\overline{G}$, and (ii) there is a cut $C$ of size $\lambda$ such that every node knows which of its incident edges are in $C$.

Let $\overline{V}$ be the vertex set in this contracted graph $\overline{G}$ and $\overline{E}$ be the remaining edge set after contraction. Below we give a lemma similar to Lemma 5.2 which gives us a set of spanning tree for the graph $\overline{G}$.

Lemma 5.13**.**

Given a contracted graph $\overline{G}$, in total of $\tilde{O}(\sqrt{n}+D)$ rounds, we can find a set of spanning trees $\overline{\mathcal{T}}=\left\{\overline{T}_{1},\ldots,\overline{T}_{{\Theta}(\log^{2.2}n)}\right\}$ such that w.h.p there exists at least one spanning tree $\overline{T}\in\overline{\mathcal{T}}$, which 2-respects a min-cut of $\overline{G}$.

Proof.

The proof follows from Lemma 5.2 where we constructed $O(\log^{2.2}n)$ MSTs. Here we are only left to show, how an MST can be constructed in the contracted graph. Recall that by Theorem 4.2, each vertex $v$ knows if it is in $\operatorname{Core}(C)$ of some cluster $C\in\mathcal{C}$ of $\operatorname{MSGC}(G,\epsilon)$. In $O(1)$ rounds, it can find all its neighbours $u$ which are in the same core by finding their ${groupId}(u)$. The weights of edges going between vertices of same core are locally set to $\infty$. And then to construct the tree packing, we just require to construct $\Theta(\log^{2.2}n)$ MSTs. This takes $\tilde{O}(\sqrt{n}+D)$ rounds. ∎

Having received the set of spanning trees, we explain how to find atomic values similar to Claim 5.9. One of the key difference here in comparison to the previous section is the depth of any tree $\overline{T}\in\overline{\mathcal{T}}$. The depth of any such tree w.r.t the contracted graph $\overline{G}$ is $n^{1-\frac{\epsilon}{22}}$. But for computing the properties (here the size of all induced cuts which share two tree edges) in $O(n^{1-\frac{\epsilon}{22}})$ rounds, we would require the depth to be $O(n^{1-\frac{\epsilon}{22}})$ when the tree is considered w.r.t. the original graph $G$. Here, we map all $T\in\overline{T}$ to a spanning tree of $\overline{G}$, this will enable for efficiently calculating the properties which involve the whole graph.

A trivial mapping for any spanning tree $\overline{T}$ of $\overline{G}$ to a spanning tree $T$ of $G$ would be to construct a smallest depth sub-tree in each of the induced subgraph of a core of a cluster. But unfortunately, this does not work because the guarantees we have from Theorem 4.2 are in terms of the diamater of the clusters and not specifically about the core which might be linear in $n$, even worse, the subgraph induced by core of a cluster may not even be a connected component. Thus, here instead of constructing a BFS tree in each subgraph induced by the core of a cluster, we will construct BFS tree in the subgraph induced by the whole cluster. We define this mapping more precisely as below.

Let $\overline{T}$ be a rooted spanning tree of $\overline{G}$. Let $C$ be a non-trivial cluster of $\overline{G}$ such that $C=S\cup R$, where $S=\operatorname{Core}(C)$ is the set of vertices corresponding to core and $R=\operatorname{Regular}(C)$ is the set of regular nodes of cluster $C$. Let $s(C)$ be a vertex of $\overline{G}$ formed by collapsing vertices in $\operatorname{Core}(C)$.

Now, for every spanning tree $\overline{T}$ of $\overline{G}$, we will define a way to construct a BFS tree in each cluster. For every cluster $C$, we assign a leader node $L_{\overline{T}}(C)$. If for some cluster $C$, $s(C)$ is a root of $\overline{T}$ then define $L_{\overline{T}}(C)$ as any arbitrary node from $\operatorname{Core}(C)$. Otherwise, if $s(C)$ is any other node of $\overline{T}$ then define $L_{\overline{T}}(C)$ as a node $r_{C}\in\operatorname{Core}(C)$ such that $(r_{C},\pi_{{\overline{T}}}\left(s(C)\right))$ is a tree edge in $\overline{T}$. Note that there will be an unique $r_{C}$ beecause $s(C)$ has only one parent in the spanning tree $\overline{T}$. Further, define $\overline{T}[C]$ as a BFS tree in the induced subgraph $G[C]$ rooted at $\pi_{{\overline{T}}}\left(r_{C}\right)$. Now, define the mapping as a multi-set of edges which is the union of these constructed BFS tree edges, preserving the multiplicity:

[TABLE]

We give the properties of the $\operatorname{\texttt{mapping}}$ in the following lemma.

Lemma 5.14**.**

Let $\overline{T}$ be a rooted spanning tree of $\overline{G}=\operatorname{MSGC}(G,\epsilon)$ received from Theorem 4.2. Then $\operatorname{mapping}(\overline{T},\overline{G})$ has the following properties

If every node $s$ of $\overline{G}$ (a core node or regular node) has a message $\texttt{msg}_{s}$ to be sent to each and every node in ${s}^{\downarrow{\overline{T}}}$, then to deliver all such messages it takes $O({n}^{1-\frac{\epsilon}{22}})$ rounds. 2. 2.

Let $f:\overline{V}\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ and $g:\overline{V}^{2}\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ be some functions. Let $f(s)=\sum_{x\in{s}^{\downarrow{\overline{T}}}}g(s,x)$ and $g(s,x)$ is precomputed by every node $x$ for all $s\in\operatorname{anc}_{\overline{T}}(x)$. Then in $O(n^{1-\frac{\epsilon}{22}})$ rounds $f$ can be computed by all nodes $s$. 3. 3.

Let $f,g:\overline{V}\rightarrow\left\{0,1,\ldots,\mbox{\rm poly}(n)\right\}$ be some functions. For every node $s$ of $\overline{G}$, let $f(s)=g(s)+\sum_{c\in\operatorname{children}_{{\overline{T}}}\left(s\right)}f(c)$. If $g(s)$ is precomputed by every node $s$, then $f$ can be computed in $O(n^{1-\frac{\epsilon}{22}})$ rounds by every node $s$ of $\overline{G}$. Further, if we have $k$ such functions then every node $s$ of $\overline{G}$ can compute them in $O(n^{1-\frac{\epsilon}{22}}+k)$.

The proof of Lemma 5.14 is similar to Lemma 5.3 and is given in appendix B. Here we use the $\operatorname{\texttt{mapping}}(\overline{T},\overline{G})$ for message passing. The key idea behind this is the fact that there is a path between any two nodes in $G$ of size $O(n^{1-\frac{\epsilon}{22}})$ using the edges of $\operatorname{\texttt{mapping}}(\overline{T},\overline{G})$ and each edge is repeated at most twice in the $\operatorname{\texttt{mapping}}(\overline{T},\overline{G})$ contributed by either one of the BFS tree $\overline{T}[C]$ for some cluster $C$ or by $\overline{T}$ or by both.

Recall that Claims 5.7, 5.8, 5.9 and 5.10 were application of Lemma 5.3 coupled with Observations 5.5 and 5.6. Since, Observations 5.5 and 5.6 depend only on hierarchy of nodes established by a spanning tree thus these will be applicable for $\overline{T}$ and $\overline{G}$ as well. Similar to Lemma 5.3, for $\overline{G}$ and $\overline{T}$, we have Lemma 5.14. Thus, Claims 5.7, 5.8, 5.9 and 5.10 can be proved for $\overline{T}$ and $\overline{G}$ as well. This will imply that for any spanning tree $\overline{T}$ and any two vertices $r$ and $s$ of $\overline{G}$ at least one of them can find $C({r}^{\downarrow{\overline{T}}}),C({s}^{\downarrow{\overline{T}}})$ and $C({r}^{\downarrow{\overline{T}}},{s}^{\downarrow{\overline{T}}})$. Hence, using Lemma 5.13 we can prove Theorem 5.12 similar to Theorem 5.1.

6 Putting Everything Together

Here, we prove Theorem 1.1. Let $\delta=n^{2\epsilon}$ for some $\epsilon\in(0,\frac{1}{2})$. We use a combination of Theorems 4.2 and 5.12 which allows us to find the min-cut of $G$ w.h.p., as required by Theorem 1.1 in $\tilde{O}(D+n^{1-\epsilon/44})$ rounds. Call this algorithm $\mathcal{A}$. Also, by Theorem 2.1, we know that min-cut can be found in $\tilde{O}((\sqrt{n}+D)\lambda^{4})$ rounds. We use a combination of both these algorithms. Firstly, it is a well know fact that the approximate diameter $D^{\prime}$ can be estimated in $O(D)$ rounds in $\mathsf{CONGEST}$ model such that $D\leq D^{\prime}\leq 2D$. If $D$ is linear in $n$, then we cannot do much and to find the min-cut we require $\tilde{O}(n)$ rounds for instance by using Theorem 5.1. Suppose that for some $\mu$, $D^{\prime}\leq n^{1-\mu}$.

Using the above mentioned parameter, the runtime of Theorem 2.1 is $\tilde{O}((\sqrt{n}+n^{1-\mu})n^{8\epsilon})=\tilde{O}(n^{\frac{1}{2}+8\epsilon}+n^{1-\mu+8\epsilon})$ and the runtime of Algorithm $\mathcal{A}$ is $\tilde{O}(n^{1-\mu}+n^{1-\epsilon/44})$. Firstly, note that both $\mu$ and $\epsilon$ can be determined using a distributed algorithm in $O(D)$ rounds. The runtime of Theorem 2.1 has two components $n^{\frac{1}{2}+8\epsilon}$ and $n^{1-\mu+8\epsilon}$ such that when $\mu>1/2$ the former dominates and when $\mu<1/2$ then the later. When $\mu>\frac{1}{2}$, then from runtime complexity of both the algorithms, the first term dominates and the break-point on deciding which among the two algorithms occurs at $\epsilon=\frac{22}{353}$, which leads to $n^{1-\frac{1}{706}}$ contribution from this part. When $\mu\leq\frac{1}{2}$, in this case, in both Algorithm $\mathcal{A}$ and [NS14] the first term dominates. The break-point on deciding which among the two algorithms should occurs at $\epsilon=\frac{44\mu}{353}$. Thus this part gives contributes $n^{1-\frac{1}{353}}D^{\frac{1}{353}}$ to the running time. Combining these two, the runtime complexity of our algorithm is $O(n^{1-\frac{1}{706}}+n^{1-\frac{1}{353}}D^{\frac{1}{353}})$.

7 Open Problems

An obvious open problem from our work is whether there are sublinear time distributed algorithms for computing the minimum cut for multi-graphs, where parallel edges allow more communication per round, and ultimately for weighted graph, where edge weights do not affect communication. Recall that we showed an $\tilde{O}(n)$ bound for these problems in Section 5.1. Note that the same questions are open for centralized deterministic algorithms, where we borrow some techniques from [KT15]. Understanding these questions in one setting might shed some light on the other.

To answer the above, it might help to understand the two-party communication complexity of the following minimum cut problem: Nodes of a graph $G=(V,E)$ are partition into two sets, denoted by $V_{A}$ and $V_{B}$. Let $C=E(V_{A},V_{B})$. There are two players, Alice and Bob, who know the information about all edges incident to $V_{A}$ and $V_{B}$, respectively. Can Alice and Bob compute the value of the minimum cut of $G$ by communicating $\tilde{O}(n^{1-\epsilon}|C|)$ bits? A negative answer to this question would imply a lower bound in the CONGEST model by a standard technique (e.g. [FHW12, ACK16, CKP17a, Nan14]). A positive answer would rule out pretty much the only known technique to prove lower bounds and might lead to a fast algorithm in the CONGEST model, as happened for all-pairs shortest paths [CKP17a, BN19].

It is also very interesting to show tight bounds for computing the minimum cut on unweighted simple graphs. Since we already achieve sublinear time, past experiences from approximation distributed algorithms suggest that this might be $\tilde{\Theta}(\sqrt{n}+D)$. An $\tilde{O}(\sqrt{n}\mbox{\rm poly}(D))$-time algorithm would be a big step towards this bound. Ruling out such algorithm should be very interesting, since it should imply a bound between $\tilde{O}(\sqrt{n}+D)$ and $\tilde{O}(n)$.

A special case that deserves attention is when the graph connectivity is small. For example, is there an algorithm that can check whether an unweighted network has connectivity at most $k$ in $\mbox{\rm poly}(k,D,\log(n))$ time? A less ambitious goal that is already interesting is to get a $f(k)\mbox{\rm poly}(D,\log(n))$-time algorithm, for some function $f$ that is independent of $D$ and $n$ (an algorithm “parameterized by $k$”). Bounds in these forms are currently known only for $k\leq 2$ [PT11].777Update: We recently learned that such bound can be essentially extended to $k=O(1)$ in the sense that there is a $\mbox{\rm poly}(D)$-time algorithm [Par19]. We thank Merav Parter for this information.

As noted earlier, this paper is part of an effort to understand exact distributed graph algorithms. So far, not many problems admit tight bounds when it comes to exact solutions. (Minimum spanning tree [GKP98, KP98] and all-pairs shortest paths [BN19] are among a few that we are aware of.) Many problems are yet to be explored, e.g. single-source shortest paths [FN18], maximum weight/cardinality matching [AKO18], st-cut/flow [GKK*+*15], vertex connectivity [CGK14], densest subgraph [DLNT12], and betweenness and closeness centralities [HPD*+*19].

A more general question that was raised recently [CKP17a] is to classify complexities of global problems in the CONGEST model. Tight bounds witnessed so far are in the form of either $\tilde{\Theta}(D)$, $\tilde{\Theta}(\sqrt{n}+D)$, $\tilde{\Theta}(n)$, or $\tilde{\Theta}(n^{2})$. Are there (preferably natural) graph problems with complexity in-between (e.g. $\tilde{\Theta}(n^{1/2+\epsilon}+D)$ or $\tilde{\Theta}(n^{1+\epsilon})$ for some constant $\epsilon>0$)? A bound in the form $\tilde{\Theta}(n^{1/2}D^{\epsilon}+D)$ will be also interesting, and we suspect that it might be achievable when the two-party communication rounds are considered (as in [EKNP14]).

Acknowledgement

This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme under grant agreement No 715672. Daga, Nanongkai, and Saranurak were also supported by the Swedish Research Council (Reg. No. 2015-04659). The research leading to these results has received funding from the European Research Council under the European Union’s Seventh Framework Programme (FP/2007-2013) / ERC Grant Agreement no. 340506.

Appendix A Proof of Theorem 3.2

Firstly, we state a known fact about the number of cuts of a particular size

Lemma A.1** ([Kar00] Theorem 3.2).**

Let $G$ be any unweighted and undirected graph. Let $\lambda$ be the size of the minimum cut. Then for any constant $\alpha\geq 1$, the number of cuts in $G$ which are of the size at most $\alpha\lambda$ is ${n^{\lceil 2\alpha\rceil}}$

Proof of Theorem 3.2.

Let $\alpha\geq 1$ and let us fix an arbitrary cut $C$ of size at most $\alpha k\leq\alpha\lambda$. Using Lemma A.1 we know that the number of such cuts is $n^{\lceil 2\alpha\rceil}$ Then using Chernoff bound we have

[TABLE]

For the last equality in the above equation, we choose $p=3\tau\frac{\ln n}{\epsilon^{2}k}=\theta(\frac{\ln n}{\epsilon^{2}k})$. Also from Lemma A.1, we know that the number of such cuts is $n^{2\alpha}$. Thus by union bound we have

[TABLE]

Further, the minimum value of $k$ could be $1$ and the size of any cut is at most $n^{2}$. Thus we have at most $n^{2}$ values of $\alpha$. Hence using the union bound again eq. 7 for all values of alpha we have

[TABLE]

Thus by choosing $\tau\geq 3$ this would imply that w.h.p edges sampled from all the cuts $C$ are less than $(1+\epsilon)p|C|$ ∎

Appendix B Omitted proofs from section 5

B.1 Proof of Lemma 5.13

Firstly, in this section we prove Lemma 5.2. To prove this we review the greedy tree packing as given in [Tho07] and mentioned earlier in [PST95, You95, TK00].

Definition B.1**.**

For any set of spanning tree $\mathcal{T}$, let the load of an edge $e$ be defined as $L^{\mathcal{T}}(e)=|\left\{T\mid e\in T\right\}|$. A set of spanning tree $\mathcal{T}=\left\{T_{1},T_{2},\ldots,T_{k}\right\}$ is a greedy tree packing if each $T_{i}$ is a minimum spanning tree with respect to the load on each edge given by $L^{\mathcal{T}_{i-1}}(e)$ where $\mathcal{T}_{i-1}=\left\{T_{1},T_{2},\ldots,T_{i-1}\right\}$.

We now state known results about tree packing

Lemma B.2** ([Tho07]Lemma 6).**

Let $C$ be any cut with $<1.1\lambda$ edges and let $\mathcal{T}$ be a greedy tree packing with $\omega(\lambda\ln m)$ trees. Then a fraction $1/3$ of the trees in $\mathcal{T}$ cross $C$ at most twice.

In the above lemma we are required to construct $\omega(\lambda\ln m)$, which could be linear in $n$. This is too large for our purpose. Thus we use the sampling idea from [Kar99] which will reduce the size of min-cut to $\omega(\ln m)$

Lemma B.3**.**

Let $p$ be a probability and $H=G_{p}$ be a random subgraph of $G$ including each edge independently with probability $p$. Let $\lambda_{H}$ be the edge connectivity of $H$. Suppose $p\lambda=\omega(\log n)$. Then, w.h.p., $\lambda_{H}=(1\pm o(1))p\lambda$. Moreover, w.h.p., min-cuts of $G$ are near-minimal in H and vice versa. More precisely, a min-cut $C$ of $G$ has $(1+o(1))\lambda_{H}$ cross edges in $H$. Conversely, a min-cut $C_{H}$ of $H$ has $(1+o(1))\lambda$ cross edges in $G$.

Using the above we can prove Lemma 5.2. This is similar to proof of [Tho07, Lemma 8].

Proof of Lemma 5.2.

We need to prove that w.h.p., we can construct a set of spanning trees such that at least one of them 2-respects a min-cut. At the beginning, we do not know $\lambda$, but we know that for some $i$, $\lambda/2^{i}=\Theta(\log^{1.1}n)$. We choose this value of $i$. Let $p=\frac{1}{2^{i}}$. Let $H=G_{p}$ as given by Lemma B.3. By the same lemma, we know that the edge connectivity $\lambda_{H}$ of $H$ is $\Theta(\log^{1.1}n)$. Thus $H$ has at least $\Theta(\log^{1.1}n)$ spanning forests. We also have that any min-cut $C$ of G has $(1+o(1))\lambda_{H}$ edges. Thus by Lemma B.2, a tree packing $\mathcal{T}$ of $H$ with $O(\log^{2.2}n)$ trees has a tree $T$ which crosses the min-cut at most twice. To construct a MST in $\mathsf{CONGEST}$ model we require $\tilde{O}(\sqrt{n}+D)$ rounds. Thus this lemma follows. ∎

B.2 Proof of Lemma 5.3 and Lemma 5.14

Lemma 5.3 gives known algorithms in $\mathsf{CONGEST}$ model. Lemma 5.3(1) is a simple downcast with pipelined messages.

Proof of Lemma 5.3(1).

Here each node $v$ has at most $Depth(T)$ ancestors. Thus it receives at most $Depth(T)$ messages. The idea here is to perform a message passing from top to bottom in a pipelined fashion. At round $t=0$, the root $r_{T}$ sends its messages to all its children which immediately send to their children. Subsequently, any internal node $v$ of the tree which receives some msg from $\pi_{{T}}\left(v\right)$ in round $t$ immediately sends msg to all its children in round $t+1$. At round $t=1$ nodes at level $1$ (distance $1$ from root $r_{T}$) release there messages. At any round $t=t^{\prime}\leq Depth(T)$, nodes at level $t^{\prime}$ release there message. Thus in $O(Depth(T))$ rounds all nodes $v$ receive messages $\texttt{msg}_{a}$ from all $a\in\operatorname{anc}_{T}(v)$. ∎

Let $\texttt{level}_{T}\left(v\right)$ of any node $v$ be the distance from the root $r_{T}$ following the tree edges. For Lemma 5.3(2), we give a distributed-two phased procedure in algorithm 7.

Proof of Lemma 5.3(2).

For any node $v$, $f(v)$ depends on the value $g(v,x)$ for all $x\in{v}^{\downarrow{T}}$, thus each such node $x$ convergecasts (see [Pel00, Chapter 3]) the required information up the tree which is supported by aggregation of the values. We will give an algorithmic proof for this lemma. The algorithm to efficiently compute function $f(\cdot)$ is given in algorithm 7.

The aggregation phase of the algorithm given in Phase 1 runs for at most $Depth(T)$ rounds and facilitates a coordinated aggregation of the required values and convergecasts them in a synchronized fashion. Each node $x$ in Phase 2, sends $\texttt{level}_{T}\left(x\right)$ messages of size $O(\log n)$ to its parent, each message include $g(v,{x^{\downarrow T}})$ where $v\in{\operatorname{anc}}_{T}\left(x\right)$; which as defined earlier is the contribution of nodes in $x^{\downarrow T}$ to $f(v)$. This message passing takes $O(1)$ time since $1\leq g(v,{x^{\downarrow T}})\leq\mbox{\rm poly}(n)$ is of size $O(\log n)$ bits. For brevity, we assume this takes exactly $1$ round, this enables us to talk about each round more appropriately as follows: Any node $x$ at level $\texttt{level}_{T}\left(x\right)$ waits for round $t=1$ to $Depth(T)-\texttt{level}_{T}\left(x\right)$. For any $l\in[0,\texttt{level}_{T}\left(x\right)-1]$, in round $t=Depth(T)-\texttt{level}_{T}\left(a\right)+l+1$ node $x$ sends to its parent $\langle{l,g(v,{x^{\downarrow T}})}\rangle$ where $v$ is the ancestor of $x$ at level $l$. When node $x$ is an internal node then, $g(v,{x}^{\downarrow{T}})$ depends on $g(v,x)$ which can be pre-calculated. Also, $g(v,{x^{\downarrow T}})$ depends on $g(v,{c}^{\downarrow{T}})$ for all $c\in\operatorname{children}_{{T}}\left(x\right)$ which are at level $\texttt{level}_{T}\left(x\right)+1$ and have send to $x$ (which is their parent) the message $\langle{l,g(v,{c}^{\downarrow{T}})}\rangle$ in the $(Depth(T)-\texttt{level}_{T}\left(x\right)+l)^{\text{th}}$ round. For a leaf node $x$, $g(v,{x^{\downarrow T}})=g(v,x)$ which again is covered in pre-processing step.

In Phase 2, node $v$ computes function $f(v)$. As per definition of $f$ each internal node $v$ requires $g(v,{{c}^{\downarrow{T}}})\ \forall c\in\operatorname{children}_{{T}}\left(v\right)$ and $g(v.v)$ is computed in the pre-processing step. And $g(v,{{c}^{\downarrow{T}}})$ is received by $v$ in the aggregation phase. When node $v$ is a leaf node, $f(v)$ depends only on $g(v,v)$ since ${v}^{\downarrow{T}}=\left\{v\right\}$. ∎

For Lemma 5.3(3), we use similar technique as Proof of Lemma 5.3(1). But instead of sending a train of messages towards the leaf nodes, we send a train of messages towards the root in a synchronized fashion.

Proof of Lemma 5.3(3).

Here we are given that $f(v)=g(v)+\sum_{c\in\operatorname{children}_{{T}}\left(v\right)}f(c)$. We know that $1\leq f(v)\leq\mbox{\rm poly}(n)$. Thus, for any node $v$ to send $f(v)$ from one node to another through a physical link it takes $O(1)$ rounds. For brevity let’s assume that this takes exactly $1$ round. For this lemma, if we can show that any node $x$ at level $\texttt{level}_{T}\left(x\right)=t$ computes $f(x)$ and sends it to $\pi_{{T}}\left(x\right)$ in round $Depth(T)-\texttt{level}_{T}\left(x\right)$, then $f(v)$ can be computed by each node $v$ in $O(Depth(T))$ rounds. For the base case, at round $t=0$, leaf nodes $x$ such that $\texttt{level}_{T}\left(x\right)=Depth(T)$ send $f(x)=g(x)$ (pre computed by $x$) to $\pi_{{T}}\left(x\right)$. Fix a $t\leq Depth(T)$, assume that all node $x$ at level $\texttt{level}_{T}\left(x\right)=t$ computes $f(x)$ and sends it to $\pi_{{T}}\left(x\right)$ in round $Depth(T)-\texttt{level}_{T}\left(x\right)$. Now using this information nodes $x$ at $\texttt{level}_{T}\left(x\right)=t+1$ can compute $f(x)$ and send it to $\pi_{{T}}\left(x\right)$. If $x$ is a leaf node then it has the precomputed value of $f(x)=g(x)$. Otherwise it uses $f(x)=g(x)+\sum_{c\in\operatorname{children}_{{T}}\left(x\right)}f(c)$. Recall that by induction hypothesis all children $c$ of $x$ have sent $f(c)$ to $x$ in round $Depth(T)-\texttt{level}_{T}\left(c\right)=Depth(T)-\texttt{level}_{T}\left(x\right)-1$. Thus $f(x)$ can be sent to $\pi_{{T}}\left(x\right)$ in round $Depth(T)-\texttt{level}_{T}\left(x\right)$.

Further, if we have $k$ such functions $f_{1},\ldots,f_{k}$, then we can use a train of $k$ messages sent by each node $x$ with the values of $f_{1}(x),\ldots,f_{k}(x)$ to $\pi_{{T}}\left(x\right)$ ∎

Proof of Lemma 5.14

The proof of Lemma 5.14 is similar to Lemma 5.3. In a general physical network $G$, for any spanning tree $T$ in $O(1)$ round a node $v$ can send a message of $O(\log n)$ bits to $\pi_{{T}}\left(x\right)$ or to all child nodes $c$ in $\operatorname{children}_{{T}}\left(v\right)$. But for a contracted graph $\overline{G}=\operatorname{MSGC}(G,\epsilon)$ and a spanning tree $\overline{T}$ of $\overline{G}$, a node $s$ of $\overline{G}$ can not send a message of $\log n$ bits to $\pi_{{\overline{T}}}\left(s\right)$ or to all child nodes $c$ in $\operatorname{children}_{{\overline{T}}}\left(s\right)$ in $O(1)$ rounds because some of these nodes are a set of nodes in the original network $G$ and, thus, are not immediate neighbors of s in G. But due to condition of low diameter Theorem 4.2, we can show that in total for computation of any of the functions described Lemma 5.14 we just pay an over head of $O(n^{1-\frac{\epsilon}{22}})$ rounds. Firstly, we prove some properties of $\operatorname{\texttt{mapping}}(\overline{G},\overline{T})$.

Recall that the nodes of $\overline{G}$ are either physical nodes or formed by collapsing $\operatorname{Core}(C)$ of some cluster $C$. Also recall, that in each $\operatorname{Core}(C)$, we have chosen $r_{C}$ which is the root of the BFS tree $\overline{T}[C]$.

Claim B.4**.**

Any node $v$ of the contracted graph $\overline{G}$, has a path of length $O(n^{1-\frac{\epsilon}{22}})$ to all nodes $a\in\operatorname{anc}_{\overline{T}}(v)$ using the edges of $\operatorname{mapping}({\overline{G}},{\overline{T}})$. In case $a$ is a vertex formed by collapsing $\operatorname{Core}(C)$ of a cluster $C$ then there is a path from $v$ to $r_{C}$ of length $O(n^{1-\frac{\epsilon}{22}})$.

Proof.

Let $\mathcal{C}$ be the cluster set of $\overline{G}$. Recall that in $\overline{G}$ there are $\Theta(n^{1-\frac{\epsilon}{22}})$ nodes. Thus, any spanning tree $\overline{T}$ of $\overline{G}$ has depth $O(n^{1-\eta_{1}})$. Let $v$ be any node. Lets fix an arbitrary $a\in\operatorname{anc}_{\overline{T}}(v)$. Following the tree edges of $\overline{T}$ we have a path of length $O(n^{1-\eta_{1}})$ between $a$ and $v$. But this is in the contracted graph $\overline{G}$ and not in the given physical graph $G$. The difference here is that, some of the nodes on this path are formed by collapsing $\operatorname{Core}(C)$ of some cluster $C\in\mathcal{C}$. Thus to traverse through such nodes the path uses the BFS tree $\overline{T}[C]$ which is part of $\operatorname{\texttt{mapping}}(\overline{G},\overline{T})$. As per Definition 4.1(4) we know that $\sum_{c\in\mathcal{C}}diam(G[C])=O(n^{1-\frac{\epsilon}{20}})$ . Hence, $\sum_{c\in\mathcal{C}}Depth(\overline{T}[C])=O(n^{1-\frac{\epsilon}{22}})$. ∎

The proof Lemma 5.14 uses Claim B.4.

Proof of Lemma 5.14.

Let $C\in\mathcal{C}$ be some cluster. Recall that $s(C)$ is a node formed by collapsing $\operatorname{Core}(C)$. Any node $x\in C\setminus\operatorname{Core}(C)$ may have some incident edges which are part of both $\overline{T}[C]$ and $\overline{T}$ at the same time. In any given round, these edges will be tasked to carry a message of two forms by node $x$: messages sent from children of $s(C)$ in $\overline{T}$ to $s(C)$ or messages sent from $x$ to $\pi_{{\overline{T}}}\left(x\right)$. Thus we include an extra label to the message to indicate which one of the two cases it belongs to so that it can be routed appropriately either using the edges of $\overline{T}$ or by $\overline{T}[C]$. This will increase the complexity by a factor of $2$. Hence using the same arguments in proof of Lemma 5.3 and Claim B.4 this lemma follows. ∎

Appendix C Proof of Theorem 4.4

Disclaimer

: This section is taken almost as is from [CPZ18] except for a few changes of parameters to suit our need. It is included only for the sake of verification.

We first introduce some notation. Let $\deg_{H}(v)$ be the degree of $v$ in the subgraph $H$, or in the graph induced by edge/vertex set $H$. Let $V(E^{\ast})$ be the set of vertices induced by the edge set $E^{\ast}\subseteq E$. The strong diameter of a subgraph $H$ of $G$ is defined as $\max_{u,v\in H}{\operatorname{dist}}_{H}(u,v)$ and the weak diameter of $H$ is $\max_{u,v\in H}{\operatorname{dist}}_{G}(u,v)$.

The goal of this is to prove Theorem 4.4. The algorithm for Theorem 4.4 is based on repeated application of a black box algorithm $\mathcal{A}^{\ast}$, which is given a subgraph $G^{\prime}=(V^{\prime},E^{\prime})$ of the original graph $G=(V,E)$, where $V^{\prime}=V(E^{\prime})$, $n^{\prime}=|V^{\prime}|$, and $m^{\prime}=|E^{\prime}|$. In $\mathcal{A}^{\ast}$, vertices may halt the algorithm at different times.

Specification of the Black Box.

The goal of $\mathcal{A}^{\ast}$ is, given $G^{\prime}=(V^{\prime},E^{\prime})$, to partition $E^{\prime}$ into $E^{\prime}=E_{h}^{\prime}\cup E_{s}^{\prime}\cup E_{r}^{\prime}$ satisfying some conditions. The edge set $E_{h}^{\prime}$ is partitioned into $E_{h}^{\prime}=\bigcup_{i=1}^{t}\mathcal{E}_{i}$. We write $\mathcal{V}_{i}=V(\mathcal{E}_{i})$ and $\mathcal{G}_{i}=(\mathcal{V}_{i},\mathcal{E}_{i})$, and define $S=V^{\prime}\setminus\left(\bigcup_{i=1}^{t}\mathcal{V}_{i}\right)$.

(C1)

The vertex sets $\mathcal{V}_{1},\ldots,\mathcal{V}_{t},S$ are disjoint and partition $V^{\prime}$.

(C2)

The edge set $E_{s}^{\prime}$ can be decomposed as $E_{s}^{\prime}=\bigcup_{v\in S}E_{s,v}^{\prime}$, where $E_{s,v}^{\prime}$ is a subset of edges incident to $v$, viewed as oriented away from $v$. This orientation is acyclic. For each vertex $v$ such that $E_{s,v}^{\prime}\neq\emptyset$, we have $|E_{s,v}^{\prime}|+\deg_{E_{h}^{\prime}}(v)\leq n^{\gamma}$. Each vertex $v$ knows the set $E_{s,v}^{\prime}$.

(C3)

Consider a subgraph $\mathcal{G}_{i}=(\mathcal{V}_{i},\mathcal{E}_{i})$. Vertices in $\mathcal{V}_{i}$ halt after the same number of rounds, say $K$. Exactly one of the following subcases will be satisfied.

1. (C3-1)

All vertices in $\mathcal{V}_{i}$ have degree $\Omega(n^{\gamma})$ in the subgraph $\mathcal{G}_{i}$, each connected component of $\mathcal{G}_{i}$ has $\tilde{O}(n^{\rho})$ mixing time, and $K=\tilde{O}(n^{10\rho})$. Furthermore, every vertex in $\mathcal{V}_{i}$ knows that they are in this sub-case. 2. (C3-2)

$|\mathcal{V}_{i}|\leq n^{\prime}-\tilde{\Omega}(n^{\gamma})$, and every vertex in $\mathcal{V}_{i}$ knows they are in this subcase.

(C4)

Each vertex $v\in S$ halts in $\tilde{O}(n^{\prime}/n^{\gamma})$ rounds.

(C5)

The inequality E_{r}^{\prime}\leq\Big{(}|E^{\prime}|\log|E^{\prime}|-\sum_{i=1}^{t}|\mathcal{E}_{i}|\log|\mathcal{E}_{i}|\Big{)}/(6n^{\rho}\log m) is met.

(C6)

Each cluster $\mathcal{V}_{i}$ has a distinct identifier. When a vertex $v\in\mathcal{V}_{i}$ terminates, $v$ knows the identifier of $\mathcal{V}_{i}$. If $v\in S$, $v$ knows that it belongs to $S$.

We briefly explain the intuition behind these conditions. The algorithm $\mathcal{A}^{\ast}$ will be applied recursively to all subgraphs $\mathcal{G}_{i}$ that have yet to satisfy the minimum degree and mixing time requirements specified in Theorem 4.4 and Definition 4.3. Because vertices in different components halt at various times, they also may begin these recursive calls at different times.

The goal of (C2) is to make sure that once a vertex $v$ has $E_{s,v}^{\prime}\neq\emptyset$, the total number of edges added to $E_{s,v}$ cannot exceed $n^{\gamma}$. The goal of (C3) is to guarantee that the component size drops at a fast rate. The idea of (C5) is that the size of $E_{r}^{\prime}$ can be mostly charged to the number of the edges in the small-sized edge sets $\mathcal{E}_{i}$; this is used to bound the size of $E_{r}$ of our graph partitioning algorithm.

Note that in general the strong diameter of a subgraph $\mathcal{G}_{i}$ can be much higher than the maximum running time of vertices in $\mathcal{G}_{i}$, and it could be possible that $\mathcal{G}_{i}$ is not even a connected subgraph of $G$. However, (C6) guarantees that each vertex $v\in\mathcal{V}_{i}$ still knows that it belongs to $\mathcal{V}_{i}$. This property allows us to recursively execute $\mathcal{A}^{\ast}$ on each subgraph $\mathcal{G}_{i}$.

Lemma C.1**.**

There is an algorithm $\mathcal{A}^{\ast}$ that finds a partition $E^{\prime}=E_{h}^{\prime}\cup E_{s}^{\prime}\cup E_{r}^{\prime}$ meeting the above specification in the $\mathsf{CONGEST}$ model, w.h.p.

Assuming Lemma C.1, we are now in a position to prove Theorem 4.4.

Proof of Theorem 4.4.

Let $\mathcal{A}^{\ast}$ be the algorithm for Lemma C.1. Initially, we apply $\mathcal{A}^{\ast}$ with $G^{\prime}=G$, and this returns a partition $E^{\prime}=E_{h}^{\prime}\cup E_{s}^{\prime}\cup E_{r}^{\prime}$.

For each subgraph $\mathcal{G}_{i}$ in the partition output by an invocation of $\mathcal{A}^{\ast}$, do the following. If $\mathcal{G}_{i}$ satisfies (C3-1), by definition it must have $\tilde{O}(n^{\rho})$ mixing time, and all vertices in $\mathcal{G}_{i}$ have degree $\Omega(n^{\gamma})$ in $\mathcal{G}_{i}$; we add the edge set $\mathcal{E}_{i}$ to the set $E_{h}$ and all vertices in $\mathcal{V}_{i}$ halt. Otherwise we apply the algorithm recursively to $\mathcal{G}_{i}$, i.e., we begin by applying $\mathcal{A}^{\ast}$ to $G^{\prime}=\mathcal{G}_{i}$ to further partition its edges. All recursive calls proceed in parallel, but may begin and end at different times. Conditions (C1) and (C6) guarantee that this is possible. (Note that if $\mathcal{G}_{i}$ is disconnected, then each connected component of $\mathcal{G}_{i}$ will execute the algorithm in isolation.)

Initially $E_{r}=\emptyset$ and $E_{s}=\emptyset$. After each invocation of $\mathcal{A}^{\ast}$, we update $E_{r}\leftarrow E_{r}\cup E_{r}^{\prime}$, $E_{s}\leftarrow E_{s}\cup E_{s}^{\prime}$, and $E_{s,u}\leftarrow E_{s,u}\cup E_{s,u}^{\prime}$ for each vertex $u$.

Analysis.

We verify that the three conditions of Definition 4.3 are satisfied. First of all, note that each connected component of $E_{h}$ terminated in (C3-1) must have $\tilde{O}(n^{\rho})$ mixing time, and all vertices in the component have degree $\Omega({n^{\gamma}})$ within the component. Condition (a) of Definition 4.3 is met. Next, observe that Condition (b) of Definition 4.3 is met due to (C2). If the output of $\mathcal{A}^{\ast}$ satisfies that $E_{s,v}^{\prime}\neq\emptyset$, then $|E_{s,v}|$ together with the number of remaining incident edges (i.e., the ones in $E_{h}^{\prime}$) is less then ${n^{\gamma}}$. Therefore, $|E_{s,v}|$ cannot exceed ${n^{\gamma}}$, since only the edges in $E_{h}^{\prime}$ that are incident to $v$ can be added to $E_{s,v}$ in future recursive calls. Lastly, we argue that (C5) implies that Condition (c) of Definition 4.3 is satisfied. Assume, inductively, that a recursive call on edge set $\mathcal{E}_{i}$ eventually contributes at most $|\mathcal{E}_{i}|\log|\mathcal{E}_{i}|/(6n^{\rho}\log m)$ edges to $E_{r}$. It follows from (C5) that the recursive call on edge set $E^{\prime}$ contributes $|E^{\prime}|\log|E^{\prime}|/(6n^{\rho}\log m)$ edges to $E_{r}$. We conclude that $|E_{r}|\leq|E|\log|E|/(6n^{\rho}\log|E|)=|E|/6n^{\rho}$.

Now we analyze the round complexity. In one recursive call of $\mathcal{A}^{\ast}$, consider a component $\mathcal{G}_{i}$ in the output partition, and let $K$ be the running time of vertices in $\mathcal{V}_{i}$. Due to (C3), there are two cases. If $\mathcal{G}_{i}$ satisfied (C3-1), it will halt in $K=O(n^{10\rho})$ rounds. Otherwise, (C3-2) is met, and we have $|\mathcal{V}_{i}|\leq n^{\prime}-\tilde{\Omega}(n^{\gamma})$. Let $v\in V$ be any vertex, and let $K_{1},\ldots,K_{z}$ be the running times of all calls to $\mathcal{A}^{\ast}$ that involve $v$. (Whenever $v$ ends up in $S$ or in a component satisfying (C3-1) it halts permanently, so $K_{1},\ldots,K_{z-1}$ reflect executions that satisfy (C3-2) upon termination). Here $z$ can be at most $n^{1-\gamma}$, thus we have $\sum_{i=1}^{z}K_{i}\leq\tilde{O}(n^{1-\gamma+10\rho})$. And this is the running time since the whole algorithm stops within $\tilde{O}(n^{1-\gamma+9\rho})$ rounds. ∎

C.1 Subroutines

Before proving Lemma C.1, we first introduce some helpful subroutines. Lemma C.3 shows that for subgraphs of sufficiently high strong diameter, we can find a sparse cut of the subgraph, with runtime proportional to the strong diameter. Lemma C.4 offers a procedure that removes a set of edges in such a way that the vertices in the remaining graph have high degree, and the removed edges form a low arboricity subgraph. Lemma C.5 shows that if a subgraph already has a low conductance cut, then we can efficiently find a cut of similar quality.

All these subroutines are applied to a connected subgraph $G^{\ast}=(V^{\ast},E^{\ast})$ of the underlying network $G=(V,E)$, and the computation does not involve vertices outside of $G^{\ast}$. In subsequent discussion in this section, the parameters $n$ and $m$ are always defined as $n=|V|$ and $m=|E|$, which are independent of the chosen subgraph $G^{\ast}$.

Lemma C.2**.**

Let $m$ and $D$ be two numbers. Let $(a_{1},\ldots,a_{D})$ be a sequence of positive integers such that $D\geq 48n^{\rho}\log^{2}m$ and $\sum_{i=1}^{D}a_{i}\leq m$. Then there exists an index $j$ such that $j\in[D/4,3D/4]$ and

[TABLE]

Proof.

Define $S_{k}=\sum_{i=1}^{k}a_{i}$ to be the $k$th prefix sum. By symmetry, we may assume $S_{\lfloor D/2\rfloor}\leq S_{D}-S_{\lfloor D/2\rfloor}$, since otherwise we can reverse the sequence. Scan each index $j$ from $D/4$ to $D/2$. If an index $j$ does not satisfy $a_{j}\leq\frac{1}{12n^{\rho}\log m}\cdot S_{j-1}$, then this implies that $S_{j}>S_{j-1}\left(1+\frac{1}{12n^{\rho}\log m}\right)$. If no index $j\in[D/4,D/2]$ satisfies this condition then $S_{\lfloor D/2\rfloor}$ is larger than

[TABLE]

which is impossible since $\sum_{i=1}^{D}a_{i}\leq m$. Therefore, there must exist an index $j\in[D/4,D/2]$ such that $a_{j}\leq\frac{1}{12n^{\rho}\log m}\cdot S_{j-1}=\frac{1}{12n^{\rho}\log m}\cdot\sum_{i=1}^{j-1}a_{i}$. By our assumption that $S_{\lfloor D/2\rfloor}\leq S_{D}-S_{\lfloor D/2\rfloor}$, we also have $a_{j}\leq\frac{1}{12n^{\rho}\log m}\cdot\min\left(\sum_{i=1}^{j-1}a_{i},\;\sum_{i=j+1}^{D}a_{i}\right)$. ∎

Lemma C.3** (High Diameter subroutine).**

Let $G^{\ast}=(V^{\ast},E^{\ast})$ be a connected subgraph and $x\in V^{\ast}$ be a vertex for which $\tilde{D}=\max_{v\in V^{\ast}}{\operatorname{dist}}_{G^{\ast}}(x,v)\geq 48n^{\rho}\log^{2}m$. Define $V_{\operatorname{low}}=\{v\in V^{\ast}\mid\mathrm{deg}_{G^{\star}}(v)\leq{n^{\gamma}}/2\}$. Suppose there are no edges connecting two vertices in $V_{\operatorname{low}}$. Then we can find a cut $(C,\bar{C})$ of $G^{\ast}$ such that $\min(|C|,|\bar{C}|)\geq\frac{\tilde{D}}{32}n^{\gamma}$ and $\partial(C)\leq\min(V_{\operatorname{vol}}(C),V_{\operatorname{vol}}(\bar{C}))/(12n^{\rho}\log m)$ in $O(\tilde{D})$ rounds deterministically in the $\mathsf{CONGEST}$ model. Each vertex in $V^{\ast}$ knows whether or not it is in $C$.

Proof.

The algorithm is as follows. First, build a BFS tree of $G^{\ast}$ rooted at $x\in V^{\ast}$ in $O(\tilde{D})$ rounds. Let $L_{i}$ be the set of vertices of level $i$ in the BFS tree, and let $p_{i}$ be the number of edges $e=\{u,v\}$ such that $u\in L_{i}$ and $v\in L_{i+1}$. We write $L_{a..b}=\bigcup_{i=a}^{b}L_{i}$. In $O(\tilde{D})$ rounds we can let the root $x$ learn the sequence $(p_{1},\ldots,p_{\tilde{D}})$.

Note that in a BFS tree, edges do not connect two vertices in non-adjacent levels. By Lemma C.2, there exists an index $j\in[\tilde{D}/4,3\tilde{D}/4]$ such that $p_{j}\leq\frac{1}{12n^{\rho}\log m}\cdot\min\left(V_{\operatorname{vol}}(L_{1..j}),V_{\operatorname{vol}}(L_{j+1..\tilde{D}})\right)$, and such an index $j$ can be computed locally at the vertex $x$.

The cut is chosen to be $C=L_{1..j}$, so we have $\partial(C)\leq\min(V_{\operatorname{vol}}(C),V_{\operatorname{vol}}(\bar{C}))/(12n^{\rho}\log m)$. As for the second condition, due to our assumption in the statement of the lemma, for any two adjacent levels $L_{i},L_{i+1}$, there must exist a vertex $v\in L_{i}\cup L_{i+1}$ such that $v\notin V_{\operatorname{low}}$. By definition of $V_{\operatorname{low}}$, $v$ has more than ${n^{\gamma}}/2$ neighbors in $G^{\ast}$, and they are all within $L_{i-1..i+2}$. Thus, the number of vertices within any four consecutive levels must be greater than ${n^{\gamma}}/2$. Since $j\in[\tilde{D}/4,3\tilde{D}/4]$, we have

[TABLE]

To let each vertex in $V^{\ast}$ learn whether or not it is in $C$, the root $x$ broadcasts the index $j$ to all vertices in $G^{\ast}$. After that, each vertex in level smaller than or equal to $j$ knows that it is in $C$; otherwise it is in $\bar{C}$. ∎

Intuitively, Lemma C.4 says that after the removal of a subgraph of small arboricity (i.e., the edge set $E_{s}^{\diamond}$), the remaining graph (i.e., the edge set $E^{\diamond}$) has high minimum degree. The runtime is proportional to the number of removed vertices (i.e., $|V^{\ast}|-|V^{\diamond}|$) divided by the threshold ${n^{\gamma}}$. Note that the second condition of Lemma C.4 implies that $E_{s,v}^{\diamond}=\emptyset$ for all $v\in V^{\diamond}$.

Lemma C.4** (Low Degree subroutine).**

Let $G^{\ast}=(V^{\ast},E^{\ast})$ be a connected subgraph with strong diameter $D$. We can partition $E^{\ast}=E^{\diamond}\cup E_{s}^{\diamond}$ meeting the following two conditions.

Let $V^{\diamond}$ be the set of vertices induced by $E^{\diamond}$. Each $v\in V^{\diamond}$ has more than ${n^{\gamma}}/2$ incident edges in $E^{\diamond}$.

• 2.

The edge set $E_{s}^{\diamond}$ is further partitioned as $E_{s}^{\diamond}=\bigcup_{v\in V^{\ast}\setminus V^{\diamond}}E_{s,v}^{\diamond}$, where $E_{s,v}^{\diamond}$ is a subset of incident edges of $v$, and $|E_{s,v}^{\diamond}|\leq{n^{\gamma}}$. Each vertex $v$ knows $E_{s,v}^{\diamond}$.

This partition can be found in $O(D+(|V^{\ast}|-|V^{\diamond}|)/{n^{\gamma}})$ rounds deterministically in the $\mathsf{CONGEST}$ model.

Proof.

To meet Condition $1$, a naive approach is to iteratively “peel off” vertices that have degree at most ${n^{\gamma}}/2$, i.e., put all their incident edges in $E_{s}$, so long as any such vertex exists. On some graphs this process requires $\Omega(n)$ peeling iterations.

We solve this issue by doing a batch deletion. First, build a BFS tree of $G^{\ast}$ rooted at an arbitrary vertex $x\in V^{\ast}$. We use this BFS tree to let $x$ count the number of vertices that have degree less than ${n^{\gamma}}$ in the remaining subgraph in $O(D)$ rounds.

The algorithm proceeds in iterations. Initially we set $E^{\diamond}\leftarrow E^{\ast}$ and $E_{s}^{\diamond}\leftarrow\emptyset$. In each iteration, we identify the subset $Z\subseteq V^{\ast}$ whose vertices have at most ${n^{\gamma}}$ incident edges in $E^{\diamond}$. We orient all the $E^{\diamond}$-edges touching $Z$ away from $Z$, if one endpoint is in $Z$, or away from the endpoint with smaller ${{\operatorname{ID}}}$, if both endpoints are in $Z$. Edges incident to $v$ oriented away from $v$ are added to $E_{s,v}^{\diamond}$ and removed from $E^{\diamond}$. The root $x$ then counts the number $z=|Z|$ of such vertices via the BFS tree. If $z>{n^{\gamma}}/2$, we proceed to the next iteration; otherwise we terminate the algorithm.

The termination condition ensures that each vertex has degree at least $({n^{\gamma}}+1)-z>{n^{\gamma}}/2$, and so Condition 1 is met. It is straightforward to see that the set $E_{s}^{\diamond}$ generated by the algorithm meets Condition 2, since for each $v$, we only add edges to $E_{s,v}^{\diamond}$ once, and it is guaranteed that $|E_{s,v}^{\diamond}|\leq{n^{\gamma}}$. Tie-breaking according to vertex-${\operatorname{ID}}$ ensures the orientation is acyclic.

Throughout the process, each time one vertex puts any edges into $E_{s}^{\diamond}$, it no longer stays in $V^{\diamond}$. Each iteration can be done in $O(D)$ time. We proceed to the next iteration only if there are more than ${n^{\gamma}}/2$ vertices being removed from $V^{\diamond}$. A trivial implementation can lead to an algorithm taking $O(D\left\lceil(|V^{\ast}|-|V^{\diamond}|)/{n^{\gamma}}\right\rceil))$ rounds. The round complexity can be further improved to $O(D+(|V^{\ast}|-|V^{\diamond}|)/{n^{\gamma}})$ by pipelining the iterations. At some point the root $x$ detects that iteration $i$ was the last iteration; in $O(D)$ time it broadcasts a message to all nodes instructing them to roll back iterations $i+1,i+2,\ldots$, which have been executed speculatively.∎

The proof of the following lemma is given in [CPZ19, Section 3]

Lemma C.5** (Low Conductance subroutine).**

Let $G^{\ast}=(V^{\ast},E^{\ast})$ be a connected subgraph with strong diameter $D$. Let $\phi\leq 1/12$ be a number. Suppose that there exists a subset $S\subset V^{\ast}$ satisfying

[TABLE]

Assuming such an $S$ exists, there is a $\mathsf{CONGEST}$ algorithm that finds a cut $C\subset V^{\ast}$ such that $\Phi(C)\leq 12\phi$ in $O(D+\mbox{\rm poly}(\log|E^{\ast}|,1/\phi))$ rounds, with failure probability $1/\mbox{\rm poly}(|E^{\ast}|)$. Each vertex in $V^{\ast}$ knows whether or not it belongs to $C$.

C.2 Proof of Lemma C.1

We prove Lemma C.1 by presenting and analyzing a specific distributed algorithm, which makes use of the subroutines specified in Lemma C.3, Lemma C.4, and Lemma C.5.

Recall that we are given a subgraph with edge set $E^{\prime}$ and must ultimately return a partition of it into $E_{h}^{\prime}\cup E_{s}^{\prime}\cup E_{r}^{\prime}$. The algorithm initializes $E_{h}^{\prime}\leftarrow E^{\prime}$, $E_{s}^{\prime}\leftarrow\emptyset$, and $E_{r}^{\prime}\leftarrow\emptyset$. There are two types of special operations.

Remove.

In an Remove operation, some edges are moved from $E_{h}^{\prime}$ to either $E_{s}^{\prime}$ or $E_{r}^{\prime}$. For the sake of a clearer presentation, each such operation is tagged Remove-$i$, for some index $i$.

Split.

Throughout the algorithm we maintain a partition of the current set $E_{h}^{\prime}$. In a Split operation, the partition subdivided. Each such operation is tagged as Split-$i$, for some index $i$, such that Split-$i$ occurs right after Remove-$i$.

Throughout the algorithm, we ensure that any part $E^{\star}$ of the partition of $E_{h}^{\prime}$ has an identifier that is known to all members of $V(E^{\star})$. It is not required that each part forms a connected subgraph. The partition at the end of the algorithm, $E_{h}^{\prime}=\bigcup_{i=1}^{t}\mathcal{E}_{i}$, is the output partition.

Notations.

Since we treat $E_{h}^{\prime}$ as the “active” edge set and $E_{s}^{\prime}$ and $E_{r}^{\prime}$ as repositories of removed edges, $\deg(v)$ refers to the degree of $v$ in the subgraph induced by the current $E_{h}^{\prime}$. We write $V_{\operatorname{low}}=\{v\in V^{\prime}\mid\mathrm{deg}(v)\leq n^{\gamma}\}$.

Algorithm.

In the first step of the algorithm, move each edge $\{u,v\}\in E_{h}^{\prime}$ in the subgraph induced by $V_{\operatorname{low}}$to $E_{s,u}^{\prime}$, where ${\operatorname{ID}}(u)<{\operatorname{ID}}(v)$ (Remove-1). (Breaking ties by vertex-${\operatorname{ID}}$ is critical to keep the orientation acyclic.)

After that, $E_{h}^{\prime}$ is divided into connected components. Assume these components are $G_{1}=(V_{1},E_{1})$, $G_{2}=(V_{2},E_{2}),\ldots$, where $V_{i}=V(E_{i})$. Let $D_{i}$ be the depth of a BFS tree rooted at an arbitrary vertex in $G_{i}$. In $O(D_{i})$ rounds, the subgraph $G_{i}$ is assigned an identifier that is known to all vertices in $V_{i}$ (Split-1). Note that this step is done in parallel for each $G_{i}$, and the time for this step is different for each $G_{i}$. From now on there will be no communication between different subgraphs in $\{G_{1},G_{2},\ldots\}$, and we focus on one specific subgraph $G_{i}$ in the description of the algorithm.

Depending on how large $D_{i}$ is, there are two cases. If $D_{i}\geq 48\log^{2}m$, we go to Case 1, otherwise we go to Case 2.

Case 1:

In this case, we have $D_{i}\geq 48n^{\rho}\log^{2}m$. Since there are no edges connecting two vertices in $V_{\operatorname{low}}$, we can apply the High Diameter subroutine, Lemma C.3, which finds a cut $(C,\bar{C})$ of $G_{i}$ such that $\min(|C|,|V_{i}\setminus C|)\geq\frac{D_{i}}{32}n^{\gamma}$ and $\partial(C)\leq\min(V_{\operatorname{vol}}(C),V_{\operatorname{vol}}(V_{i}\setminus C))/(12n^{\rho}\log m)$ in $O(D_{i})$ rounds. Every vertex in $V_{i}$ knows whether it is in $C$ or not. All edges of the cut $(C,\bar{C})$ are put into $E_{r}^{\prime}$ (Remove-2). Then $E_{i}$ splits into two parts according to the cut $(C,\bar{C})$ (Split-2). After that, all vertices in $V_{i}$ terminate. (Observe that the part containing the BFS tree root is connected, but the other part is not necessarily connected.)

Case 2:

In this case, we have $D_{i}\leq 48n^{\rho}\log^{2}m$. Since $G_{i}=(V_{i},E_{i})$ is a small diameter graph, a vertex $v\in V_{i}$ is able broadcast a message to all vertices in $V_{i}$ very fast. We apply the Low Degree subroutine, Lemma C.4, to obtain a partition $E_{i}=E^{\diamond}\cup{E}_{s}^{\diamond}$. We add all edges in ${E}_{s}^{\diamond}$ to $E_{s}^{\prime}$ in such a way that $E_{s,v}^{\prime}\leftarrow E_{s,v}^{\prime}\cup{E}_{s,v}^{\diamond}$ for all $v\in V_{i}\setminus V^{\diamond}$, where $V^{\diamond}=V(E^{\diamond})$ (Remove-3).

After removing these edges, the remaining edges of $E_{i}$ are divided into several connected components, but all remaining vertices have degree larger than $n^{\gamma}/2$. Assume these connected components are $G_{i,1}=(V_{i,1},E_{i,1})$, $G_{i,2}=(V_{i,2},E_{i,2})$, $\ldots$. Let $D_{i,j}$ be the depth of the BFS tree from an arbitrary root vertex in $G_{i,j}$. In $O(D_{i,j})$ rounds we compute such a BFS tree and assign an identifier that is known to all vertices in $V_{i,j}$ (Split-3). That is, the remaining edges in $E_{i}$ are partitioned into $E_{i,1}$, $E_{1,2}$, $\ldots$.

In what follows, we focus on one subgraph $G_{i,j}$ and proceed to Case 2-a or Case 2-b.

Case 2-a:

In this case, $D_{i,j}\geq 48n^{\rho}\log^{2}m$. The input specification of the High Diameter subroutine (Lemma C.3) is satisfied, since every vertex has degree larger than $n^{\gamma}/2$. We apply the High Diameter subroutine to $G_{i,j}$. This takes $O(D_{i,j})$ rounds. This case is similar to Case 1, and we do the same thing as what we do in Case 1, i.e., remove the edges in the cut found by the subroutine (Remove-4), split the remaining edges (Split-4), and then all vertices in $V_{i,j}$ terminate.

Case 2-b:

In this case, $D_{i,j}\leq 48n^{\rho}\log^{2}m$. Note that every vertex has degree larger than $n^{\gamma}/2$, and $G_{i,j}$ has small diameter. What we do in this case is to test whether $G_{i,j}$ has any low conductance cut; if yes, we will split $E_{i,j}$ into two components. To do so, we apply the Low Conductance subroutine, Lemma C.5, with $\phi=\frac{1}{144n^{\rho}\log m}$. Based on the result, there are two cases.

Case 2-b-i:

The subroutine finds a set of vertices $C$ that $\Phi(C)\leq 12\phi=\frac{1}{12n^{\rho}\log m}$, and every vertex knows whether it is in $C$ or not. We move $\partial(C)$ to $E_{r}^{\prime}$ (Remove-5), and then split the remaining edges into two edge sets according to the cut $(C,\bar{C})$ (Split-5). After that, all vertices in $V_{i,j}$ terminate.

Case 2-b-ii:

Otherwise, the subroutine does not return a subset $C$, and it means with probability at least $1-1/\mbox{\rm poly}(|E_{i,j}|)=1-1/\mbox{\rm poly}(n)$, there is no cut $(S,\bar{S})$ with conductance less than $\frac{\phi^{3}}{19208\ln^{2}(|E_{i,j}|e^{4})}=\Theta(\log^{-5}m)$. Recall the relation between the mixing time $\tau_{\operatorname{mix}}(G_{i,j})$ and the conductance $\Phi=\Phi_{G_{i,j}}$: $\Theta(\frac{1}{\Phi})\leq\tau_{\operatorname{mix}}(G_{i,j})\leq\Theta(\frac{\log|V_{i,j}|}{\Phi^{2}})$. Therefore, w.h.p., $G_{i,j}$ has $O(\mbox{\rm poly}\log n)$ mixing time. All vertices in $V_{i,j}$ terminate without doing anything in this step.

Note that in the above calculation, we use the fact that every vertex in $V_{i,j}$ has degree larger than $n^{\gamma}/2$ in $G_{i,j}$, and this implies that $|V_{i,j}|=\Omega(n^{\gamma})$ and $|E_{i,j}|=\Omega(n^{2\delta})$, and so $\Theta(\log m)=\Theta(\log n)=\Theta(\log|E_{i,j}|)=\Theta(\log|V_{i,j}|)$.

Analysis.

We show that the output of $\mathcal{A}^{\ast}$ meets its specifications (C1)–(C6). Recall that $E_{h}^{\prime}=\bigcup_{i=1}^{t}\mathcal{E}_{i}$ is the final partition of the edge set $E_{h}^{\prime}$ when all vertices terminate. Once an edge is moved from $E_{h}^{\prime}$ to either $E_{r}^{\prime}$ or $E_{s}^{\prime}$, it remains there for the rest of the computation. Condition (C1) follows from the fact that each time we do a split operation, the induced vertex set of each part is disjoint. Condition (C6) follows from the fact that each vertex knows which part of $E_{h}^{\prime}$ it belongs to after each split operation. In the rest of this section, we prove that the remaining conditions are met.

Claim C.6**.**

Condition (C2) is met.

Proof.

Note that only Remove-1 and Remove-3 involve $E_{s}^{\prime}$. In Remove-1, any $E_{s,u}^{\prime}$ that becomes non-empty must have had $u\in V_{\operatorname{low}}$, so $\deg(u)\leq n^{\gamma}$ before Remove-1, and therefore $|E_{s,u}^{\prime}|+\deg(u)\leq n^{\gamma}$ after Remove-1. In Remove-3, the Low Degree subroutine of Lemma C.4 computes a partition $E_{i}=E^{\diamond}\cup{E}_{s}^{\diamond}$, and then we update $E_{s,u}^{\prime}\leftarrow E_{s,u}^{\prime}\cup{E}_{s,u}^{\diamond}$ for all $u\in V_{i}\setminus V^{\diamond}$. By Lemma C.4, for any $u$ such that ${E}_{s,u}^{\diamond}\neq\emptyset$, we have $|{E}_{s,u}^{\diamond}|\leq n^{\gamma}$, and $u\notin V^{\diamond}$, where $V^{\diamond}$ is the vertex set induced by the remaining edge set $E^{\diamond}$. In other words, once $u$ puts at least one edge into $E_{s,u}^{\prime}$, we have $\deg(u)=0$ after Remove-3. ∎

Claim C.7**.**

Conditions (C3) and (C4) are met.

Proof.

We need to verify that in each part of the algorithm, we either spend at most $\tilde{O}(n^{10\rho})$ (because the run time of low conductance routine Lemma C.5 is $O(\log^{9}/\phi^{10})$ rounds and here $\phi=\frac{1}{144n^{\rho\log m}}$, whereas the run time of high conductance cut is $O(n^{\rho}\log^{2}m)$), or the size of the current component shrinks by $\tilde{\Omega}(n^{\gamma})$ vertices per round.

After removing all edges in the subgraph induced by $V_{\operatorname{low}}$, the rest of $E^{\prime}$ is partitioned into connected components $\mathcal{E}_{1},\mathcal{E}_{2},\ldots$. Consider one such component $\mathcal{E}_{i}$, and suppose it goes to Case 1. We find a sparse cut $(C,\bar{C})$, and moving $\partial(C)$ to $E_{r}^{\prime}$ breaks $\mathcal{E}_{i}$ into $\mathcal{E}_{i}^{1}$ and $\mathcal{E}_{i}^{2}$. By Lemma C.3, we have $\min(|C|,|\bar{C}|)\geq\frac{D_{i}}{32}n^{\gamma}$, so the size of both $V(\mathcal{E}_{i}^{1})=C$ and $V(\mathcal{E}_{i}^{2})=\bar{C}$ are at most $|V(\mathcal{E}_{i})|-\frac{D_{i}}{32}n^{\gamma}\leq n^{\prime}-\Omega(D_{i})n^{\gamma}=n^{\prime}-\Omega(n^{\rho+\gamma})$. Since the running time for each vertex in $V(\mathcal{E}_{i}^{1})$ and $V(\mathcal{E}_{i}^{2})$ is $O(D_{i})$, the condition (C3-2) is met.

Now suppose that $\mathcal{E}_{i}$ goes to Case 2. Note that the total time spent before it reaches Case 2 is $O(D_{i})=\mbox{\rm poly}\log n$. In Case 2 we execute the Low Degree subroutine of Lemma C.4, and let the time spent in this subroutine be $\tau$. By Lemma C.4, it is either the case that (i) $\tau=O(D_{i})$ or (ii) the remaining vertex set $V^{\diamond}$ satisfies $|V(E_{i})|-|V^{\diamond}|=\Omega(\tau n^{\gamma})$. In other words, if we spend too much time (i.e., $\omega(D_{i})$) on this subroutine, we must lose $\Omega(n^{\gamma})$ vertices per round.

After that, $\mathcal{E}_{i}$ is split into $\mathcal{E}_{i,1}$, $\mathcal{E}_{i,2}$, $\ldots$. We consider the set $\mathcal{E}_{i,j}$. If $\mathcal{E}_{i,j}$ goes to Case 2-a, then the analysis is the same as that in Case 1, and so (C3-2) is met.

Now suppose that $\mathcal{E}_{i,j}$ goes to Case 2-b. Note that the time spent during the Low Conductance subroutine of Lemma C.5 is $\tilde{O}(n^{10\rho})$. Suppose that a low conductance cut $(C,\bar{C})$ is found (Case 2-b-i). Since the cut has conductance less than $\frac{1}{12n^{\rho}\log m}$, by the fact that every vertex has degree higher than $n^{\gamma}/2$, we must have $\min(|C|,|\bar{C}|)=\Omega(n^{\gamma})$. Assume $\mathcal{E}_{i,j}\setminus\partial(C)$ is split into $\mathcal{E}_{i,j}^{1}$ and $\mathcal{E}_{i,j}^{2}$. The size of both $V(\mathcal{E}_{i,j}^{1})$ and $V(\mathcal{E}_{i,j}^{2})$ must be at most $|V(\mathcal{E}_{i,j})|-\Omega(n^{\gamma})$. Thus, (C3-2) holds for both parts $\mathcal{E}_{i,j}^{1}$ and $\mathcal{E}_{i,j}^{2}$.

Suppose that no cut $(C,\bar{C})$ is found (Case 2-b-ii). If the running time $K$ among vertices in $V_{i,j}$ is $\tilde{O}(n^{10\rho})$, then (C3-1) holds. Otherwise, we must have $|{V}_{i,j}|\leq n^{\prime}-\tilde{\Omega}(Kn^{\gamma})$ due to the Low Degree subroutine, and so (C3-2) holds.

Condition (C4) follows from the the above proof of (C3), since for each part of the algorithm, it is either the case that (i) this part takes $O(n^{10\rho})$ time, or (ii) the number of vertices in the current subgraph is reduced by $\tilde{\Omega}(n^{\gamma})$ per round. ∎

Claim C.8**.**

Condition (C5) is met.

Proof.

Condition (C5) says that after the algorithm $\mathcal{A}^{\ast}$ completes, $|E_{r}^{\prime}|\leq f$, where

[TABLE]

We prove the stronger claim that this inequality holds at all times w.r.t. the current edge partition $\mathcal{E}_{1}\cup\cdots\cup\mathcal{E}_{t}$ of $E_{h}^{\prime}$. In the base case this is clearly true, since $t=1$ and $E^{\prime}=E_{h}^{\prime}=\mathcal{E}_{1}$ and $E_{r}^{\prime}=\emptyset$. Moving edges from $E_{h}^{\prime}$ to $E_{s}^{\prime}$ increases $f$ and has no effect on $E_{r}^{\prime}$, so we only have to consider the movement of edges from $E_{h}^{\prime}$ to $E_{r}^{\prime}$. Note that this only occurs in Remove-$i$ and Split-$i$, for $i\in\{2,4,5\}$, where in these operations we find a cut $(C,\bar{C})$ and split one of the parts $\mathcal{E}_{j}$ according to the cut. In all cases we have

[TABLE]

Suppose that removing $\partial(C)$ splits $\mathcal{E}_{j}$ into $\mathcal{E}_{j}^{1}$ and $\mathcal{E}_{j}^{2}$, with $|\mathcal{E}_{j}^{1}|\leq|\mathcal{E}_{j}^{2}|$ and $C=V(\mathcal{E}_{j}^{1})$. We bound the change in $|E_{r}^{\prime}|$ and $f$ separately. Clearly

[TABLE]

Thus, $|E_{r}^{\prime}|\leq f$ also holds after Remove-$i$ and Split-$i$, for $i\in\{2,4,5\}$. ∎