Tight Lower Bounds for Directed Cut Sparsification and Distributed Min-Cut

Abstract

In this paper, we consider two fundamental cut approximation problems on large graphs. We prove new lower bounds for both problems that are optimal up to logarithmic factors.

The first problem is to approximate cuts in balanced directed graphs. In this problem, the goal is to build a data structure that $(1\pm \epsilon )$-approximates cut values in graphs with $n$ vertices. For arbitrary directed graphs, such a data structure requires $\mathrm{\Omega }\left(n^2\right)$ bits even for constant $\epsilon$. To circumvent this, recent works study $\beta$-balanced graphs, meaning that for every directed cut, the total weight of edges in one direction is at most $\beta$ times that in the other direction. We consider two models: the for-each model, where the goal is to approximate each cut with constant probability, and the for-all model, where all cuts must be preserved simultaneously. We improve the previous $\mathrm{\Omega }(n\sqrt{\beta /\epsilon })$ lower bound to $\tilde{\mathrm{\Omega }}(n\sqrt{\beta }/\epsilon )$ in the for-each model, and we improve the previous $\mathrm{\Omega }(n\beta /\epsilon )$ lower bound to $\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)$ in the for-all model. ¹ This resolves the main open questions of (Cen et al., ICALP, 2021).

The second problem is to approximate the global minimum cut in a local query model, where we can only access the graph via degree, edge, and adjacency queries. We improve the previous $\mathrm{\Omega }\left(\frac{m}{k}\right)$ query complexity lower bound to $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ for this problem, where m is the number of edges, $k$ is the size of the minimum cut, and we seek a $(1+\epsilon )$-approximation. In addition, we show that existing upper bounds with slight modifications match our lower bound up to logarithmic factors.

1. Introduction

The notion of cut sparsifiers has been extremely influential. It was introduced by Benczúr and Karger [BK96] and it is the following: Given a graph $G=(V,E,w)$ with $n=\left|V\right|$ vertices, $m=\left|E\right|$ edges, edge weights $w_e\ge 0$, and a desired error parameter $\epsilon >0$, a ($1\pm \epsilon$) cut sparsifier of $G$ is a subgraph $H$ on the same vertex set $V$ with (possibly) different edge weights, such that $H$ approximates the value of every cut in $G$ within a factor of $(1\pm \epsilon )$. Benczúr and Karger [BK96] showed that every undirected graph has a $(1\pm \epsilon )$ cut sparsifier with only $O\left(n\mathrm{l}\mathrm{o}\mathrm{g}n/{\epsilon }^2\right)$ edges. This was later extended to the stronger notion of spectral sparsifiers [ST11] and the number of edges was improved to $O\left(n/{\epsilon }^2\right)$ [BSS12]; see also related work with different bounds for both cut and spectral sparsifiers [FHHP19, KP12, ST04, SS11, LS17, CKST19].

In the database community, a key result is the work of [AGM12], which shows how to construct a sparsifer using $\tilde{O}\left(n/{\epsilon }^2\right)$ linear measurements to $(1+\epsilon )$-approximate all cut values. Sketching massive graphs arises in various applications where there are entities and relationships between them, such as webpages and hyperlinks, people and friendships, and IP addresses and data flows. As large graph databases are often distributed or stored on external memory, sketching algorithms are useful for reducing communication and memory usage in distributed and streaming models. We refer the readers to [McG14] for a survey of graph stream algorithms in the database community.

For very small values of $\epsilon$, the $1/{\epsilon }^2$ dependence in known cut sparsifiers may be prohibitive. Motivated by this, the work of [ACK+16] relaxed the cut sparsification problem to outputting a data structure $D$, such that for any fixed cut $S\subset V$, the value $D\left(S\right)$ is within a $(1\pm \epsilon )$ factor of the cut value of $S$ in $G$ with probability at least 2/3. Notice the order of quantifiers — the data structure only needs to preserve the value of any fixed cut (chosen independently of its randomness) with high constant probability. This is referred to as the for-each model, and the data structure is called a for-each cut sketch. Surprisingly, [ACK+16] showed that every undirected graph has a $(1\pm \epsilon )$ for-each cut sketch of size $\tilde{O}(n/\epsilon )$ bits, reducing the dependence on $\epsilon$ to linear. They also showed an $\mathrm{\Omega }(n/\epsilon )$ bits lower bound in the for-each model. The improved dependence on $\epsilon$ is indeed coming from relaxing the original sparsification problem to the for-each model: [ACK+16] proved an $\mathrm{\Omega }\left(n/{\epsilon }^2\right)$ bit lower bound on any data structure that preserves all cuts simultaneously, which is referred to as the for-all model. This lower bound in the for-all model was strengthened to $\mathrm{\Omega }\left(n\mathrm{l}\mathrm{o}\mathrm{g}n/{\epsilon }^2\right)$ bits in [CKST19].

While the above results provide a fairly complete picture for undirected graphs, a natural question is whether similar improvements are possible for directed graphs. This is the main question posed by [CCPS21]. For directed graphs, even in the for-each model, there is an $\mathrm{\Omega }\left(n^2\right)$ lower bound without any assumptions on the graph. Motivated by this, [EMPS16, IT18, CCPS21] introduced the notion of $\beta$-balanced directed graphs, meaning that for every directed cut $(S,V\backslash S)$, the total weight of edges from $S$ to $V\backslash S$ is at most $\beta$ times that from $V\backslash S$ to $S$. The notion of $\beta$-balanced graphs turned out to be very useful for directed graphs, as [IT18, CCPS21] showed an $\tilde{O}(n\sqrt{\beta }/\epsilon )$ upper bound in the for-each model, and an $\tilde{O}\left(n\beta /{\epsilon }^2\right)$ upper bound in the for-all model, thus giving non-trivial bounds for both problems for small values of $\beta$. The work of [CCPS21] also proved lower bounds: they showed an $\mathrm{\Omega }(n\sqrt{\beta /\epsilon })$ lower bound in the for-each model, and an $\mathrm{\Omega }(n\beta /\epsilon )$ lower bound in the for-all model. While their lower bounds are tight for constant $\epsilon$, there is a quadratic gap for both models in terms of the dependence on $\epsilon$. The main open question of [CCPS21] is to determine the optimal dependence on $\epsilon$, which we resolve in this work.

Recent work further explored spectral sketches, faster computation of sketches, and sparsification of Eulerian graphs ($\beta$-balanced graphs with $\beta =1$) [ACK+16, JS18, CKK+18, CGP+23, SW19]. In this paper, we focus on the space complexity of cut sketches for general values of $\beta$.

As observed in [ACK+16], one of the main ways to use for-each cut sketches is to solve the distributed minimum cut problem. This is the problem of computing a $(1+\epsilon )$-approximate global minimum cut of a graph whose edges are distributed across multiple servers. One can ask each server to compute a (1 ± 0.2) for-all cut sketch and a $(1\pm \epsilon )$ for-each cut sketch. This allows one to find all $O(1)$-approximate minimum cuts, and because there are at most $n^{O(C)}$ cuts with value within a factor of $C$ of the minimum cut, one can query all these $\mathrm{p}\mathrm{o}\mathrm{l}\mathrm{y}(n)$ cuts using the more accurate for-each cut sketches, resulting in an optimal linear in $1/\epsilon$ dependence in the communication.

Motivated by this connection to distributed minimum cut estimation, we also consider the problem of directly approximating the minimum cut in a local query model, which was introduced in [RSW18] and studied for minimum cut in [ER18, BGMP21]. The model is defined as follows.

Let $G(V,E)$ be an unweighted and undirected graph, where the vertex set $V$ is known but the edge set $E$ is unknown. In the local query model, we have access to an oracle that can answer the following three types of local queries:

1. Degree query: Given $u\in V$, the oracle returns the degree of $u$.

2. Edge query: Given $u\in V$ and index $i$, the oracle returns the i-th neighbor of $u$, or $\perp$ if the edge does not exist.

3. Adjacency query: Given $u,v\in V$, the oracle returns whether $(u,v)\in E$.

In the Min-Cut problem, our goal is to estimate the global minimum cut up to a $(1\pm \epsilon )$-factor using these local queries. The complexity of the problem is measured by the number of queries, and we want to use as few queries as possible. For this problem we focus on undirected graphs.

Previous work [ER18] showed an $\mathrm{\Omega }\left(\frac{m}{k}\right)$ query complexity lower bound, where $k$ is the size of the minimum cut. The main open question is what the dependence on $\epsilon$ should be. There is also an $\tilde{O}(\frac{m}{k\mathrm{p}\mathrm{o}\mathrm{l}\mathrm{y}(\epsilon )})$ upper bound in [BGMP21], and a natural question is to close this gap.

1.1. Our Results

We resolve the main open questions mentioned above.

Cut Sketch for Balanced (Directed) Graphs.

We study the space complexity of $(1\pm \epsilon )$ cut sketches for $n$-node $\beta$-balanced (directed) graphs. Previous work [IT18, CCPS21] gave an $\tilde{O}\left(n\beta /{\epsilon }^2\right)$ upper bound in the for-all model and an $\tilde{O}(n\sqrt{\beta }/\epsilon )$ upper bound in the for-each model, along with an $\mathrm{\Omega }(n\beta /\epsilon )$ lower bound and an $\mathrm{\Omega }(n\sqrt{\beta /\epsilon })$ lower bound, respectively.

We close these gaps and resolve the dependence on $\epsilon$, improving the lower bounds to match the upper bounds for all parameters $n$, $\beta$, and $\epsilon$ (up to logarithmic factors). Formally, we have:

Theorem 1.1 (For-Each Cut Sketch for Balanced Graphs).

Let $\beta \ge 1$ and $0<\epsilon <1$. Assume $\sqrt{\beta }/\epsilon \le n/2$. Any $(1\pm \epsilon )$ for-each cut sketching algorithm for $\beta$-balanced $n$-node graphs must output $\tilde{\mathrm{\Omega }}(n\sqrt{\beta }/\epsilon )$ bits.

Theorem 1.2 (For-All Cut Sketch for Balanced Graphs).

Let $\beta \ge 1$ and $0<\epsilon <1$. Assume $\beta /{\epsilon }^2\le n/2$. Any $(1\pm \epsilon )$ for-all cut sketching algorithm for $\beta$-balanced $n$-node graphs must output $\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)$ bits.

Query Complexity of Min-Cut in the Local Query Model.

We study the problem of $(1\pm \epsilon )$-approximating the (undirected) global minimum cut in a local query model, where we can only access the graph via degree, edge, and adjacency queries.

We close the gap on the $\epsilon$ dependence in the query complexity of this problem by proving a tight $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ lower bound, where $m$ is the number of edges and $k$ is the size of the minimum cut. This improves the previous $\mathrm{\Omega }\left(\frac{m}{k}\right)$ lower bound in [ER18]. Formally, we have:

Theorem 1.3 (Approximating Min-Cut using Local Queries).

Any algorithm that estimates the size of the global minimum cut of a graph $G$ up to a $(1\pm \epsilon )$ factor requires $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ queries in expectation in the local query model, where m is the number of edges in $G$ and $k$ is the size of the minimum cut.

