Epsilon-CUT: Optimal Graph Sketching

• The paper establishes that any ε-cut sketching scheme must use Ω(n log n/ε²) bits by combining rigidity phenomena and information-theoretic counting arguments.
• Epsilon-CUT defines a sketch which, for every cut in an undirected graph, guarantees a (1±ε) multiplicative approximation of the Laplacian quadratic form.
• The analysis leverages regular graph properties and compares cut and spectral sparsifiers to confirm that existing sparsifier constructions are asymptotically optimal.

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" (Carlson et al., 2017), 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 (Carlson et al., 2017).

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 $(1\pm\epsilon)$0. This identifies cut sketching with approximation of Laplacian quadratic forms on the discrete cube (Carlson et al., 2017).

The paper defines two sketch notions. An $(1\pm\epsilon)$1-spectral sketch of $(1\pm\epsilon)$2 is a function $(1\pm\epsilon)$3 such that for every $(1\pm\epsilon)$4,

$(1\pm\epsilon)$5

An $(1\pm\epsilon)$6-cut sketch is the same guarantee restricted to $(1\pm\epsilon)$7. In the Epsilon-CUT problem, the requirement is the latter: for every cut $(1\pm\epsilon)$8, equivalently every $(1\pm\epsilon)$9,

$\{-1,1\}^n$0

A sketching scheme consists of a deterministic map

$\{-1,1\}^n$1

together with storage and evaluation procedures for $\{-1,1\}^n$2. 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 (Carlson et al., 2017).

2. Relation to cut and spectral sparsifiers

The standard comparison object is a sparsifier. An $\{-1,1\}^n$3-spectral sparsifier of $\{-1,1\}^n$4 is a weighted graph $\{-1,1\}^n$5 on the same vertex set such that for all $\{-1,1\}^n$6,

$\{-1,1\}^n$7

equivalently $\{-1,1\}^n$8. An $\{-1,1\}^n$9-cut sparsifier imposes the same inequality only for $\Theta(n\log n/\epsilon^2)$0, equivalently

$\Theta(n\log n/\epsilon^2)$1

Spectral sparsification implies cut sparsification, but not conversely. Any spectral sparsifier yields a spectral sketch by taking $\Theta(n\log n/\epsilon^2)$2; 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 (Carlson et al., 2017).

The upper bound quoted in the paper is $\Theta(n\log n/\epsilon^2)$3 bits. The reason is that $\Theta(n\log n/\epsilon^2)$4-spectral sparsifiers with $\Theta(n\log n/\epsilon^2)$5 edges are known, and each edge weight can be stored with $\Theta(n\log n/\epsilon^2)$6 bits, for example by discretization to precision $\Theta(n\log n/\epsilon^2)$7. The paper states that the result of Batson–Spielman–Srivastava produces $\Theta(n\log n/\epsilon^2)$8-spectral sparsifiers with $\Theta(n\log n/\epsilon^2)$9 edges, which yield $G$0-spectral sketches with $G$1 bits, so the lower bound it proves is tight up to a factor of $G$2 (Carlson et al., 2017).

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 $G$3, any $G$4-cut sketching scheme for graphs with $G$5 vertices must use at least

$G$6

bits in the worst case. With the proof’s choice of degree $G$7, this becomes

$G$8

bits (Carlson et al., 2017).

This improves the earlier lower bound $G$9 for cut sketches proved in "The Sketching Complexity of Graph Cuts" (Andoni et al., 2014). The extra $A_G$0 factor is the decisive refinement, because the sparsifier upper bounds already imply $A_G$1 bits. The 2017 result therefore shows that arbitrary data structures with arbitrary decoding procedures cannot asymptotically beat the storage cost of sparsifiers (Carlson et al., 2017).

The paper proves an analogous theorem for full spectral sketching. For any $A_G$2, any $A_G$3-spectral sketching scheme must use at least

$A_G$4

bits in the worst case, again yielding $A_G$5 after expressing the construction in terms of $A_G$6. This shows that restricting attention from all quadratic forms to cut vectors does not improve the asymptotic worst-case space bound (Carlson et al., 2017).

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 $A_G$7 and $A_G$8 are simple $A_G$9-regular graphs satisfying

$D_G$0

then they must have at least

$D_G$1

edges in common. Thus, for $D_G$2, the overlap is almost complete (Carlson et al., 2017).

