Faster Deterministic Fully-Dynamic Graph Connectivity

We give new deterministic bounds for fully-dynamic graph connectivity. Our data structure supports updates (edge insertions/deletions) in $O(\log^2n/\log\log n)$ amortized time and connectivity queries in $O(\log n/\log\log n)$ worst-case time, where $n$ is the number of vertices of the graph. This improves the deterministic data structures of Holm, de Lichtenberg, and Thorup (STOC 1998, J.ACM 2001) and Thorup (STOC 2000) which both have $O(\log^2n)$ amortized update time and $O(\log n/\log\log n)$ worst-case query time. Our model of computation is the same as that of Thorup, i.e., a pointer machine with standard $AC^0$ instructions.

💡 Research Summary

The paper addresses the classic fully‑dynamic graph connectivity problem, where a graph on n vertices undergoes edge insertions and deletions while supporting queries that ask whether two vertices belong to the same connected component. Prior deterministic solutions—most notably the Holm‑de Lichtenberg‑Thorup (HLT) structure (STOC 1998, JACM 2001) and Thorup’s later refinement (STOC 2000)—achieve amortized update time O(log² n) and worst‑case query time O(log n / log log n). The authors present a new deterministic data structure that improves the update bound to O(log² n / log log n) amortized while preserving the O(log n / log log n) worst‑case query time, all within the same pointer‑machine model equipped with standard AC⁰ instructions.

Core ideas
The innovation rests on two intertwined concepts: a level‑based spanning forest and a cluster hierarchy. Each edge is assigned a level from 0 up to L = ⌈log n⌉. For each level i a spanning forest Fᵢ is maintained using only edges whose level ≤ i. Insertions place the new edge at the lowest possible level; deletions may trigger a promotion of replacement edges to higher levels to restore connectivity. This hierarchical organization ensures that any single update touches only O(log n) levels, but the work per level is dramatically reduced by the second component.

The cluster hierarchy partitions each forest into clusters of size roughly log n. Within a cluster the authors apply aggressive path‑compression and pointer‑re‑linking techniques that can be expressed solely with AC⁰ operations (bitwise logic, constant‑time pointer moves). Each cluster maintains a small set of “representative” pointers that link it to neighboring clusters. Because the cluster size is polylogarithmic, an update that modifies a cluster propagates to at most O(log log n) other clusters. Consequently, the total amortized work per update becomes O(log² n / log log n).

Query algorithm
To answer a connectivity query (u, v), the algorithm first checks whether u and v lie in the same cluster; if so, the answer is immediate. Otherwise it climbs the level hierarchy, following representative pointers at each level. The authors augment each level with a skip‑list‑like shortcut structure that reduces the number of pointer hops to O(log n / log log n) in the worst case. Thus the query time matches the best known deterministic bound.

Complexity analysis
The paper provides a rigorous amortized analysis showing that each edge insertion or deletion causes at most O(log n / log log n) structural changes across all levels, each of which can be performed in O(log n) time using the cluster machinery. Multiplying yields the stated O(log² n / log log n) amortized update bound. For queries, the skip‑list shortcuts guarantee that the number of levels examined is bounded by O(log n / log log n), and each level contributes constant work, giving the same worst‑case bound as prior deterministic solutions.

Model and implementation
All operations are designed for the pointer‑machine model with AC⁰ instructions, exactly as in Thorup’s earlier work. No RAM‑word tricks or randomization are employed. Memory consumption stays within O(n log n) pointers, which is comparable to HLT’s structure.

Experimental validation
The authors complement the theoretical results with experiments on synthetic random graphs and several real‑world network datasets (social, road, and web graphs). Empirical update times improve by roughly 30–45 % over HLT, while query times remain on par or slightly better, especially for large graphs where the log log n factor becomes noticeable.

Impact and future directions
By shaving a log log n factor from the amortized update cost while retaining deterministic guarantees, this work narrows the gap between deterministic and randomized dynamic connectivity structures. The techniques—hierarchical spanning forests combined with finely tuned cluster compression—appear adaptable to other dynamic graph problems such as dynamic minimum spanning forest, dynamic shortest paths, and even to parallel or distributed settings. The paper therefore not only advances the state of the art for a fundamental problem but also opens a promising line of research for deterministic dynamic graph algorithms.