Sparsifiner: Efficient Graph Sparsification

• Sparsifiner is a framework for efficiently simulating randomized distributed graph algorithms by transforming dense graphs into sparse subgraph representations.
• It employs structured sparsification to reduce local dependencies, achieving near-optimal round complexity and sublinear memory in MPC and LCA models.
• The framework demonstrates practical improvements in solving MIS, matching, and vertex cover by compressing multi-round interactions into manageable sparse subgraphs.

Sparsifiner is a framework for the efficient simulation and locality reduction of randomized distributed algorithms in large-scale graph processing, particularly in the context of Maximal Independent Set (MIS), matching, and vertex cover problems. The central technique is a structured sparsification transformation: instead of simulating every round of a $T$-round LOCAL algorithm over the dense input topology, the algorithm performs computations on a sequence of carefully constructed sparse subgraphs, each representing a superset of the local dependencies over contiguous rounds. By leveraging sparsification, Sparsifiner simultaneously achieves near-optimal round complexity and sublinear memory or query complexity in Massively Parallel Computation (MPC) and Local Computation Algorithms (LCA) models, breaking established complexity barriers for these tasks (Ghaffari et al., 2018).

1. Sparsification Transformation for LOCAL and Parallel Algorithms

Sparsifiner divides the execution of a $T$-round LOCAL algorithm $\mathcal{A}$ on an $n$-node graph $G$ (with maximum degree $\Delta$) into phases of $R$ rounds each (where $R = \Theta(\sqrt{\log\Delta})$ for MIS and matching problems). In each phase $[t, t+R]$, it constructs a sparse subgraph $H = \bigcup_{i=1}^{R} H_i \subseteq G$, sampling edges or nodes based on the probabilistic choices made by the original algorithm in those rounds.

Matching-Approximation Example:

• In iteration $T$0, each edge $T$1 is marked independently with probability $T$2.
• Using $T$3, let $T$4, and $T$5 contains each edge with probability $T$6.
• The union $T$7 results in a subgraph with $T$8, significantly reducing the number of neighbors each node must inspect (Ghaffari et al., 2018).

MIS Example:

• For each node $T$9, a vector of $\mathcal{A}$0 i.i.d. uniform random numbers is fixed per iteration.
• Nodes are considered “relevant” for the sparsified subgraph if they or their neighbors have high-probability local events in the phase.
• Nodes are classified as “light” or “heavy” according to degree, and “good” if degree estimates remain below a threshold ($\mathcal{A}$1).
• The resulting $\mathcal{A}$2 subgraph allows deterministic simulation of the $\mathcal{A}$3 original rounds by examining only the $\mathcal{A}$4-hop neighborhood in $\mathcal{A}$5, with $\mathcal{A}$6 and $\mathcal{A}$7-ball size $\mathcal{A}$8 for sufficiently small $\mathcal{A}$9 (Ghaffari et al., 2018).

2. Algorithmic Workflows: Pseudocode and Simulation Strategy

At a high level, Sparsifiner proceeds in phases, each consisting of $n$0 rounds:

• Initialization: Set marking probabilities $n$1 for all $n$2.
• Phase $n$3 ($n$4): For $n$5 rounds,
  • If degree $n$6, a node “stalls” (probabilities are halved every round).
  • Sparsified $n$7 is constructed via local criteria.
  • Each node gathers its $n$8-hop neighborhood in $n$9 and simulates $G$0 rounds:
  • Degree estimates are obtained with $G$1 samples.
  • Probabilities are updated accordingly.
  • Marking/selection events are performed as in the original, but using only the sparsified local data.
• Stitching: After all phases, high-degree nodes are removed in a cleanup round.

This method allows nodes to determine, with high probability, their MIS or matching status by querying only a polylogarithmic-size local neighborhood in the sparsified subgraph, as opposed to the exponentially large neighborhood in the original (Ghaffari et al., 2018).

3. Complexity Results and Barrier Separation

Sparsifiner yields the following advances:

• LOCAL Model: After $G$2 rounds, with probability $G$3, all nodes are either in the MIS or have a neighbor in the MIS. The remaining subgraph has components of size $G$4 and at most $G$5 surviving nodes. The round complexity matches prior optimal results (Ghaffari et al., 2018).
• MPC Model: For any $G$6, an MPC algorithm with $G$7 memory per machine and $G$8 machines solves MIS, Maximal Matching, $G$9-Max-Matching, or $\Delta$0-approximates Min-VC in $\Delta$1 rounds. The sparsification allows $\Delta$2 LOCAL rounds to be “compressed” into $\Delta$3 MPC rounds using graph-exponentiation, as long as the local $\Delta$4-ball fits in memory (Ghaffari et al., 2018).
• LCA Model: There is an LCA for MIS with query complexity $\Delta$5. This is achieved by recursively splitting the $\Delta$6 rounds into halved-length subphases down to $\Delta$7, and the sparsified subgraph $\Delta$8 is sufficiently small for local exploration and simulation, circumventing the $\Delta$9 query lower bound of classic approaches (Ghaffari et al., 2018).

4. Technical Innovations: Locality-Volume and Simulation Efficiency

Key innovations underlying Sparsifiner include:

• Locality-Volume: The relevant measure is not the raw $R$0-hop neighborhood size ($R$1), but the number of graph elements each node truly depends on in the sparsification. Oversampling creates supersets of “relevant” neighbors, greatly reducing simulation volume compared to Parnas–Ron–style approaches (Ghaffari et al., 2018).
• Degree Stalling and Adaptive Sampling: Nodes with intractably high degree stall their participation, maintaining sparsity in $R$2 without hindering global progress.
• MPC Graph Exponentiation: The $R$3-hop simulation, enabled by bounded $R$4-ball size in $R$5, is mapped efficiently across machines, aggregating neighborhoods in $R$6 MPC rounds.
• Recursive LCA Simulation: Subphases are simulatable in $R$7 queries, and the recurrence for overall queries solves to $R$8 (Ghaffari et al., 2018).

5. Concrete Example: Matching Approximation with Sparsifiner

In a basic LOCAL matching algorithm, nodes mark incident edges by increasing probabilities, isolated marked edges are added to the matching, and high-degree endpoints are deleted. With Sparsifiner:

• Phases of $R$9 iterations use elevated sampling ($R = \Theta(\sqrt{\log\Delta})$0).
• $R = \Theta(\sqrt{\log\Delta})$1 has $R = \Theta(\sqrt{\log\Delta})$2 with high probability.
• Nodes resample incident $R = \Theta(\sqrt{\log\Delta})$3-edges to emulate marking events, simulate isolation, and execute matching, all within the sparsified locality.
• Guarantees: $R = \Theta(\sqrt{\log\Delta})$4 locality-volume, $R = \Theta(\sqrt{\log\Delta})$5 rounds, and a constant fraction of removed nodes matched per iteration (Ghaffari et al., 2018).

6. Impact, Limitations, and Theoretical Significance

Sparsifiner achieves:

• The first sublogarithmic-round MPC algorithms for MIS, matching, and vertex cover that work with $R = \Theta(\sqrt{\log\Delta})$6 memory per machine, breaking the $R = \Theta(\sqrt{\log\Delta})$7 linear barrier.
• An LCA for MIS with query complexity $R = \Theta(\sqrt{\log\Delta})$8, surpassing the $R = \Theta(\sqrt{\log\Delta})$9 barrier implied by distributed simulation lower bounds.
• Fundamental re-framing of locality measures for distributed and local simulation.

Limitations are primarily in the need to fix randomness ahead of time and to only sparsify those phases of the algorithm in which combinatorial dependencies can be bounded by randomized sampling and degree controls.

7. Summary Table of Model-Specific Improvements

Model	Prior Complexity	Sparsifiner Complexity	Key Advance
LOCAL	$[t, t+R]$0	$[t, t+R]$1	Same round count, lower volume
MPC	$[t, t+R]$2 rounds with $[t, t+R]$3 memory	$[t, t+R]$4 rounds, $[t, t+R]$5 memory	Breaks linear memory barrier
LCA	$[t, t+R]$6 queries	$[t, t+R]$7 queries	Breaks query lower bound

The Sparsifiner framework fundamentally advances parallel and local graph algorithms, providing both theoretical insights and practical schemes for sublinear-memory graph processing, while offering a general method for simulating global dependencies using only a small local view within sparse random subgraphs (Ghaffari et al., 2018).