---
title: 'Epsilon-CUT: Optimal Graph Sketching'
url: https://www.emergentmind.com/topics/epsilon-cut
type: topic
---

# Epsilon-CUT: Optimal Graph Sketching

Searching arXiv for the specified paper and closely related work on graph-cut sketching.
Epsilon-CUT denotes the graph sketching problem of storing an undirected graph on \(n\) vertices in a compact representation that supports a multiplicative \((1\pm\epsilon)\)-approximation to **every** cut, simultaneously. In the formulation studied in "Optimal Lower Bounds for Sketching Graph Cuts" [1712.10261], the object is a sketch of the graph’s cut function, equivalently of its Laplacian quadratic form on \(\{-1,1\}^n\), and the central question is the worst-case number of bits required in the **for all** model. The paper proves that this space complexity is \(\Theta(n\log n/\epsilon^2)\) up to constant factors, via a rigidity phenomenon for regular graphs and an information-theoretic counting argument [1712.10261].

## 1. Formal definition and Laplacian formulation

For an undirected weighted graph \(G\) with adjacency matrix \(A_G\) and degree matrix \(D_G\), the Laplacian is
\[
L_G = D_G - A_G.
\]
If a cut is encoded by a vector \(x\in\{-1,1\}^n\), then \(x^\top L_G x\) is proportional to the cut weight \(w(\delta(S))\). This identifies cut sketching with approximation of Laplacian quadratic forms on the discrete cube [1712.10261].

The paper defines two sketch notions. An \(\epsilon\)-spectral sketch of \(G\) is a function \(f:\mathbb{R}^n\to\mathbb{R}\) such that for every \(x\in\mathbb{R}^n\),
\[
(1-\epsilon)x^\top L_G x \le f(x)\le (1+\epsilon)x^\top L_G x.
\]
An \(\epsilon\)-cut sketch is the same guarantee restricted to \(x\in\{-1,1\}^n\). In the Epsilon-CUT problem, the requirement is the latter: for every cut \(S\subseteq V\), equivalently every \(x\in\{-1,1\}^n\),
\[
(1-\epsilon)x^\top L_G x \le f(x)\le (1+\epsilon)x^\top L_G x.
\]

A sketching scheme consists of a deterministic map
\[
sk : \{\text{graphs on } n \text{ vertices}\} \to \{\text{functions } f\},
\]
together with storage and evaluation procedures for \(f\). The model explicitly ignores time complexity and measures only the number of bits needed to store the sketch. The decisive feature is the **for all** guarantee: a single stored object must answer all cut queries correctly for the input graph [1712.10261].

## 2. Relation to cut and spectral sparsifiers

The standard comparison object is a sparsifier. An \(\epsilon\)-spectral sparsifier of \(G\) is a weighted graph \(H\) on the same vertex set such that for all \(x\in\mathbb{R}^n\),
\[
(1-\epsilon)x^\top L_G x \le x^\top L_H x\le (1+\epsilon)x^\top L_G x,
\]
equivalently \((1-\epsilon)L_G \preceq L_H \preceq (1+\epsilon)L_G\). An \(\epsilon\)-cut sparsifier imposes the same inequality only for \(x\in\{-1,1\}^n\), equivalently
\[
(1-\epsilon)L_G\preceq_\square L_H\preceq_\square (1+\epsilon)L_G.
\]

Spectral sparsification implies cut sparsification, but not conversely. Any spectral sparsifier yields a spectral sketch by taking \(f(x)=x^\top L_H x\); any cut sparsifier yields a cut sketch in the same way. Consequently, sparsifiers provide upper bounds for Epsilon-CUT: store the sparsifier itself as the sketch [1712.10261].

The upper bound quoted in the paper is \(O(n\log n/\epsilon^2)\) bits. The reason is that \(\epsilon\)-spectral sparsifiers with \(O(n/\epsilon^2)\) edges are known, and each edge weight can be stored with \(O(\log n)\) bits, for example by discretization to precision \(1/n^4\). The paper states that the result of Batson–Spielman–Srivastava produces \(\epsilon\)-spectral sparsifiers with \(16n/\epsilon^2\) edges, which yield \(\epsilon\)-spectral sketches with \(64n\lg n/\epsilon^2\) bits, so the lower bound it proves is tight up to a factor of \(64\cdot 500\) [1712.10261].