We also show that with a slight modification, the $\tilde{O}(\frac{m}{k\mathrm{p}\mathrm{o}\mathrm{l}\mathrm{y}(\epsilon )})$ query complexity upper bound in [BGMP21] can be improved to $\tilde{O}\left(\frac{m}{{\epsilon }^{2}k}\right)$, which implies that our lower bound is tight (up to logarithmic factors).

1.2. Our Techniques

A common technique we use for the different problems is communication complexity games that involve the approximation parameter $\epsilon$. For example, suppose Alice has a bit string $s$ of length $\left(1/{\epsilon }^2\right)$, and she can encode $s$ into a graph $G$ such that, if she sends Bob a $(1\pm \epsilon )$ (for-each or for-all) cut sketch to Bob, then Bob can recover a specific bit of s with high constant probability. By communication complexity lower bounds, we know Alice must send $\mathrm{\Omega }\left(1/{\epsilon }^2\right)$ bits to Bob, which gives a lower bound on the size of the cut sketch.

For-Each Cut Sketch Lower Bound.

Let $k=\sqrt{\beta }/\epsilon$. At a high level, we partition the $n$ nodes into $n/(2k)$ sub-graphs, where each sub-graph is a $k$-by-$k$ bipartite graph with two parts $L$ and $R$. We then divide $L$ and $R$ into $\sqrt{\beta }$ disjoint clusters $\left|L_1\right|=\left|L_2\right|=\dots =|L_{\sqrt{\beta }}|=1/\epsilon$ and $\left|R_1\right|=\left|R_2\right|=\dots =|R_{\sqrt{\beta }}|=1/\epsilon$. For every cluster pair $L_i$ and $R_j$, there are a total of $1/{\epsilon }^2$ edges. Intuitively, we wish to encode a bit string $s\in {\{-1,1\}}^{1/{\epsilon }^2}$ into forward edges (left to right) each with weight $\mathrm{\Theta }(1)$, and add backward edges (right to left) each with weight $1/\beta$ so that the graph $\beta$-balanced. If we could approximately decode this string from a for-each cut sketch, then we would get an $\mathrm{\Omega }((n/k)\cdot (\sqrt{\beta }{)}^2\cdot (1/\epsilon {)}^2)=\mathrm{\Omega }(n\sqrt{\beta }/\epsilon )$ lower bound.

However, if we use a simple encoding method [ACK+16, CCPS21] where each bit $s_i$ is encoded into one edge $(u,v)$ (e.g., with weight 1 or 2) and query the edges leaving $S=\left\{u\right\}\cup (R\backslash \{v\})$, then the $(k-1{)}^2=\mathrm{\Omega }\left(\beta /{\epsilon }^2\right)$ backward edges with weight $1/\beta$ will cause the cut value to be $\mathrm{\Omega }\left(1/{\epsilon }^2\right)$. The $(1\pm \epsilon )$ cut sketch will have additive error $\mathrm{\Omega }(1/\epsilon )\gg \mathrm{\Theta }(1)$, which will obscure $s_i=\{-1,1\}$. To address this, we instead encode $1/{\epsilon }^2$ bits of information across $1/{\epsilon }^2$ edges simultaneously. When we want to decode a specific bit $s_i$, we query the (directed) cut values between two carefully designed subsets $A\in L_i$ and $B\in R_j$. The key idea of our construction is that, although each edge in $A\times B$ is used to encode many bits of $s$, the encoding of different bits of $s$ is never too correlated: while encoding other bits does affect the total weight from $A$ to $B$, this effect is similar to adding noise which only varies the total weight from $A$ to $B$ by a small amount.

For-All Cut Sketch Lower Bound.

Let $k=\beta /{\epsilon }^2$. At a high level, we partition the $n$ nodes into $n/(2k)$ sub-graphs, where each sub-graph is a $k$-by-$k$ bipartite graph with two parts $L$ and $R$. Let $L=\left\{{\ell }_1,\dots ,{\ell }_k\right\}$. We partition $R$ into $\beta$ disjoint clusters $\left|R_1\right|=\dots =\left|R_{\beta }\right|=1/{\epsilon }^2$. We use edges from ${\ell }_i$ to $R_j$ to encode a bit string $s\in {\{0,1\}}^{1/{\epsilon }^2}$ by setting the weight of each forward edge to 1 or 2, and adding a backward edge of weight $1/\beta$ to balance the graph.

We can show that the following problem requires $\mathrm{\Omega }\left(1/{\epsilon }^2\right)$ bits of communication: Consider ${\ell }_i\in L$ and a random subset $T\subset R_j$ where $|T|=\frac{\left|R_j\right|}{2}$. Let $N\left({\ell }_i\right)$ denote ${\ell }_i$’s neighbors $v$ such that $\left({\ell }_i,v\right)$ has weight 2, which is uniformly random if $s$ is uniformly random. The problem is to decide whether $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$ or $\left|N\left({\ell }_i\right)\cap T\right|\le \frac{1}{4{\epsilon }^2}-\frac{c}{2\epsilon }$ for a sufficiently small constant $c>0$. Intuitively, the graph encodes a $(k\beta )$-fold version of this communication problem, which implies an $\mathrm{\Omega }((n/k)\cdot k\beta \cdot (1/\epsilon {)}^2)=\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)$ lower bound.

We need to show that Bob can distinguish between the two cases of $\left|N\left({\ell }_i\right)\cap T\right|$ given a for-all cut sketch. However, there are some challenges. The difference between the two cases is $\mathrm{\Theta }(1/\epsilon )$ while the natural cut to query $S=\left\{{\ell }_i\right\}\cup (R\backslash T)$ has value $\mathrm{\Omega }\left(\beta /{\epsilon }^4\right)$. The $(1\pm \epsilon )$ cut sketch will have additive error $\mathrm{\Omega }\left(\beta /{\epsilon }^3\right)\gg \mathrm{\Theta }(1/\epsilon )$, which is too much. To overcome this, note that we have not used the property that the for-all cut sketch preserves all cuts. We make use of the following crucial observation in [ACK+16]: In expectation, roughly half of the nodes ${\ell }_i\in L$ satisfy $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$ because $c$ is small. If Bob enumerates all subsets $Q\subset L$ of size $\frac{\left|L\right|}{2}$, he will eventually get lucky and find a set $Q$ that contains almost all such nodes. Since there are roughly $\frac{\left|L\right|}{2}=\frac{\beta }{2{\epsilon }^2}$ such nodes, the $(c/\epsilon )$ bias per node will contribute $\mathrm{\Omega }\left(c\beta /{\epsilon }^3\right)$ in total, which is enough to be detected even under an $O\left(\beta /{\epsilon }^3\right)$ additive error.

Query Complexity of Min-Cut in the Local Query Model.

We prove our lower bound using communication complexity, but unlike previous work [ER18], we consider the following 2SUM problem [WZ14]: Given $2t$ length-$L$ binary strings $\left(x^1,x^2,\dots ,x^t\right)$ and $\left(y^1,y^2,\dots ,y^t\right)$, we want to approximate the value of ${\sum }_{i\in \left[t\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(x^i,y^i\right)$ up to a $\sqrt{t}$ additive error, with the promise that at least a constant fraction of the $\left(x^i,y^i\right)$ satisfy $\mathrm{I}\mathrm{N}\mathrm{T}\left(x^i,y^i\right)=\alpha$ while the remaining pairs satisfy $\mathrm{I}\mathrm{N}\mathrm{T}\left(x^i,y^i\right)=0$ or $\alpha$. Here $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)={\sum }_{i=1}^L x_i\wedge y_i$ is the number of indices where $x$ and $y$ are both 1, and $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)$ is the set-disjointness problem, i.e., $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)=1$ if $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)=0$ and $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)=0$ otherwise. The parameters $L,t$, and $\alpha$ will be chosen later.

