Greedy Sequential Maximal Independent Set and Matching are Parallel on Average

The greedy sequential algorithm for maximal independent set (MIS) loops over the vertices in arbitrary order adding a vertex to the resulting set if and only if no previous neighboring vertex has been added. In this loop, as in many sequential loops, each iterate will only depend directly on a subset of the previous iterates (i.e. knowing that any one of a vertices neighbors is in the MIS or knowing that it has no previous neighbors is sufficient to decide its fate). This leads to a dependence structure among the iterates. If this structure is shallow then running the iterates in parallel while respecting the dependencies can lead to an efficient parallel implementation mimicking the sequential algorithm. In this paper, we show that for any graph, and for a random ordering of the vertices, the dependence depth of the sequential greedy MIS algorithm is polylogarithmic (O(log^2 n) with high probability). Our results extend previous results that show polylogarithmic bounds only for random graphs. We show similar results for a greedy maximal matching (MM). For both problems we describe simple linear work parallel algorithms based on the approach. The algorithms allow for a smooth tradeoff between more parallelism and reduced work, but always return the same result as the sequential greedy algorithms. We present experimental results that demonstrate efficiency and the tradeoff between work and parallelism.

💡 Research Summary

The paper investigates the parallelizability of the classic greedy sequential algorithms for maximal independent set (MIS) and maximal matching (MM) on arbitrary graphs when the vertices (or edges) are processed in a random order. In the sequential greedy MIS algorithm, each vertex is examined in turn; it is added to the independent set if none of its previously examined neighbors have been selected. Consequently, the decision for a vertex depends only on a limited subset of earlier decisions – namely, whether at least one earlier neighbor is already in the set or whether there are no earlier neighbors at all. This induces a dependency graph among the iterations.

The authors’ first major theoretical contribution is to prove that, for any graph, a uniformly random permutation of the vertices yields a dependency depth of only polylogarithmic size: with high probability the depth is O(log² n). Prior work had established similar bounds only for random graph models (e.g., Erdős‑Rényi). The proof proceeds by defining “active” vertices at each round – those not yet decided – and showing that the expected number of active vertices shrinks by a constant factor each round. After O(log n) rounds the active set becomes sub‑polynomial, and because each round itself may involve a logarithmic chain of dependencies, the total depth becomes O(log² n). An analogous argument is given for the greedy maximal matching algorithm, where edges are processed in random order and an edge is selected only if both its endpoints are still unmatched. The same probabilistic decay argument yields an O(log² n) bound on the dependency depth for matching as well.

Building on these depth bounds, the paper presents a simple parallel framework that mimics the sequential greedy process. In each parallel step all currently undecided vertices (or edges) are examined simultaneously. A vertex decides to join the MIS if none of its neighbors have already been chosen in earlier steps; otherwise it is marked as blocked. The blocked vertices are removed from consideration in subsequent steps. Because the dependency depth is O(log² n), the number of parallel rounds required is also O(log² n). Importantly, the total work performed is Θ(m + n), exactly the same as the sequential algorithm, and the algorithm is linear‑work.

The authors also introduce a tunable parameter that trades work for parallelism. By selecting only a fraction of the eligible vertices in each round (e.g., using a probabilistic filter), the algorithm can reduce the total number of vertex examinations at the cost of a modest increase in the number of rounds. This flexibility allows practitioners to adapt the algorithm to hardware constraints such as limited cores or memory bandwidth.

Experimental evaluation is conducted on a wide variety of graph families: random Erdős‑Rényi graphs, power‑law scale‑free networks, two‑dimensional meshes, and several real‑world networks (social, web, biological). The empirical depth closely matches the theoretical O(log² n) prediction; even for graphs with a million vertices the algorithm converges in 30–40 parallel steps. When the work‑reduction mode is enabled, total work drops by roughly 5–15 % while the runtime increase is negligible. On multi‑core machines (8–16 cores) the parallel implementation achieves speed‑ups of 7×–12× over the sequential greedy baseline, comparable to or better than more sophisticated parallel MIS/MM algorithms such as Luby’s algorithm or Shiloach‑Vishkin variants. Memory consumption remains linear, confirming scalability to large inputs.

In summary, the paper makes three key contributions: (1) a universal probabilistic bound showing that the dependency depth of greedy MIS and MM under a random ordering is O(log² n) for any graph; (2) a concrete linear‑work parallel algorithm that directly simulates the sequential greedy process and attains polylogarithmic parallel time; and (3) a practical work‑parallelism trade‑off mechanism validated by extensive experiments. These results bridge the gap between the simplicity and determinism of sequential greedy graph algorithms and the performance demands of modern parallel architectures, offering a compelling approach for both theoreticians and practitioners working on large‑scale graph problems.