## 3. Optimal lower bound for storing all cuts

The main Epsilon-CUT theorem is a worst-case lower bound for deterministic sketching schemes in the for-all model. For any \(\epsilon=\omega(n^{-1/4})\), any \(\epsilon\)-cut sketching scheme for graphs with \(n\) vertices must use at least
\[
\frac{n\lg n}{2304^2}\cdot (1-o_n(1))
\]
bits in the worst case. With the proof’s choice of degree \(d=1/(16\cdot 9\epsilon^2)\), this becomes
\[
\Omega\!\left(\frac{n\log n}{\epsilon^2}\right)
\]
bits [1712.10261].

This improves the earlier lower bound \(\Omega(n/\epsilon^2)\) for cut sketches proved in "The Sketching Complexity of Graph Cuts" [1403.7058]. The extra \(\log n\) factor is the decisive refinement, because the sparsifier upper bounds already imply \(O(n\log n/\epsilon^2)\) bits. The 2017 result therefore shows that arbitrary data structures with arbitrary decoding procedures cannot asymptotically beat the storage cost of sparsifiers [1712.10261].

The paper proves an analogous theorem for full spectral sketching. For any \(\epsilon=\omega(n^{-1/4})\), any \(\epsilon\)-spectral sketching scheme must use at least
\[
\frac{n\lg n}{500^2}\cdot (1-o_n(1))
\]
bits in the worst case, again yielding \(\Omega(n\log n/\epsilon^2)\) after expressing the construction in terms of \(\epsilon\). This shows that restricting attention from all quadratic forms to cut vectors does not improve the asymptotic worst-case space bound [1712.10261].

## 4. Rigidity of cut and spectral approximation

The key structural ingredient is a rigidity phenomenon: if two regular graphs approximate each other too well, then they must share many edges. The spectral version states that if \(G\) and \(H\) are simple \(d\)-regular graphs satisfying
\[
(1-\epsilon)L_G \preceq L_H \preceq (1+\epsilon)L_G,
\]
then they must have at least
\[
\frac{dn}{2}\left(1-\frac{\epsilon^2 d}{2}\right)
\]
edges in common. Thus, for \(\epsilon \ll 1/\sqrt d\), the overlap is almost complete [1712.10261].

The proof uses the identity \(L_G=dI-A_G\) for \(d\)-regular graphs. Spectral approximation implies
\[
\|A_G-A_H\| = \|L_H-L_G\| \le 2\epsilon d.
\]
Passing to Frobenius norm gives
\[
\|A_G-A_H\|_F^2 \le 4\epsilon^2 d^2 n.
\]
Because \(A_G-A_H\) has entries in \(\{-1,0,1\}\), this Frobenius norm also equals \(2|E(G)\Delta E(H)|\), which yields the overlap bound.

For Epsilon-CUT itself, the paper needs a cut-only analogue. If \(G\) and \(H\) are simple \(d\)-regular bipartite graphs with the same bipartition and
\[
(1-\epsilon)L_G\preceq_\square L_H\preceq_\square (1+\epsilon)L_G,
\]
then they must have at least
\[
\frac{dn}{2}(1-3\sqrt d\,\epsilon)
\]
edges in common [1712.10261].

The proof is by contrapositive. Writing \(M=L_G-L_H=A_H-A_G\), the argument seeks \(x\in\{-1,1\}^n\) such that \(x^\top M x\) is too large for cut approximation to hold. The construction uses a Goemans–Williamson style rounding: first build vectors from columns of \(I+M/\sqrt d\), normalize them to \(y_i\), then sample a random hyperplane and set
\[
x_i=
\begin{cases}
+1 & \text{if }\langle y_i,w\rangle\ge 0,\\
-1 & \text{otherwise}.
\end{cases}
\]
Using
\[
\mathbb{E}[x_i x_j] = \frac{2}{\pi}\sin^{-1}(\langle y_i,y_j\rangle)
\]
and \(\sin^{-1}(u)\ge u\), the paper shows that a sufficiently large symmetric difference between \(E(G)\) and \(E(H)\) produces a cut vector violating the \((1\pm\epsilon)\) condition. The rigidity lemma follows [1712.10261].

## 5. Counting argument and proof architecture

