Optimal Per-Edge Processing Times in the Semi-Streaming Model

We present semi-streaming algorithms for basic graph problems that have optimal per-edge processing times and therefore surpass all previous semi-streaming algorithms for these tasks. The semi-streaming model, which is appropriate when dealing with massive graphs, forbids random access to the input and restricts the memory to O(npolylog n) bits. Particularly, the formerly best per-edge processing times for finding the connected components and a bipartition are O(alpha(n)), for determining k-vertex and k-edge connectivity O(k^2n) and O(nlog n) respectively for any constant k and for computing a minimum spanning forest O(log n). All these time bounds we reduce to O(1). Every presented algorithm determines a solution asymptotically as fast as the best corresponding algorithm up to date in the classical RAM model, which therefore cannot convert the advantage of unlimited memory and random access into superior computing times for these problems.

💡 Research Summary

The paper addresses fundamental graph problems in the semi‑streaming model, where the input graph arrives as a stream of edges, random access to the whole graph is prohibited, and the working memory is limited to O(n·polylog n) bits. The authors focus on the per‑edge processing time (T), a critical performance metric that determines how fast edges can be ingested. They first observe that prior work used an ambiguous definition of T, conflating worst‑case and amortized bounds, which does not accurately capture the real‑time constraints of streaming. Consequently, they propose a precise definition: T is the minimum admissible time interval between two consecutive edges in the input stream. This definition directly ties T to the maximum feasible input rate of the streaming system.

The central technical contribution is a generic framework that reduces the per‑edge processing time to O(1) for a wide class of graph problems. The framework relies on two concepts: (1) strong certificates – sparse subgraphs that preserve the property of interest and enjoy transitivity and union properties, and (2) group‑wise buffering – processing edges in blocks of size Θ(n) rather than one by one. While reading a block, the algorithm maintains a strong certificate for the graph formed by all previously processed edges. After the block is buffered, the certificate is updated using only the edges of the block; because the certificate is sparse (O(n) edges) it fits into the semi‑streaming memory budget. Theorem 1 formalizes this: if a certificate can be constructed in time f(n, O(n)) and space O(m), then the per‑edge processing time achievable is T = f(n, O(n))/n.

Applying this framework, the authors obtain constant‑time per‑edge algorithms for several classic problems:

• Connected Components – A spanning forest serves as a strong certificate. It can be built by a single DFS/BFS in O(n+m) time and O(n) space, yielding T = O(1). A final DFS on the forest identifies each component in O(n) post‑processing time.

• Bipartition (Bipartiteness) – The certificate is a spanning forest augmented with one extra edge that creates an odd cycle if the graph is non‑bipartite (denoted F⁺). The construction again uses a DFS with alternating coloring, fitting the same time and space bounds, and the final coloring produces a bipartition or an odd‑cycle witness.

• k‑Vertex Connectivity (k constant) – The authors employ the Nagamochi‑Ibaraki subgraph C_k, which contains at most k·n edges and preserves local vertex connectivity up to k. They prove C_k is a strong certificate for k‑vertex connectivity, and its construction runs in O(n+m) time, giving T = O(1). Post‑processing checks separations in C_k to answer connectivity queries.

• k‑Edge Connectivity (k constant) – By adapting the dynamic‑graph sparsification techniques of Eppstein et al., a k‑sparse strong certificate is obtained, again leading to constant per‑edge time.

• Minimum Spanning Forest (MSF) – Existing semi‑streaming algorithms achieve O(log n) per‑edge time. By integrating the group‑wise update mechanism, the authors reduce this to O(1) while preserving the optimal total running time of O(m + n log n) for the final MST extraction.

Table 1 in the paper juxtaposes the previous best per‑edge times (often O(α(n)), O(k²n), or O(n log n)) with the new O(1) bounds, demonstrating a uniform improvement across all considered problems.

The paper concludes that, despite the severe memory restriction, the semi‑streaming model cannot exploit the “unlimited memory” advantage of the RAM model to achieve faster overall computation; the best achievable total time matches that of the best RAM algorithms for these problems. The authors suggest that the strong‑certificate + block‑buffering paradigm is broadly applicable and may inspire further constant‑time per‑edge algorithms for other streaming graph tasks.