We construct our graph $G_{x,y}$ based on the vectors $x^i$ and $y^i$ in a way inspired by [ER18]. We then give a careful analysis of the size of the minimum cut of $G_{x,y}$, and show that under certain conditions, the size of the minimum cut is exactly $2{\sum }_{i\in \left[t\right]} \mathrm{I}\mathrm{N}\mathrm{T}\left(x^i,y^i\right)$. Consequently, a ($1\pm \epsilon$)-approximation of the minimum cut yields an approximation of ${\sum }_{i\in \left[t\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(x^i,y^i\right)$ up to a $\sqrt{\epsilon }$ additive error, which implies the desired lower bound.

2. Preliminaries

Let $G=(V,E,w)$ be a weighted (directed) graph with $n$ vertices and $m$ edges, where each edge $e\in E$ has weight $w_e\ge 0$. We write $G=(V,E)$ if $G$ is unweighted and leave out $w$. For two sets of nodes $S,T\subseteq V$, let $E(S,T)=\{(u,v)\in E:u\in S,v\in T\}$ denote the set of edges from $S$ to $T$. Let $w(S,T)={\sum }_{e\in E(S,T)} w_e$ denote the total weight of edges from $S$ to $T$. For a node $u\in V$ and a set of nodes $S\subseteq V$, we write $w(u,S)$ for $w(\{u\},S)$.

We write $\left[n\right]$ for $\{1,\dots ,n\}$. We use $\mathbf{1}$ to denote the all-ones vector. For a vector $v$, we write $\Vert v{\Vert }_2$ and $\Vert v{\Vert }_{\mathrm{\infty }}$ for the ${\ell }_2$ and ${\ell }_{\mathrm{\infty }}$ norm of $x$ respectively. For two vectors $u,v\in {\mathbb{R}}^n$, let $u\otimes v\in {\mathbb{R}}^{n^2}$ be the tensor product of $u$ and $v$. Given a matrix $A$, we use $A_i$ to denote the i-th row of $A$.

Directed Cut Sketches.

We start with the definitions of $\beta$-balanced graphs, for-all and for-each cut sketches [BK96, ST11, ACK+16, CCPS21].

We say a directed graph is balanced if all cuts have similar values in both directions.

Definition 2.1 ($\beta$-Balanced Graphs).

A strongly connected directed graph $G=(V,E,w)$ is $\beta$-balanced if, for all $\mathrm{\varnothing }\subset S\subset V$, it holds that $w(S,V\backslash S)\le \beta \cdot w(V\backslash S,S)$.

We say $\mathrm{s}\mathrm{k}(G)$ is a for-all cut sketch if the value of all cuts can be approximately recovered from it. Note that $\mathrm{s}\mathrm{k}(G)$ is not necessarily a graph and can be an arbitrary data structure.

Definition 2.2 (For-All Cut Sketch).

Let $0<\epsilon <1$. We say $𝒜$ is a ($1\pm \epsilon$) for-all cut sketching algorithm if there exists a recovering algorithm $f$ such that, given a directed graph $G=(V,E,w)$ as input, $𝒜$ can output a sketch $\mathrm{s}\mathrm{k}(G)$ such that, with probability at least 2/3, for all $\mathrm{\varnothing }\subset S\subset V$:

$$\left(1-\epsilon \right)\cdot w\left(S,V\backslash S\right)\le f\left(S,\mathrm{s}\mathrm{k}\left(G\right)\right)\le \left(1+\epsilon \right)\cdot w\left(S,V\backslash S\right).$$

Another notion of cut approximation is that of a “for-each” cut sketch, which requires that the value of each individual cut is preserved with high constant probability, rather than approximating the values of all cuts simultaneously.

Definition 2.3 (For-Each Cut Sketch).

Let $0<\epsilon <1$. We say $𝒜$ is a $(1\pm \epsilon )$ for-each cut sketching algorithm if there exists a recovering algorithm $f$ such that, given a directed graph $G=(V,E,w)$ as input, $𝒜$ can output a sketch $\mathrm{s}\mathrm{k}(G)$ such that, for each $\mathrm{\varnothing }\subset S\subset V$, with probability at least 2/3,

$$\left(1-\epsilon \right)\cdot w\left(S,V\backslash S\right)\le f\left(S,\mathrm{s}\mathrm{k}\left(G\right)\right)\le \left(1+\epsilon \right)\cdot w\left(S,V\backslash S\right).$$

In Definitions 2.2 and 2.3, the sketching algorithm $𝒜$ and the recovering algorithm $f$ can be randomized, and the probability is over the randomness in $𝒜$ and $f$.

3. For-Each Cut Sketch

In this section, we prove an $\mathrm{\Omega }(n\sqrt{\beta }/\epsilon )$ lower bound on the output size of ($1\pm \epsilon$) for-each cut sketching algorithms (Definition 2.3).

Theorem 1.1 (For-Each Cut Sketch for Balanced Graphs).

Let $\beta \ge 1$ and $0<\epsilon <1$. Assume $\sqrt{\beta }/\epsilon \lesssim n/2$. Any $(1\pm \epsilon )$ for-each cut sketching algorithm for $\beta$-balanced $n$-node graphs must output $\tilde{\mathrm{\Omega }}(n\sqrt{\beta }/\epsilon )$ bits.

Our result uses the following communication complexity lower bound for a variant of the Index problem, where Alice and Bob’s inputs are random.

Lemma 3.1 ([KNR01]).

Suppose Alice has a uniformly random string $s\in \{-1,1{\}}^n$ and Bob has a uniformly random index $i\in \left[n\right]$. If Alice sends a single (possibly randomized) message to Bob, and Bob can recover $s_i$ with probability at least 2/3 (over the randomness in the input and their protocol), then Alice must send $\mathrm{\Omega }(n)$ bits to Bob.

Our lower-bound construction relies on the following technical lemma.

Lemma 3.2.

For any integer $k\ge 1$, there exists a matrix $M\in {\{-1,1\}}^{{\left(2^k-1\right)}^2\times 2^{2k}}$ such that:

1. $⟨M_t,\mathbf{1}⟩=0$ for all $t\in [{\left(2^k-1\right)}^2]$.

2. $⟨M_t,M_{t^{\prime }}⟩=0$ for all $1\le t<t^{\prime }\le {\left(2^k-1\right)}^2$.

3. For all $t\in [{\left(2^k-1\right)}^2]$, the $t$-th row of $M$ can be written as $M_t=u\otimes v$ where $u,v\in {\{-1,1\}}^{2^k}$ and $⟨u,\mathbf{1}⟩=⟨v,\mathbf{1}⟩=0$.

Proof.

Our construction is based on the Hadamard matrix $H=H_{2^k}\in {\{-1,1\}}^{2^k\times 2^k}$. Recall that the first row of $H$ is the all-ones vector and that $⟨H_i,H_j⟩=0$ for all $i\ne j$. For every $2\le i$, $j\le 2^k$, we add $H_i\otimes H_j\in {\{-1,1\}}^{2^{2k}}$ as a row of $M$, so $M$ has ${\left(2^k-1\right)}^2$ rows.

Condition (3) holds because $⟨H_i,\mathbf{1}⟩=⟨H_j,\mathbf{1}⟩=0$ for all $i,j\ge 2$. For Conditions (1) and (2), note that for any vectors $u$, $v$, $w$, and $z$, we have $⟨u\otimes v,w\otimes z⟩=⟨u,w⟩⟨v,z⟩$. Using this fact, Condition (1) holds because $⟨M_t,\mathbf{1}⟩=⟨H_i\otimes H_j,\mathbf{1}\otimes \mathbf{1}⟩=⟨H_i,\mathbf{1}⟩⟨H_j,\mathbf{1}⟩=0$, and Condition (2) holds because $(i,j)\ne \left(i^{\prime },j^{\prime }\right)$ and thus $⟨M_t,M_{t^{\prime }}⟩=⟨H_i\otimes H_j,H_{i^{\prime }}\otimes H_{j^{\prime }}⟩=⟨H_i,H_{i^{\prime }}⟩⟨H_j,H_{j^{\prime }}⟩=0$. □

We first prove a lower bound for the special case $n=\mathrm{\Theta }(\sqrt{\beta }/\epsilon )$. Our proof for this special case introduces important building blocks for proving the general case $n=\mathrm{\Omega }(\sqrt{\beta }/\epsilon )$.

Lemma 3.3.

Suppose $n=\mathrm{\Theta }(\sqrt{\beta }/\epsilon )$. Any $(1\pm \epsilon )$ for-each cut sketching algorithm for $\beta$-balanced $n$-node graphs must output $\tilde{\mathrm{\Omega }}(n\sqrt{\beta }/\epsilon )=\tilde{\mathrm{\Omega }}\left(\beta /{\epsilon }^2\right)$ bits.

At a high level, we reduce the Index problem (Lemma 3.1) to the for-each cut sketching problem. Given Alice’s string $s$, we construct a graph $G$ to encode $s$, such that Bob can recover any single bit in $s$ by querying $O(1)$ cut values of $G$. Our lower bound (Lemma 3.3) then follows from the communication complexity lower bound of the Index problem (Lemma 3.1), because Alice can run a for-each cut sketching algorithm and send the cut sketch to Bob, and Bob can successfully recover the $O(1)$ cut values with high constant probability.

Proof of Lemma 3.3.

We reduce from the Index problem. Let $s\in {\{-1,1\}}^{\beta {(\frac{1}{\epsilon }-1)}^2}$ denote Alice’s random string.

Construction of $\mathit{G}$.

We construct a directed complete bipartite graph $G$ to encode $s$. Let $L$ and $R$ denote the left and right nodes of $G$, where $|L|=|R|=\sqrt{\beta }/\epsilon$. We partition $L$ into $\sqrt{\beta }$ disjoint blocks $L_1,\dots ,L_{\sqrt{\beta }}$ of equal size, and similarly partition $R$ into $R_1,\dots ,R_{\sqrt{\beta }}$. We divide $s$ into $\beta$ disjoint strings $s_{i,j}\in {\{-1,1\}}^{{(\frac{1}{\epsilon }-1)}^2}$ of the same length. We will encode $s_{i,j}$ using the edges from $L_i$ to $R_j$. Note that the encoding of each $s_{i,j}$ is independent since $E\left(L_i,R_j\right)\cap E\left(L_{i^{\prime }},R_{j^{\prime }}\right)=\varnothing$ for $(i,j)\ne \left(i^{\prime },j^{\prime }\right)$.

We fix $i$ and $j$ and focus on the encoding of $s_{i,j}$. Note that $\left|L_i\right|=\left|R_j\right|=1/\epsilon$. We refer to the edges from $L_i$ to $R_j$ as forward edges and the edges from $R_j$ to $L_i$ as backward edges. Let $w\in {\mathbb{R}}^{1/{\epsilon }^2}$ denote the weights of the forward edges, which we will choose soon. Every backward edge has weight $1/\beta$.

Let $z=s_{i,j}\in {\{-1,1\}}^{{(\frac{1}{\epsilon }-1)}^2}$. Assume w.l.o.g. that $1/\epsilon =2^k$ for some integer $k$. Consider the vector $x={\sum }_{t=1}^{{(\frac{1}{\epsilon }-1)}^2} z_t{M}_t\in {\mathbb{R}}^{1/{\epsilon }^2}$ where $M$ is the matrix in Lemma 3.2 with $2^k=1/\epsilon$. Because $z_t\in \{-1,1\}$ is uniformly random, each coordinate of $x$ is a sum of $O\left(1/{\epsilon }^2\right)$ i.i.d. random variables of value ±1. By the Chernoff bound and the union bound, we know that with probability at least 99/100, $\Vert x{\Vert }_{\mathrm{\infty }}\le c_1\mathrm{l}\mathrm{n}(1/\epsilon )/\epsilon$ for some constant $c_1>0$. If this happens, we set $w=\epsilon x+2c_1\mathrm{l}\mathrm{n}(1/\epsilon )1$, so that each entry of $w$ is between $c_1\mathrm{l}\mathrm{n}(1/\epsilon )$ and $3c_1\mathrm{l}\mathrm{n}(1/\epsilon )$. Otherwise, we set $w=2c_1\mathrm{l}\mathrm{n}(1/\epsilon )1$ to indicate that the encoding failed.

We first verify that $G$ is $O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$-balanced. This is because every edge has a reverse edge with similar weight: For every $u\in L$ and $v\in R$, the edge $(u,v)$ has weight $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$, while the edge $(v,u)$ has weight $1/\beta$.

We will show that given a $(1\pm \frac{c_2\epsilon }{\mathrm{l}\mathrm{n}(1/\epsilon )})$ cut sketch for some constant $c_2>0$, Bob can recover a specific bit of $z$ using 4 cut queries. By Lemma 3.1, this implies an $\mathrm{\Omega }\left(\beta /{\epsilon }^2\right)=\tilde{\mathrm{\Omega }}\left({\beta }^{\prime }/{\epsilon }^{\prime 2}\right)$ lower bound for cut sketching algorithms for ${\beta }^{\prime }=O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$ and ${\epsilon }^{\prime }=c_2\epsilon /\mathrm{l}\mathrm{n}(1/\epsilon )$.

Recovering a bit in $\mathit{s}$ from a for-each cut sketch of $\mathit{G}$.

Suppose Bob wants to recover a specific bit of $s$, which belongs to the substring $z=s_{i,j}$ and has an index $t$ in $z$. We assume that $z$ is successfully encoded by the subgraph between $L_i$ and $R_j$.

For simplicity, we index the nodes in $L_i$ as $1,\dots ,(1/\epsilon )$ and similarly for $R_j$. We index the forward edges $(u,v)$ in alphabetical order, first by $u\in L_i$ and then by $v\in R_j$. Under this notation, $⟨w,{\mathbf{1}}_A\otimes {\mathbf{1}}_B⟩$ gives the total weight $w(A,B)$ of forward edges from $A$ to $B$, where ${\mathbf{1}}_A,{\mathbf{1}}_B\in {\{0,1\}}^{1/\epsilon }$ are the indicator vectors of $A\subset L_i$ and $B\subset R_j$.

The crucial observation is that, given a cut sketch of $G$, Bob can approximate $⟨w,M_t⟩$ using 4 cut queries. By Lemma 3.2, $M_t=h_A\otimes h_B$ for some $h_A,h_B\in {\{-1,1\}}^{1/\epsilon }$. Let $A\subset L_i$ be the set of nodes $u\in L_i$ with $h_A(u)=1$. Let $B\subset R_i$ be the set of nodes $v\in R_j$ with $h_B(v)=1$. Let $\bar{A}=L_i\backslash A$ and $\bar{B}=R_j\backslash B$.

$$\begin{array}{l}⟨w,M_t⟩=⟨w,h_A\otimes h_B⟩=⟨w,\left({\mathbf{1}}_A-{\mathbf{1}}_{\bar{A}}\right)\otimes \left({\mathbf{1}}_B-{\mathbf{1}}_{\bar{B}}\right)⟩\\ =w\left(A,B\right)-w\left(\bar{A},B\right)-w\left(A,\bar{B}\right)+w\left(\bar{A},\bar{B}\right).\end{array}$$

To approximate the value of $w(A,B)$ (and similarly $w(\bar{A},B)$, $w(A,\bar{B})$, $w(\bar{A},\bar{B})$), Bob can query $w(S,V\backslash S)$ for $S=A\cup (R\backslash B)$. Consider the edges from $S$ to $(V\backslash S)$: the forward edges are from $A$ to $B$, each with weight $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$; and the backward edges are from $(R\backslash B)$ to $(L\backslash A)$, each with weight $1/\beta$. See Figure 1 as an example.

Figure 1:

For $S=A\cup (R\backslash B)$, the (directed) edges from $S$ to $(V\backslash S)$ consist of the following: the forward edges from $A$ to $B$, each with weight $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$, and the backward edges from $(R\backslash B)$ to $(L\backslash A)$, each with weight $1/\beta$.

By Lemma 3.2, $⟨h_A,\mathbf{1}⟩=⟨h_B,\mathbf{1}⟩=0$, so $|A|=|B|=\frac{\left|L_i\right|}{2}=\frac{\left|R_j\right|}{2}=\frac{1}{2\epsilon }$. The total weight of the forward edges is $\mathrm{\Theta }\left(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon )/{\epsilon }^2\right)$, and the total weight of the backward edges is ${(\frac{\sqrt{\beta }}{\epsilon }-\frac{1}{2\epsilon })}^2\frac{1}{\beta }=\mathrm{\Theta }\left(1/{\epsilon }^2\right)$, so the cut value $w(S,V\backslash S)$ is $\mathrm{\Theta }\left(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon )/{\epsilon }^2\right)$. Given a $(1\pm \frac{c_2\epsilon }{\mathrm{l}\mathrm{n}(1/\epsilon )})$ for-each cut sketch, Bob can obtain a $(1\pm \frac{c_2\epsilon }{\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon )})$ multiplicative approximation of $w(S,V\backslash S)$, which has $O\left(c_2/\epsilon \right)$ additive error. After subtracting the total weight of backward edges, which is fixed, Bob has an estimate of $w(A,B)$ with $O\left(c_2/\epsilon \right)$ additive error. Consequently, Bob can approximate $⟨w,M_t⟩$ with $O\left(c_2/\epsilon \right)$ additive error using 4 cut queries.