Rigidity alone is qualitative; the lower bound emerges by combining it with counting. The proof restricts attention to \(d\)-regular bipartite graphs on a fixed bipartition \(L\cup R\), with
\[
d = \Theta(1/\epsilon^2),
\]
and in the cut case specifically
\[
d = \frac{1}{16\cdot 9\epsilon^2}.
\]
Let \(B_{n,d}\) denote this family [1712.10261].

The number of \(d\)-regular graphs is controlled using asymptotic enumeration. For \(d=o(\sqrt n)\),
\[
\lg |G_{n,d}| \ge \frac{dn\lg(n/d)}{2}\cdot (1-o(1)) \ge \frac{dn\lg n}{4}\cdot (1-o(1)).
\]
Using the bipartite double-cover argument, the paper obtains
\[
\lg |B_{n,d}| \ge \frac{dn\lg n}{8}\cdot(1-o(1)).
\]

The next step bounds how many graphs can share a single sketch. If a function \(f\) is an \(\epsilon\)-cut sketch for two graphs \(G,H\in B_{n,d}\), then \(G\) and \(H\) \(3\epsilon\)-approximate each other’s cuts, so rigidity forces a large edge overlap. Hence any graph represented by the same sketch must lie within small symmetric difference of a reference graph. Encoding that symmetric difference uses only
\[
O(\sqrt d\,\epsilon\cdot dn\log n)
\]
bits, and with the chosen \(d\) this simplifies to
\[
\frac{dn\log n}{16}\cdot(1+o(1)).
\]

A pigeonhole argument then compares the total number of graphs with the maximum number represented by one sketch:
\[
\lg N \ge \frac{dn\lg n}{8} - \frac{dn\lg n}{16}
= \frac{dn\lg n}{16}\cdot(1-o(1)),
\]
where \(N\) is the number of distinct sketches. Substituting \(d=\Theta(1/\epsilon^2)\) yields
\[
\lg N = \Omega\!\left(\frac{n\log n}{\epsilon^2}\right),
\]
which is exactly the desired lower bound on sketch size [1712.10261].

This proof is explicitly information-theoretic. The paper does not rely on communication complexity for the new lower bound, unlike the earlier \(\Omega(n/\epsilon^2)\) result [1403.7058]. A plausible implication is that the missing \(\log n\) factor is captured by the combinatorial explosion in the number of regular graphs rather than by a direct-product argument over many independent small instances.

## 6. Consequences, scope, and limitations

The principal consequence is that the space complexity of Epsilon-CUT in the for-all model is optimal up to constant factors:
\[
\Theta\!\left(\frac{n\log n}{\epsilon^2}\right).
\]
The upper bound comes from spectral sparsifiers; the lower bound shows that no alternative sketching formalism can asymptotically do better on worst-case graphs [1712.10261].

Because the theorem is purely information-theoretic, it applies uniformly to streaming algorithms, distributed algorithms, and static preprocessing schemes whenever the requirement is to answer **all** cut queries with multiplicative \((1\pm\epsilon)\) accuracy from a stored state. The paper explicitly notes that none of these models can use asymptotically fewer than \(\Omega(n\log n/\epsilon^2)\) bits in the worst case [1712.10261].

The scope is limited in several ways. The lower bounds are proved for undirected graphs. The hard instances are unweighted simple \(d\)-regular graphs, and in the cut-rigidity lemma specifically simple \(d\)-regular bipartite graphs. The asymptotic statement is given for
\[
\epsilon=\omega(n^{-1/4}).
\]
The work is also confined to the **for all** model; it explicitly contrasts this with the **for each** model, where only a fixed query must be answered with high probability. In that weaker setting, "The Sketching Complexity of Graph Cuts" proves \(\tilde O(n/\epsilon)\)-bit upper bounds and \(\Omega(n/\epsilon)\)-bit lower bounds for arbitrary sketches [1403.7058].

Within its stated scope, however, the paper establishes that approximating every cut of a graph to multiplicative error \(1\pm\epsilon\) requires, and can be achieved with, \(\Theta(n\log n/\epsilon^2)\) bits. In that sense, the space complexity of Epsilon-CUT is essentially completely understood [1712.10261].

Source: https://www.emergentmind.com/topics/epsilon-cut