The proof uses the identity $D_G$3 for $D_G$4-regular graphs. Spectral approximation implies

$D_G$5

Passing to Frobenius norm gives

$D_G$6

Because $D_G$7 has entries in $D_G$8, this Frobenius norm also equals $D_G$9, which yields the overlap bound.

For Epsilon-CUT itself, the paper needs a cut-only analogue. If $L_G = D_G - A_G.$0 and $L_G = D_G - A_G.$1 are simple $L_G = D_G - A_G.$2-regular bipartite graphs with the same bipartition and

$L_G = D_G - A_G.$3

then they must have at least

$L_G = D_G - A_G.$4

edges in common (Carlson et al., 2017).

The proof is by contrapositive. Writing $L_G = D_G - A_G.$5, the argument seeks $L_G = D_G - A_G.$6 such that $L_G = D_G - A_G.$7 is too large for cut approximation to hold. The construction uses a Goemans–Williamson style rounding: first build vectors from columns of $L_G = D_G - A_G.$8, normalize them to $L_G = D_G - A_G.$9, then sample a random hyperplane and set

$x\in\{-1,1\}^n$0

Using

$x\in\{-1,1\}^n$1

and $x\in\{-1,1\}^n$2, the paper shows that a sufficiently large symmetric difference between $x\in\{-1,1\}^n$3 and $x\in\{-1,1\}^n$4 produces a cut vector violating the $x\in\{-1,1\}^n$5 condition. The rigidity lemma follows (Carlson et al., 2017).

5. Counting argument and proof architecture

Rigidity alone is qualitative; the lower bound emerges by combining it with counting. The proof restricts attention to $x\in\{-1,1\}^n$6-regular bipartite graphs on a fixed bipartition $x\in\{-1,1\}^n$7, with

$x\in\{-1,1\}^n$8

and in the cut case specifically

$x\in\{-1,1\}^n$9

Let $x^\top L_G x$0 denote this family (Carlson et al., 2017).

The number of $x^\top L_G x$1-regular graphs is controlled using asymptotic enumeration. For $x^\top L_G x$2,

$x^\top L_G x$3

Using the bipartite double-cover argument, the paper obtains

$x^\top L_G x$4

The next step bounds how many graphs can share a single sketch. If a function $x^\top L_G x$5 is an $x^\top L_G x$6-cut sketch for two graphs $x^\top L_G x$7, then $x^\top L_G x$8 and $x^\top L_G x$9 $(1\pm\epsilon)$00-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

$(1\pm\epsilon)$01

bits, and with the chosen $(1\pm\epsilon)$02 this simplifies to

$(1\pm\epsilon)$03

A pigeonhole argument then compares the total number of graphs with the maximum number represented by one sketch: $(1\pm\epsilon)$04 where $(1\pm\epsilon)$05 is the number of distinct sketches. Substituting $(1\pm\epsilon)$06 yields

$(1\pm\epsilon)$07

which is exactly the desired lower bound on sketch size (Carlson et al., 2017).

This proof is explicitly information-theoretic. The paper does not rely on communication complexity for the new lower bound, unlike the earlier $(1\pm\epsilon)$08 result (Andoni et al., 2014). A plausible implication is that the missing $(1\pm\epsilon)$09 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: $(1\pm\epsilon)$10 The upper bound comes from spectral sparsifiers; the lower bound shows that no alternative sketching formalism can asymptotically do better on worst-case graphs (Carlson et al., 2017).

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)$11 accuracy from a stored state. The paper explicitly notes that none of these models can use asymptotically fewer than $(1\pm\epsilon)$12 bits in the worst case (Carlson et al., 2017).

The scope is limited in several ways. The lower bounds are proved for undirected graphs. The hard instances are unweighted simple $(1\pm\epsilon)$13-regular graphs, and in the cut-rigidity lemma specifically simple $(1\pm\epsilon)$14-regular bipartite graphs. The asymptotic statement is given for

$(1\pm\epsilon)$15

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 $(1\pm\epsilon)$16-bit upper bounds and $(1\pm\epsilon)$17-bit lower bounds for arbitrary sketches (Andoni et al., 2014).

Within its stated scope, however, the paper establishes that approximating every cut of a graph to multiplicative error $(1\pm\epsilon)$18 requires, and can be achieved with, $(1\pm\epsilon)$19 bits. In that sense, the space complexity of Epsilon-CUT is essentially completely understood (Carlson et al., 2017).