Now consider $⟨w,M_t⟩$. By Lemma 3.2, $⟨M_t,\mathbf{1}⟩=0$ and the rows of $M$ are orthogonal,

$$⟨w,M_t⟩=⟨\epsilon x,M_t⟩=\epsilon ⟨\sum _{t^{\prime }} z_{t^{\prime }}{M}_{t^{\prime }},M_t⟩=\epsilon z_t{‖M_t‖}_2^2=\frac{z_t}{\epsilon }.$$

We can see that, for a sufficiently small universal constant $c_2$, Bob can distinguish whether $z_t=1$ or $z_t=-1$ based on an $O\left(c_2/\epsilon \right)$ additive approximation of $⟨w,M_t⟩$.

Bob’s success probability is at least 0.95, because the encoding of $z$ fails with probability at most 0.01, and each of the 4 cut queries fails with probability at most 0.01.² □

We next consider the case with general values of $n,\beta$, and $\epsilon$, and prove Theorem 1.1.

Proof of Theorem 1.1.

Let $k=\sqrt{\beta }/\epsilon$. We assume w.l.o.g. that $k$ is an integer, $n$ is a multiple of $k$, and $(1/\epsilon )$ is a power of 2. Suppose Alice has a random string $s\in {\{-1,1\}}^{\mathrm{\Omega }(nk)}$. We will show that $s$ can be encoded into a graph $G$ such that

1. $G$ has $n$ nodes and is $O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$-balanced, and

2. Given a $(1\pm \frac{c_2\epsilon }{\mathrm{l}\mathrm{n}(1/\epsilon )})$ for-each cut sketch of $G$ and an index $q$, where $c_2>0$ is a sufficiently small universal constant, Bob can recover $s_q$ with probability at least 2/3.

Consequently, by Lemma 3.1, any for-each cut sketching algorithm must output $\mathrm{\Omega }(nk)=\mathrm{\Omega }(n\sqrt{\beta }/\epsilon )=\tilde{\mathrm{\Omega }}(n\sqrt{{\beta }^{\prime }}/{\epsilon }^{\prime })$ bits for ${\beta }^{\prime }=O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$ and ${\epsilon }^{\prime }=c_2\epsilon /\mathrm{l}\mathrm{n}(1/\epsilon )$.

We first describe the construction of $G$. We partition the $n$ nodes into $\ell =n/k\ge 2$ disjoint sets $V_1,\dots ,V_{\ell }$, each containing $k$ nodes. Let $s$ be Alice’s random string with length $\beta {\left(\frac{1}{\epsilon }-1\right)}^2(\ell -1)=\mathrm{\Omega }\left(k^2\ell \right)=\mathrm{\Omega }(nk)$. We partition $s$ into $(\ell -1)$ strings ${\left(s_i\right)}_{i=1}^{\ell -1}$, with $k^2$ bits in each substring. We then follow the same procedure as in Lemma 3.3 to encode $s_i$ into a complete bipartite graph between $V_i$ and $V_{i+1}$. Notice that we have $\left|s_i\right|=\beta {\left(\frac{1}{\epsilon }-1\right)}^2$ and $\left|V_i\right|=\left|V_{i+1}\right|=\sqrt{\beta }/\epsilon$, which is the same setting as in Lemma 3.3.

We can verify that $G$ is $O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$-balanced. This is because every edge $e$ has a reverse edge whose weight is at most $O(\beta \mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$ times the weight of $e$. For every $u\in V_i$ and $v\in V_{i+1}$, the edge $(u,v)$ has weight $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$, while the edge $(v,u)$ has weight $1/\beta$.

We next show that Bob can recover the $q$-th bit of $s$. Suppose Bob’s index $q$ belongs to the substring $s_i$ which is encoded by the subgraph between $V_i$ and $V_{i+1}$. Similar to the proof of Lemma 3.3, Bob only needs to approximate $w(A,B)$ for 4 pairs of $(A,B)$ with $O(1/\epsilon )$ additive error, where $\subset V_i$, $B\subset V_{i+1}$, and $|A|=|B|=\frac{1}{2\epsilon }$. To achieve this, Bob can query the cut value $w(S,V\backslash S)$ for $S=A\cup \left(V_{i+1}\backslash B\right){\bigcup }_{j=i+2}^{\ell } V_j$. The edges from $S$ to $(V\backslash S)$ are:

• $\frac{1}{4{\epsilon }^2}$ forward edges from $A$ to $B$, each with weight $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon ))$.

• ${\left(\frac{\sqrt{\beta }}{\epsilon }-\frac{1}{2\epsilon }\right)}^2$ backward edges from $\left(V_{i+1}\backslash B\right)$ to $\left(V_i\backslash A\right)$, each with weight $\frac{1}{\beta }$.

• $\frac{\sqrt{\beta }}{2{\epsilon }^2}$ backward edges from $A$ to $V_{i-1}$ when $i\ge 2$, each with weight $\frac{1}{\beta }$.

The cut value $w(S,V\backslash S)$ is $\mathrm{\Theta }(\mathrm{l}\mathrm{o}\mathrm{g}(1/\epsilon )/{\epsilon }^2)$. Consequently, given a $(1\pm \frac{c_2\epsilon }{\mathrm{l}\mathrm{n}(1/\epsilon )})$ for-each cut sketch, after subtracting the fixed weight of the backward edges, Bob can approximate $w(A,B)$ with $O\left(c_2/\epsilon \right)$ additive error. Similar to the proof of Lemma 3.3, for sufficiently small constant $c_2>0$, repeating this process for 4 different pairs of $(A,B)$ will allow Bob to recover $s_q\in \{-1,1\}$. □

4. For-All Cut Sketch

In this section, we prove an $\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)$ lower bound on the output size of $(1\pm \epsilon )$ for-all cut sketching algorithms (Definition 2.2).

Theorem 1.2 (For-All Cut Sketch for Balanced Graphs).

Let $\beta \ge 1$ and $0<\epsilon <1$. Assume $\beta /{\epsilon }^2\le n/2$. Any $(1\pm \epsilon )$ for-all cut sketching algorithm for $\beta$-balanced $n$-node graphs must output $\Omega \left(n\beta /{\epsilon }^2\right)$ bits.

Our proof is inspired by [ACK+16] and uses the following communication complexity lower bound for an $n$-fold version of the Gap-Hamming problem.

Lemma 4.1 ([ACK+16]).

Consider the following distributional communication problem: Alice has $h$ strings $s_1,\dots ,s_h\in {\{0,1\}}^{1/{\epsilon }^2}$ of Hamming weight $\frac{1}{2{\epsilon }^2}$. Bob has an index $i\in \left[h\right]$ and a string $t\in {\{0,1\}}^{1/{\epsilon }^2}$ of Hamming weight $\frac{1}{2{\epsilon }^2}$, drawn as follows:

1. $i$ is chosen uniformly at random;

2. every $s_{i^{\prime }}$ for $i^{\prime }\ne i$ is chosen uniformly at random;

3. $s_i$ and $t$ are chosen uniformly at random, conditioned on their Hamming distance $\mathrm{\Delta }\left(s_i,t\right)$ being, with equal probability, either $\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ or $\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ for some universal constant $c>0$.

Consider a (possibly randomized) one-way protocol, in which Alice sends Bob a message, and Bob then determines with success probability at least 2/3 whether $\mathrm{\Delta }\left(s_i,t\right)$ is $\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ or $\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$. Then Alice must send $\mathrm{\Omega }\left(h/{\epsilon }^2\right)$ bits to Bob.

Before proving Theorem 1.2, we first consider the special case $n=\mathrm{\Theta }\left(\beta /{\epsilon }^2\right)$.

Lemma 4.2.

Suppose $n=\mathrm{\Theta }\left(\beta /{\epsilon }^2\right)$. Any $(1\pm \epsilon )$ for-all cut sketching algorithm for $\beta$-balanced n-node graphs must output $\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)=\mathrm{\Omega }\left({\beta }^2/{\epsilon }^4\right)$ bits.

We reduce the distributional Gap-Hamming problem (Lemma 4.1) to the for-all cut sketching problem. Suppose Alice has $h$ strings $s_1,s_2,\dots ,s_h\in {\{0,1\}}^{1/{\epsilon }^2}$ where $h={\beta }^2/{\epsilon }^2$, and Bob has an index $i\in \left[h\right]$ and a string $t\in {\{0,1\}}^{1/{\epsilon }^2}$. We construct a graph $G$ to encode $s_1,s_2,\dots ,s_h$, such that given a for-all cut sketch of $G$, Bob can determine whether $\mathrm{\Delta }\left(s_i,t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_i,t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ with high constant probability. Our lower bound then follows from Lemma 4.1.

Construction of $G$.

We construct a directed complete bipartite graph $G$. Let $L$ and $R$ denote the left and right nodes of $G$, where $\left|L\right|=\left|R\right|=\beta /{\epsilon }^2$. We partition $R$ into $\beta$ disjoint sets with $\left|R_1\right|=\dots =\left|R_{\beta }\right|=1/{\epsilon }^2$.

Consider the distributional Gap-Hamming problem in Lemma 4.1 with $h={\beta }^2/{\epsilon }^2$. We re-index Alice’s $\left({\beta }^2/{\epsilon }^2\right)$ strings as $s_{i,j}$, where $i\in \left[\beta /{\epsilon }^2\right]$ and $j\in \left[\beta \right]$. Let ${\ell }_1,{\ell }_2,\dots ,{\ell }_{\beta /{\epsilon }^2}$ be the nodes in $L$. We encode $s_{i,j}\in {\{0,1\}}^{1/{\epsilon }^2}$ using the edges from ${\ell }_i$ to $R_j$: For node ${\ell }_i$ and the v-th node in $R_j$, the forward edge $\left({\ell }_i,v\right)$ has weight $s_{i,j}(v)+1$, and the backward edge $\left(v,{\ell }_i\right)$ has weight $1/\beta$. Note that the encoding of each $s_{i,j}$ is independent since $E\left({\ell }_i,R_j\right)\cap E\left({\ell }_{i^{\prime }},R_{j^{\prime }}\right)=\varnothing$ for $(i,j)\ne \left(i^{\prime },j^{\prime }\right)$.

Determining $\mathrm{\Delta }\left(s_{i,j},t\right)$ from a for-all cut sketch of $G$.

Suppose Bob’s input (after re-indexing) is $1\le i\le \beta /{\epsilon }^2$, $1\le j\le \beta$, and $t\in {\{0,1\}}^{1/{\epsilon }^2}$. Bob wants to decide whether $\mathrm{\Delta }\left(s_{i,j},t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$.

Let $N\left({\ell }_i\right)$ denote the set of nodes $v\in R_j$ where the forward edge $\left({\ell }_i,v\right)$ has weight 2, which corresponds to the positions of 1 in $s_{i,j}$. Let $T$ be the set of nodes $v\in R_j$ such that $t(v)=1$.

$$\mathrm{\Delta }\left(s_{i,j},t\right)=\left|N\left({\ell }_i\right)\backslash T\right|+\left|T\backslash N\left({\ell }_i\right)\right|=\left|N\left({\ell }_i\right)\right|+|T|-2\left|N\left({\ell }_i\right)\cap T\right|=\frac{1}{{\epsilon }^2}-2\left|N\left({\ell }_i\right)\cap T\right|.$$

Hence, to determine whether $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_{i,j},t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$, Bob only needs to decide whether $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$ or $\left|N\left({\ell }_i\right)\cap T\right|\le \frac{1}{4{\epsilon }^2}-\frac{c}{2\epsilon }$.

Let $S=\left\{{\ell }_i\right\}\cup (R\backslash T)$. The cut $w(S,V\backslash S)$ consists of forward edges from ${\ell }_i$ to $T$ and backward edges from $(R\backslash T)$ to ($\left.L\backslash \left\{{\ell }_i\right\}\right)$. Ideally, if Bob knows $w(S,V\backslash S)$, he can subtract the weight of backward edges to obtain $w\left({\ell }_i,T\right)=\frac{1}{{\epsilon }^2}+\left|N\left({\ell }_i\right)\cap T\right|$ and recover $\left|N\left({\ell }_i\right)\cap T\right|$. However, Bob can only get a ($1\pm \epsilon )$-approximation of $w(S,V\backslash S)$, which may have $\mathrm{\Theta }\left(\beta /{\epsilon }^3\right)$ additive error because $w(S,V\backslash S)=\mathrm{\Theta }\left(\beta /{\epsilon }^4\right)$. With this much error, Bob cannot distinguish between the two cases.

To overcome this issue, we follow the idea of [ACK+16]. Intuitively, when $c$ is small, roughly half of ${\ell }_i\in L$ satisfy $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$. By enumerating all subsets $Q\subset L$ of size $|Q|=\frac{\mid L\mid }{2}$, Bob can find a set $Q$ such that most nodes $v\in Q$ satisfy $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$. Since $|Q|=\frac{\beta }{2{\epsilon }^2}$, the $\frac{c}{2\epsilon }$ bias per node adds up to roughly $\frac{c\beta }{2{\epsilon }^3}$, which can be detected even with $\mathrm{\Theta }\left(\beta /{\epsilon }^3\right)$ error.

To prove Lemma 4.2, we need the following two technical lemmas, which are essentially proved in [ACK+16].

Lemma 4.3 (Claim 3.5 in [ACK+16]).

Let $c>0$ and $\frac{\sqrt{\beta }}{\epsilon }\ge \frac{10}{c}$. Consider the following sets:

$$\begin{array}{l}{L}_{\text{high}}=\{{\ell }_i\in L:\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }\},and\\ L_{\text{low}}=\{{\ell }_i\in L:\left|N\left({\ell }_i\right)\cap T\right|\le \frac{1}{4{\epsilon }^2}-\frac{c}{2\epsilon }\}.\end{array}$$

With probability at least 0.98, we have $\frac{1}{2}-10c\le \frac{\left|L_{\text{high}}\right|}{\left|L\right|}\le \frac{1}{2}$ and $\frac{1}{2}-10c\le \frac{\left|L_{\text{low}}\right|}{\left|L\right|}\le \frac{1}{2}$.

Lemma 4.4 (Lemma 3.4 in [ACK+16]).

Let $c_1>0$ be a sufficiently small universal constant. Suppose one can approximate $w(U,T)$ with additive error $c_1\beta /{\epsilon }^3$ for every $U\subset L$ with $|U|=\frac{\left|L\right|}{2}$. Let $Q\subset L$ be the subset with the highest (approximate) cut value. Then, with probability at least 0.96, we have $\frac{\left|L_{\mathrm{h}\mathrm{i}\mathrm{g}\mathrm{h}}\cap Q\right|}{\left|L_{\mathrm{h}\mathrm{i}\mathrm{g}\mathrm{h}}\right|}\ge \frac{4}{5}$.

We are now ready to prove Lemma 4.2.

Proof of Lemma 4.2.

We reduce from the distributional Gap-Hamming problem (Lemma 4.1) with $h={\beta }^2/{\epsilon }^2$. We re-index Alice’s $h$ strings as $s_{i,j}$, where $i\in \left[\beta /{\epsilon }^2\right]$ and $j\in \left[\beta \right]$.

We construct a directed bipartite graph $G$ with two parts $L$ and $R$, where $\left|L\right|=\left|R\right|=\beta /{\epsilon }^2$. Let $L=\left\{{\ell }_1,{\ell }_2,\dots ,{\ell }_{\beta /{\epsilon }^2}\right\}$. We partition $R$ into $\beta$ disjoint sets with $\left|R_1\right|=\dots =\left|R_{\beta }\right|=1/{\epsilon }^2$. We encode $s_{i,j}\in {\{0,1\}}^{1/{\epsilon }^2}$ using the edges from ${\ell }_i$ to $R_j$: For node ${\ell }_i$ and the v-th node in $R_j$, the forward edge $\left({\ell }_i,v\right)$ has weight $s_{i,j}(v)+1$, and the backward edge $\left(v,{\ell }_i\right)$ has weight $1/\beta$.

Note that $G$ is $(2\beta )$-balanced. We will show that given a $\left(1\pm c_2\epsilon \right)$ for-all cut sketch of $G$ for some constant $c_2>0$, Bob can decide whether $\mathrm{\Delta }\left(s_{i,j},t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ with probability at least 2/3. Consequently, by Lemma 4.1, any for-all cut sketching algorithm must output $\mathrm{\Omega }\left(h/{\epsilon }^2\right)=\mathrm{\Omega }\left({\beta }^2/{\epsilon }^4\right)=\mathrm{\Omega }\left({\beta }^{\prime 2}/{\epsilon }^{\prime 4}\right)$ bits for ${\beta }^{\prime }=2\beta$ and ${\epsilon }^{\prime }=c_2\epsilon$.

Bob enumerates every $U\subset L$ with $|U|=\frac{\left|L\right|}{2}=\frac{\beta }{2{\epsilon }^2}$ and uses the cut sketch to approximate $w(U,T)$, where $T\subset R_j$ corresponds to the positions of 1 in Bob’s string $t$ and $\left|T\right|=\frac{1}{2{\epsilon }^2}$. Let $S=U\cup (R\backslash T)$. The cut $(S,V\backslash S)$ has $\frac{\beta }{4{\epsilon }^4}$ forward edges from $U$ to $T$ with weights 1 or 2, and $\left(\frac{\beta }{{\epsilon }^2}-\frac{1}{2{\epsilon }^2}\right)\left(\frac{\beta }{2{\epsilon }^2}\right)=O\left(\frac{{\beta }^2}{{\epsilon }^4}\right)$ backward edges from $(R\backslash T)$ to $(L\backslash U)$ with weight $\frac{1}{\beta }$. The total weight of these edges is $O\left(\beta /{\epsilon }^4\right)$. Therefore, given a ($1\pm c_2\epsilon$) for-all cut sketch, Bob can subtract the fixed weight of the backward edges and approximate $w(U,T)$ with additive error $O\left(c_2\beta /{\epsilon }^3\right)$. When $c_2$ is sufficiently small, this additive error is at most $c_1\beta /{\epsilon }^3$. By Lemma 4.4, Bob can find $Q\subset L$ with $|Q|=\frac{\left|L\right|}{2}$ such that $\frac{\left|L_{\text{high}}\cap Q\right|}{\left|L_{\text{high}}\right|}\ge \frac{4}{5}$. Finally, if ${\ell }_i\in Q$, Bob decides $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$ and $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$; and if ${\ell }_i\notin Q$, Bob decides $\mathrm{\Delta }\left(s_{i,j},t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$.

Suppose Bob’s index is $(i,j)$. Notice that Bob uses $j$ to determine which $R_j$ to look at, but does not use any information about $i$. Therefore, when $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ and $\left|N\left({\ell }_i\right)\cap T\right|\ge \frac{1}{4{\epsilon }^2}+\frac{c}{2\epsilon }$,

$$\mathbf{P}\mathbf{r}\left[i\in Q\right]=\frac{\left|L_{\mathrm{h}\mathrm{i}\mathrm{g}\mathrm{h}}\cap Q\right|}{\left|L_{\mathrm{h}\mathrm{i}\mathrm{g}\mathrm{h}}\right|}\ge \frac{4}{5}.$$

Conversely, when $\mathrm{\Delta }\left(s_{i,j},t\right)\le \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ and $\left|N\left({\ell }_i\right)\cap T\right|\le \frac{1}{4{\epsilon }^2}-\frac{c}{2\epsilon }$, because $L_{\text{low}}\cap L_{\text{high}}=\varnothing$,

$$\mathbf{P}\mathbf{r}\left[i\notin Q\right]=\frac{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\backslash Q\right|}{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\right|}=\frac{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\right|-\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\cap Q\right|}{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\right|}\ge \frac{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\right|-\frac{1}{5}\left|L_{\mathrm{h}\mathrm{i}\mathrm{g}\mathrm{h}}\right|}{\left|L_{\mathrm{l}\mathrm{o}\mathrm{w}}\right|}\ge \frac{3}{4}.$$

The last inequality holds because $\left|L_{\text{low}}\right|\ge 0.4\left|L\right|$ and $\left|L_{\text{high}}\right|\le 0.5\left|L\right|$ by Lemma 4.3 when $c\le 0.1$.

We analyze Bob’s success probability. Lemma 4.3 fails with probability at most 0.02, Lemma 4.4 fails with probability at most 0.04, and the for-all cut sketch fails with probability at most 0.01³ If they all succeed, Bob’s probability of answering correctly is at least $\mathrm{m}\mathrm{i}\mathrm{n}\left(\frac{\left|L_{\text{high}}\cap Q\right|}{\left|L_{\text{high}}\right|},\frac{\left|L_{\text{low}}\backslash Q\right|}{\left|L_{\text{low}}\right|}\right)\ge \frac{3}{4}$. Bob’s overall fail probability is at most 0.02 + 0.04 + 0.01 + 0.25 < 1/3. □

We next consider the case with general values of $n,\beta$, and $\epsilon$, and prove Theorem 1.2.

Proof of Theorem 1.2.

Let $k=\beta /{\epsilon }^2$. We assume w.l.o.g. that $k$ is an integer and $n$ is a multiple of $k$. We reduce from the distributional Gap-Hamming problem in Lemma 4.1 with $h=\mathrm{\Omega }(n\beta )$. We will show that Alice’s strings can be encoded into a graph $G$ such that

1. $G$ has $n$ nodes and is ($2\beta$)-balanced, and

2. After receiving a string $t$, an index $q\in \left[h\right]$, and a ($1\pm c_2\epsilon$) for-all cut sketch of $G$ for some universal constant $c_2>0$, Bob can distinguish whether $\mathrm{\Delta }\left(s_q,t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_q,t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ with probability at least 2/3.

Consequently, by Lemma 4.1, any for-all cut sketching algorithm must output $\mathrm{\Omega }\left(h/{\epsilon }^2\right)=\mathrm{\Omega }\left(n\beta /{\epsilon }^2\right)=\mathrm{\Omega }\left(n{\beta }^{\prime }/{\epsilon }^{\prime 2}\right)$ bits for ${\beta }^{\prime }=2\beta$ and ${\epsilon }^{\prime }=c_2\epsilon$.

We first describe the construction of $G$. We partition the $n$ nodes into $\ell =n/k\ge 2$ disjoint sets $V_1,V_2,\cdots ,V_{\ell }$, each containing $k$ nodes. Let $s_1,s_2,\cdots ,s_h\in {\{0,1\}}^{1/{\epsilon }^2}$ be Alice’s random strings where $h=(t-1)\left({\beta }^2/{\epsilon }^2\right)=\mathrm{\Omega }\left((n/k)\left({\beta }^2/{\epsilon }^2\right)\right)=\mathrm{\Omega }(n\beta )$. We partition the $h$ strings into $(t-1)$ disjoint sets $S_1,S_2,\cdots ,S_{t-1}$, each with $\left({\beta }^2/{\epsilon }^2\right)$ strings. We then follow the same procedure as in Lemma 4.2 to encode $S_i$ into a complete bipartite graph between $V_i$ and $V_{i+1}$. Notice that $S_i$ has $\left({\beta }^2/{\epsilon }^2\right)$ strings and $\left|V_i\right|=\left|V_{i+1}\right|=k=\beta /{\epsilon }^2$, which is the same setting as in Lemma 4.2.

We can verify that $G$ is $(2\beta )$-balanced. This is because every edge $e$ has a reverse edge whose weight is at most $2\beta$ times the weight of $e$. For every $u\in V_i$ and $v\in V_{i+1}$, the edge $(u,v)$ has weight 1 or 2, while the edge $(v,u)$ has weight $1/\beta$.

We next show how Bob can distinguish between the two cases. Suppose Bob’s index $q$ specifies a string encoded by the subgraph between $V_i$ and $V_{i+1}$. Similar to the proof of Lemma 4.2, we only need to show that given a $\left(1\pm c_2\epsilon \right)$ for-all cut sketch, Bob can approximate $w(U,T)$ with additive error $O\left(\beta /{\epsilon }^3\right)$ for every $U\subset V_i$ with $|U|=\frac{\left|V_i\right|}{2}=\frac{\beta }{2{\epsilon }^2}$ and for some $T\subset V_{i+1}$ with $|T|=\frac{1}{2{\epsilon }^2}$. To see this, consider $S=U\cup \left(V_{i+1}\backslash T\right){\bigcup }_{j=i+2}^t V_j$. The edges from $S$ to $(V\backslash S)$ are

• $\frac{\beta }{4{\epsilon }^4}$ forward edges from $U$ to $T$, each with weight 1 or 2.

• $\left(\frac{\beta }{{\epsilon }^2}-\frac{1}{2{\epsilon }^2}\right)\left(\frac{\beta }{2{\epsilon }^2}\right)$ backward edges from $\left(V_{i+1}\backslash T\right)$ to $\left(V_i\backslash U\right)$, each with weight $\frac{1}{\beta }$.

• $\frac{{\beta }^2}{2{\epsilon }^4}$ backward edges from $U$ to $V_{i-1}$ when $i\ge 2$, each with weight $\frac{1}{\beta }$.

The total weight of these edges is $w(S,V\backslash S)=O\left(\beta /{\epsilon }^4\right)$. Consequently, given a $\left(1\pm c_2\epsilon \right)$ cut sketch, Bob can subtract the fixed weight of the backward edges and approximate $w(U,T)$ with $O\left(c_2\epsilon \left(\beta /{\epsilon }^4\right)\right)=O\left(c_2\beta /{\epsilon }^3\right)$ additive error. Similar to the proof of Lemma 4.2, for sufficiently small constant $c_2>0$, this will allow Bob to distinguish between the two cases $\mathrm{\Delta }\left(s_q,t\right)\le \frac{1}{2{\epsilon }^2}-\frac{c}{\epsilon }$ or $\mathrm{\Delta }\left(s_q,t\right)\ge \frac{1}{2{\epsilon }^2}+\frac{c}{\epsilon }$ with probability at least 2/3. □

5. Local Query Complexity of Min-Cut

In this section, we present an $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ lower bound on the query complexity of approximating the global minimum cut of an undirected graph $G$ to a ($1\pm \epsilon$) factor in the local query model. Formally, we have the following theorem.

Theorem 1.3 (Approximating Min-Cut using Local Queries).

Any algorithm that estimates the size of the global minimum cut of a graph $G$ up to a $(1\pm \epsilon )$ factor requires $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ queries in expectation in the local query model, where $m$ is the number of edges in $G$ and $k$ is the size of the minimum cut.

To achieve this, we define a variant of the 2-SUM communication problem in Section 5.1, show a graph construction in Section 5.2, and show that approximating 2-SUM can be reduced to the minimum cut problem using our graph construction in Section 5.3. In Section 5.4, we will show that our lower bound is tight up to logarithmic factors.

5.1. 2-SUM Preliminaries

Building off of the work of [WZ14], we define the following variant of the $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,\alpha )$ problem.

Definition 5.1.

For binary strings $x=\left(x_1,\dots ,x_L\right)\in {\{0,1\}}^L$ and $y=\left(y_1,\dots ,y_L\right)\in {\{0,1\}}^L$, let $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)={\sum }_{i=1}^L x_i\wedge y_i$ denote the number of indices where $x$ and $y$ are both 1. Let $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)$ denote whether $x$ and $y$ are disjoint. That is, $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)=1$ if $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)=0$, and $\mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}(x,y)=0$ if $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)\ge 1$.

Definition 5.2.

Suppose Alice has binary strings $\left(X^1,\dots ,X^t\right)$ where each string $X^i\in {\{0,1\}}^L$ has length $L$ and likewise Bob hast strings $\left(Y^1,\dots ,Y^t\right)$ each of length $L.\mathrm{I}\mathrm{N}\mathrm{T}\left(X^i,Y^i\right)$ is guaranteed to be either 0 or $\alpha \ge 1$ for each pair of strings $\left(X^i,Y^i\right)$. Furthermore, at least 1/1000 of the $\left(X^i,Y^i\right)$ pairs are guaranteed to satisfy $\mathrm{I}\mathrm{N}\mathrm{T}\left(X^i,Y^i\right)=\alpha$. In the $2-\mathrm{SUM}(t,L,\alpha )$ problem, Alice and Bob want to approximate ${\sum }_{i\in \left[t\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(X^i,Y^i\right)$ up to additive error $\sqrt{t}$ with high constant probability.

Lemma 5.3.

To solve $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,1)$ with high constant probability, the expected number of bits Alice and Bob need to communicate is $\mathrm{\Omega }(tL)$.

Proof.

[WZ14] proved an expected communication complexity of $\mathrm{\Omega }(tL)$ for $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,1)$ without the promise that at least a 1/1000 fraction of the $t$ string pairs intersect. Adding this promise does not change the communication complexity, because if ($\left.X^1,\dots ,X^t\right)$ and $\left(Y^1,\dots ,Y^t\right)$ do not satisfy the promise, we can add a number of new $X^i$ and $Y^i$ to satisfy the promise and later subtract their contribution to approximate ${\sum }_{i\in \left[t\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(X^i,Y^i\right)$ with additive error $\mathrm{\Theta }(\sqrt{t})$. □

Theorem 5.4.

To solve $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,\alpha )$ with high constant probability, the expected number of bits Alice and Bob need to communicate is $\mathrm{\Omega }(tL/\alpha )$.

Proof.

Consider an instance of $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L/\alpha ,1)$ with Alice’s strings $\left(X^1,\dots ,X^t\right)$ and Bob’s strings $\left(Y^1,\dots ,Y^t\right)$ each with length $L/\alpha$. For each of Alice’s strings $X^i$ with length $L/\alpha$, we produce $X^{i,\alpha }$ (with length $L$) by concatenating $\alpha$ copies of $X^i$, and likewise we produce $Y^{i,\alpha }$ for each of Bob’s strings $Y^i$. The setup where Alice has strings $\left(X^{1,\alpha },\dots ,X^{t,\alpha }\right)$ and Bob has strings $\left(Y^{1,\alpha },\dots ,Y^{t,\alpha }\right)$ is an instance of $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,\alpha )$. From Lemma 5.3, the communication complexity of $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L/\alpha ,1)$ is $\mathrm{\Omega }(tL/\alpha )$. Thus, the communication complexity of $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,\alpha )$ is $\mathrm{\Omega }(tL/\alpha )$. □

5.2. Graph Construction

Inspired by the graph construction from [ER18], given two strings $x,y\in {\{0,1\}}^N$, we construct a graph $G_{x,y}(V,E)$ such that $V$ is partitioned into $A$, $A^{\prime }$, $B$ and $B^{\prime }$, where $\left|A\right|=\left|A^{\prime }\right|=\left|B\right|=\left|B^{\prime }\right|=\sqrt{N}=\ell$. Note that since ${\ell }^2=N$, we can index the bits in $x$ by $x_{i,j}$, where $1\le i$, $j\le \ell$. We construct the edges $E$ according to the following rule:

$$\left\{\begin{array}{ll}(a_i,b_j^{\prime }),(b_i,a_j^{\prime })\in E& \text{if}{x}_{i,j}=y_{i,j}=1\\ (a_i,a_j^{\prime }),\left(b_i,b_j^{\prime }\right)\in E& \text{otherwise}\end{array}\right.$$

Figure 2 illustrates an example of the graph $G_{x,y}(V,E)$ when $x=000000100$ and $y=100010100$.

Figure 2:

Example of $G_{x,y}(V,E)$ where $x=000000100$ and $y=100010100$. The red edges represent the intersection at $x_{31}=y_{31}=1$. The green edges represent all the non-intersections in $x$ and $y$.

We will show that under certain assumptions about $N$ and $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)$, the number of intersections in $x,y$ is twice the size of the minimum cut in $G_{x,y}$.

Lemma 5.5.

Given $x,y\in {\{0,1\}}^N$, if $\sqrt{N}\ge 3\cdot \mathrm{I}\mathrm{N}\mathrm{T}(x,y)$, then $\mathrm{M}\mathrm{I}\mathrm{N}\mathrm{C}\mathrm{U}\mathrm{T}\left(G_{x,y}\right)=2\cdot \mathrm{I}\mathrm{N}\mathrm{T}(x,y)$.

Proof.

To prove this, we use some properties about $\gamma$-connectivity of a graph. A graph is $\gamma$-connected if at least $\gamma$ edges must be removed from $G$ to disconnect it. In other words, if a graph $G$ is $\gamma$-connected, then $\mathrm{M}\mathrm{I}\mathrm{N}\mathrm{C}\mathrm{U}\mathrm{T}(G)\ge \gamma$. Equivalently, a graph $G$ is $\gamma$-connected if for every $u,v\in V$, there are at least $\gamma$ edge-disjoint paths between $u$ and $v$. Therefore, given $\mathrm{I}\mathrm{N}\mathrm{T}(x,y)=\gamma$, if we can show that $G_{x,y}$ is $2\gamma$-connected and there exists one cut of size exactly $2\gamma$, then we can show $\mathrm{M}\mathrm{I}\mathrm{N}\mathrm{C}\mathrm{U}\mathrm{T}\left(G_{x,y}\right)\ge 2\gamma$. By the construction of the graph, it is easy to see that $\mathrm{C}\mathrm{U}\mathrm{T}\left(A\cup A^{\prime },B\cup B^{\prime }\right)$ has size $2\gamma$, since each intersection of $x$, $y$ produces two crossing edges in between. Therefore, all we need to show here is that if $\sqrt{N}\ge 3\cdot \gamma$, then $G_{x,y}$ is $2\gamma$-connected.

Similar to [ER18], we prove this by looking at each pair of $u,v\in V$. Our goal is to show that for every $u,v\in V$, there exist at least $2\gamma$ edge-disjoint paths from $u$ to $v$.

Case 1.

$u,v\in A$ (or symmetrically $u,v\in A^{\prime },B,B^{\prime }$). For each pair $u,v\in A$, we have that there are at least $\ell -\gamma$ distinct common neighbors in $A^{\prime }$. This is because one intersection at $x_{ij}$ and $y_{ij}$ implies that the edge $(a_i,a_j^{\prime })$ is not contained in $E$, and would remove at most one common neighbor in $A^{\prime }$. Since $\ell =\sqrt{N}\ge 3\gamma$, we have that there are at least $\ell -\gamma \ge 2\gamma$ distinct common neighbors in $A^{\prime }$, which we denote by $u_1^{A^{\prime }},u_2^{A^{\prime }},\dots ,u_{2\gamma }^{A^{\prime }}$. Therefore, each path $u\to u_i^{A^{\prime }}\to v$ is edge-disjoint, and we have at least $2\gamma$ edge-disjoint paths from $u$ to $v$, as shown in Figure 3.

Figure 3:

$u,v\in A$. We omit all the $(a_i,b_j^{\prime })$, $(b_i,b_j^{\prime })$, and $(b_i,a_j^{\prime })$ edges.

Case 2.

$u\in A$, $v\in A^{\prime }$ (or symmetrically $u\in B$, $v\in B^{\prime }$). Since $\ell -\gamma \ge 2\gamma$, we have that $v$ has at least $2\gamma$ distinct neighbors in $A$, which we denote by $u_1^A,u_2^A,\dots ,u_{2\gamma }^A$. From Case 1, we also have that each $u_i^A$ has at least $2\gamma$ distinct common neighbors in $A^{\prime }$. Therefore, we can choose $v_1^{A^{\prime }},v_2^{A^{\prime }},\dots ,v_{2\gamma }^{A^{\prime }}$ such that each path $u\to v_i^{A^{\prime }}\to u_i^A\to v$ is edge-disjoint, so we have at least $2\gamma$ edge-disjoint paths from $u$ to $v$, as shown in Figure 4. Note that it may be the case where $u_i^A=u$. In this case, we can simply take the edge $(u,v)$ to be one of the edge-disjoint paths.

Figure 4:

$\in A$, $v\in A^{\prime }$. We omit all the $(a_i,b_j^{\prime })$, $(b_i,b_j^{\prime })$, and $(b_i,a_j^{\prime })$ edges. The green edges exist since $v$ has at least $2\gamma$ neighbors in $A$. The orange edges exist since $u_i^A$ and $u$ have at least $2\gamma$ common neighbors in $A^{\prime }$.

Case 3.

$u\in A$, $v\in B^{\prime }$ (or symmetrically $u\in A^{\prime }$, $v\in B$). In this case, we show two sets of edge-disjoint paths, where each set has at least $\gamma$ edge-disjoint paths from $u$ to $v$, and the two sets of paths do not overlap. Overall, we have at least $2\gamma$ edge-disjoint paths.

The first set of paths $S_1$ uses the edges between $A^{\prime }$ and $B$. Let $\left(w_1,x_1\right),\left(w_2,x_2\right),\dots ,\left(w_{\gamma },x_{\gamma }\right)\in A^{\prime }\times B$ be the edges between $A^{\prime }$ and $B$. Each of these edges represents one intersection in $x$ and $y$. Therefore, there are exactly $\gamma$ of them. From Case 2, we have that for every $w_i$, there are $2\gamma$ edge-disjoint paths from $u$ to $w_i$. Hence, for every $w_i$, we can choose a path from $u$ to $w_i$ and these $\gamma$ paths are edge-disjoint. Figure 5 illustrates the paths $u\to u_i\to u_i^{\prime }\to w_i\to x_i$. By symmetry, we can extend the paths from $x_i$ to $v$. This gives us $\gamma$ edge-disjoint paths from $u$ to $v$.

Figure 5:

$\in A$, $v\in B^{\prime }$. The first set of paths $S_1$ goes from $u\to u_i\to u_i^{\prime }\to w_i\to x_i$. We omit the paths from $x_i$ to $v$, as they are symmetric to the paths from $w_i$ to $u$. Once we extend the paths from $x_i$ to $v$, we have $\gamma$ edge-disjoint paths from $u$ to $v$. Note that the $w_i$ and $x_i$ may not be distinct.

We now consider the second set of paths $S_2$. Let

$$\left(y_1,z_1\right),\left(y_2,z_2\right),\dots ,\left(y_{\gamma },z_{\gamma }\right)\in A\times B^{\prime }$$

be the distinct edges between $A$ and $B^{\prime }$. Once again, it suffices to prove that there are $2\gamma$ edge-disjoint paths from $u$ to $y_i$, since the paths between $v$ to $z_i$ would be symmetric. From Case 1, we have that for every $y_i$, there are at least $2\gamma$ common neighbors between $y_i$ and $u$. Therefore, we can always find distinct $u_1^{″},u_2^{″},\dots ,u_{\gamma }^{″}$ such that the paths $u\to u_i^{″}\to y_i$ are edge-disjoint, as shown in Figure 6. Once we extend the paths from $z_i$ to $v$, we have $\gamma$-edge disjoint paths in the second set.

Figure 6:

$\in A$, $v\in B^{\prime }$. The second set of paths $S_2$ goes from $u\to u_i^{″}\to y_i\to z_i$. We omit the paths from $z_i$ to $v$, as they are symmetric to the paths from $y_i$ to $u$. Once we extend the paths from $x_i$ to $v$, we have $\gamma$ edge-disjoint paths from $u$ to $v$. Note that the $y_i$ and $z_i$ may not be distinct.

Now we have two sets of paths $S_1$ and $S_2$, where both sets have at least $\gamma$ edge-disjoint paths. It remains to show that the paths in $S_1$ and $S_2$ can be edge-disjoint. Observe that the only possible edge overlaps between the paths from $u$ to the $w_i$ and paths from $u$ to the $y_i$ are $u\to u_i^{″}$ and $u\to u_i$, since they are both neighbors of $u$. However, note that what we have shown is that for every $w_i$ or $y_i$, there are at least $2\gamma$ edge-disjoint paths from $u$ to $w_i$ or $y_i$. Therefore, one can choose $2\gamma$ edge-disjoint paths from $u$ to $w_i$ and $y_i$ such that $u_i^{\prime }$ and $u_i^{″}$ do not overlap. And similarly one can choose $2\gamma$ edge-disjoint paths from $v$ to the $z_i$ and the $x_i$. Overall, we have $2\gamma$ edge-disjoint paths from $u$ to $v$.

Case 4.

$u\in A$, $v\in B$ (or symmetrically $u\in A^{\prime }$, $v\in B^{\prime }$). This case is similar to Case 3, where we have two edge-disjoint sets $S_1^{\prime }$ and $S_2^{\prime }$. Consider the set of paths $S_1^{\prime }$, where we use the edges

$$\left(w_1,x_1\right),\left(w_2,x_2\right),\dots ,\left(w_{\gamma },x_{\gamma }\right)\in A^{\prime }\times B.$$

We can construct the paths from $u$ to $w_i$ using the same way as for $S_1$ in Case 3 (Figure 5). For the paths from $x_i$ to $v$, however, we construct them using the same way as in $S_2$ in Case 3 (Figure 6). By connecting these paths, we obtain at least $\gamma$ edge-disjoint paths in $S_1^{\prime }$. Similarly, we can also construct at least $\gamma$ edge-disjoint paths in $S_2^{\prime }$, where we use the edges

$$\left(y_1,z_1\right),\left(y_2,z_2\right),\dots ,\left(y_{\gamma },z_{\gamma }\right)\in A\times B^{\prime }.$$

We follow the same way of choosing the paths in $S_1^{\prime }$ and $S_2^{\prime }$ that are edge-disjoint. □

5.3. Reducing 2-SUM to MINCUT

In this section, we use the graph constructions in Section 5.2 to reduce the $2-\mathrm{S}\mathrm{U}\mathrm{M}(t,L,\alpha )$ problem to MINCUT and derive a lower bound on the number of queries in the local query model.

Lemma 5.6.

Given $M,\lambda >0$, and $0<\epsilon <1$, suppose that we have any algorithm $𝒜$ that can estimate the size of the minimum cut of a graph up to a $(1\pm \epsilon )$ multiplicative factor with $T$ expected queries in the local query model. Then there exists an algorithm $ℬ$ that can approximate $2-\mathrm{S}\mathrm{U}\mathrm{M}\left({\epsilon }^{-2},{\epsilon }^{2}M,\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}\right)$ up to an additive error $\sqrt{{\epsilon }^{-2}}={\epsilon }^{-1}$ using at most $O(T)$ bits of communication in expectation given $\sqrt{M}\ge 3\mathrm{m}\mathrm{a}\mathrm{x}\left\{\lambda ,{\epsilon }^{-2}\right\}$.

Proof.

We will show that the following algorithm $ℬ$ satisfies the above conditions:

1. Given Alice’s strings $(X^1,\dots ,X^{{\epsilon }^{-2}})$ each of length ${\epsilon }^{2}M$, let $x$ be the concatenation of Alice’s strings having total length ${\epsilon }^{-2}\left({\epsilon }^{2}M\right)=M$. Similarly let $y\in {\{0,1\}}^M$ be the concatenation of Bob’s strings.

2. Construct a graph $G_{x,y}$ as in Section 5.2 using the above concatenated strings as $x$, $y$.

3. Run $𝒜\left(G_{x,y}\right)$ and output $(\frac{1}{{\epsilon }^2}-\frac{𝒜\left(G_{x,y}\right)}{2\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}})$ as the solution to $2-\mathrm{S}\mathrm{U}\mathrm{M}\left({\epsilon }^{-2},{\epsilon }^{2}M,\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}\right)$.

For the 2-SUM problem, let $r={\epsilon }^{-2}-{\sum }_{i\in \left[{\epsilon }^{-2}\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(X^i,Y^i\right)$ be the number of string pairs with intersections. Since there are ${\epsilon }^{-2}$ pairs $\left(X^i,Y^i\right),r$ is at most ${\epsilon }^{-2}$. From our definition of 2-SUM, each intersecting string pair has $\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}$ intersections. $x,y$ are formed by concatenations, so $\mathrm{I}\mathrm{N}\mathrm{T}\left(x,y\right)=r\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}$. Since $\sqrt{M}\ge 3\mathrm{m}\mathrm{a}\mathrm{x}\left\{\lambda ,{\epsilon }^{-2}\right\}=3{\epsilon }^{-2}\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}\ge 3r\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}=3\cdot \mathrm{I}\mathrm{N}\mathrm{T}(x,y)$, Lemma 5.5 is applicable to $G_{x,y}$ so that

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{C}\mathrm{U}\mathrm{T}\left(G_{x,y}\right)=2r\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}.$$

Since $𝒜$ approximates MINCUT up to a ($1\pm \epsilon$) factor, $𝒜\left(G_{x,y}\right)=2r(1\pm \epsilon )\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}$. Thus, $ℬ$ ‘s output to the 2-SUM problem is within $\left({\epsilon }^{-2}-r\right)\pm r\epsilon ={\sum }_{i\in \left[{\epsilon }^{-2}\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(X^i,Y^i\right)\pm r\epsilon$. Recall that $r\le {\epsilon }^{-2}$. We can see that $ℬ$ approximates $2-\mathrm{S}\mathrm{U}\mathrm{M}\left({\epsilon }^{-2},{\epsilon }^{2}M\right.,\left.\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}\right)$ up to additive error ${\epsilon }^{-1}$.

To compare the complexities of $𝒜$ and $ℬ$, recall $𝒜$ is measured by degree, neighbor, and pair queries, whereas $ℬ$ is measured by bits of communication. Given the construction of $G_{x,y}$, as shown in [ER18], degree, neighbor, and pair queries can each be simulated using at most 2 bits of communication:

• Degree queries: each vertex in $G_{x,y}$ has degree $\sqrt{M}$ so Alice and Bob do not need to communicate to simulate degree queries.

• Neighbor queries: assuming an ordering where $a_i$ ‘s j’th neighbor is either $a_j^{\prime }$ or $b_j^{\prime }$, Alice and Bob can exchange $x_{i,j}$ and $y_{i,j}$ with 2 bits of communication to simulate a neighbor query.

• Pair queries: Alice and Bob can exchange $x_{i,j}$ and $y_{i,j}$ with 2 bits of communication to determine whether edges $(a_i,b_j^{\prime })$ and $(b_i,a_j^{\prime })$ exist.

As each of $𝒜$’s queries can be simulated using up to 2 bits of communication in $ℬ$, $ℬ$ can use $O(T)$ bits of communication to simulate $T$ queries in $𝒜$. So we have established a reduction from approximating $2-\mathrm{S}\mathrm{U}\mathrm{M}\left({\epsilon }^{-2},{\epsilon }^{2}M,\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^2\lambda ,1\right\}\right)$ up to additive error ${\epsilon }^{-1}$ to approximating MINCUT up to a ($1\pm \epsilon$) multiplicative factor. □

We are now ready to prove Theorem 1.3.

Proof of Theorem 1.3.

Given an instance of $2-\mathrm{S}\mathrm{U}\mathrm{M}\left({\epsilon }^{-2},{\epsilon }^{2}m,\mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^{2}k,1\right\}\right)$, consider the same way of constructing the graph $G_{x,y}$ in Lemma 5.6. From the construction of $G_{x,y}$, the number of edges is $2m$ since each of pair $\left(x_i,y_i\right)$ corresponds to 2 edges. Using the promise from 2-SUM, we get that $r\ge {\epsilon }^{-2}/1000$, where $r={\sum }_{i\in \left[{\epsilon }^{-2}\right]} \mathrm{D}\mathrm{I}\mathrm{S}\mathrm{J}\left(X^i,Y^i\right)$, which means that the size of the minimum cut of $G_{x,y}$ is $2r\cdot \mathrm{m}\mathrm{a}\mathrm{x}\left\{{\epsilon }^{2}k,1\right\}\ge \mathrm{\Omega }\left(\mathrm{m}\mathrm{a}\mathrm{x}\left\{k,{\epsilon }^{-2}\right\}\right)$. When $k\ge {\epsilon }^{-2}$, we have that the size of the minimum cut of $G_{x,y}$ is $\mathrm{\Omega }(k)$, and from Lemma 5.6 we obtain that any algorithm $𝒜$ that satisfies the guarantee on the distribution of $G_{x,y}$ must have $\mathrm{\Omega }\left(m/\left({\epsilon }^{2}k\right)\right)$ queries in expectation. When $k<{\epsilon }^{-2}$, the size of the minimum cut of $G_{x,y}$ is $\mathrm{\Omega }\left({\epsilon }^{-2}\right)$ and similarly we get that any algorithm $𝒜$ that satisfies the guarantee on the distribution of $G_{x,y}$ must use $\mathrm{\Omega }(m)$ queries in expectation. Combining the two, we finally obtain an $\mathrm{\Omega }(\mathrm{m}\mathrm{i}\mathrm{n}\{m,\frac{m}{{\epsilon }^{2}k}\})$ lower bound on the expected number of queries in the local query model. □

5.4. Almost Matching Upper Bound

In this section, we will show that our lower bound is tight up to logarithmic factors. In the work of [BGMP21], the authors presented an algorithm that uses $O(\frac{m}{k}\cdot \mathrm{p}\mathrm{o}\mathrm{l}\mathrm{y}(\log n,1/\epsilon ))$ queries, where $k$ is the size of the minimum cut. We will show that, despite their analysis giving a dependence of $1/{\epsilon }^4$, a slight modification of their algorithm yields a dependence of $1/{\epsilon }^2$. Formally, we have the following theorem.

Theorem 5.7 (essentially [BGMP21]).

There is an algorithm that solves the minimum cut query problem up to a $(1\pm \epsilon )$-multiplicative factor with high constant probability in the local query model. Moreover, the expected number of queries used by this algorithm is $\tilde{O}\left(\frac{m}{{\epsilon }^{2}k}\right)$.

To prove Theorem 5.7, we first give a high-level description of the algorithm in [BGMP21]. The algorithm is based on the following sub-routine.

Lemma 5.8 ([BGMP21]).

There exists an algorithm Verify-Guess $(D,t,\epsilon )$ which makes $\tilde{O}\left({\epsilon }^{-2}m/t\right)$ queries in expectation such that (here $D$ is the degree of each node)

1. If $t\ge \frac{2000\mathrm{l}\mathrm{o}\mathrm{g}n}{{\epsilon }^2}\cdot k$, then $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ rejects $t$ with probability at least $1-\frac{1}{\text{poly}(n)}$.

2. If $t\le k$, then $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ accepts $t$ and outputs a $(1\pm \epsilon )$-approximation of $k$ with probability at least $1-\frac{1}{\mathrm{p}\mathrm{o}\mathrm{l}\mathrm{y}(n)}$.

Given the above sub-routine, the algorithm initializes a guess $t=\frac{n}{2}$ for the value of the minimum cut $k$ and proceeds as follows:

• if $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ rejects $t$, set $t=t/2$ and repeat the process.

• if $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ accepts $t$, set $t=t/\kappa$ where $\kappa =\frac{2000\mathrm{l}\mathrm{o}\mathrm{g}n}{{\epsilon }^2}$. Let $\tilde{k}=\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ and return the value of $\tilde{k}$ as the output.

To analyze the query complexity of the algorithm, notice that when Verify-Guess first accepts $t$, we have that $\frac{k}{2}<t<\kappa k$. which means that $t/\kappa <k$ and hence one call to $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t/\kappa ,\epsilon )$ will get the desired output. However, at a time in $t=\mathrm{\Theta }(k/\kappa )$, the Verify-Guess procedure needs to make $\tilde{O}\left(\frac{m}{{\epsilon }^{4}k}\right)$ queries in expectation.

To avoid this, the crucial observation is that, during the above binary search process, the error parameter of $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t,\epsilon )$ does not have to be set to $\epsilon$. Using a small constant ${\beta }_0$ is sufficient. This way, when Verify-Guess $\left(D,t,{\beta }_0\right)$ first accepts $t$, we have $\frac{k}{2}<t<c\mathrm{l}\mathrm{o}\mathrm{g}(n)\cdot k$, where $c$ is a constant. Consequently, the output of $\mathrm{V}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{f}\mathrm{y}-\mathrm{G}\mathrm{u}\mathrm{e}\mathrm{s}\mathrm{s}(D,t/(c\mathrm{l}\mathrm{o}\mathrm{g}n),\epsilon )$ will satisfy the error guarantee. Using the analysis in [BGMP21], we can show that the query complexity of the new algorithm is $\tilde{O}\left(\frac{m}{{\epsilon }^{2}k}\right)$.