Dynamic framework for edge-connectivity maintenance of simple graphs

Abstract: We present a dynamic framework for maintaining $k$-edge-connectivity of undirected, simple graphs subject to structural updates, specifically single edge additions and removals. The required edge-connectivity $k$ is a chosen, constant parameter. Unlike standard dynamic graph problems, such as dynamic minimum-cut, which focus solely on reporting the value of the minimum cut, our approach actively modifies the graph $G$ to maintain the edge-connectivity invariant $λ(G) \ge k$. We address two fundamental maintenance tasks: redundancy elimination, which identifies and removes an existing edge rendered redundant for $k$-edge-connectivity by new edge insertion, and connectivity restoration, which computes and inserts a minimal set of augmenting edges to restore graph's $k$-edge-connectivity following an old edge deletion. To preclude trivial reversals, we strictly enforce that the eliminated edge is distinct from the inserted edge and that restoration excludes the already deleted edge. Our solution of the first problem integrates Nagamochi-Ibaraki sparse certificates [Nagamochi and Ibaraki 1992] with Link-Cut Trees [Sleator and Tarjan 1983] to remove redundant edges in $O(k \log n)$ amortized time. For restoration, we propose a localized augmentation strategy that exploits the residual graph structure to bridge the minimum cut. By executing Dinic's [Dinic 1970] algorithm on the sparsified input graph, we identify the minimal edge set required to reconnect the graph in $O(k \cdot n<sup>{5/3})$ time.

• The paper proposes a dynamic framework to maintain $k$-edge-connectivity in unweighted, simple, undirected graphs by implementing redundancy elimination and connectivity restoration tasks based on specific algorithmic strategies.
• The framework effectively handles redundancy by maintaining a sparse certificate data structure during edge additions, ensuring connectivity invariance and consistently preserving edge set size to $O(kn)$.
• The algorithm restores connectivity post-deletion by leveraging a max-flow computation on the residual graph, which is efficient due to a predetermined edge budget and locality lemma that guides local recomputation efforts.

Problem setting and contribution

This paper addresses a problem that is deliberately distinct from the well-studied fully dynamic minimum-cut problem. Rather than maintaining a data structure to report the value of the minimum cut under edge updates, the framework actively modifies the graph so that the invariant $\lambda(G) \ge k$ holds at all times, where $k$ is a fixed constant chosen at initialization and $G$ is an unweighted, simple, undirected graph. Two maintenance tasks are defined:

• Redundancy elimination (post-addition): after inserting an edge $e_{new} = \{u,v\}$, identify and remove an existing edge $e_{old} \neq e_{new}$ such that $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$ for its endpoints, keeping the graph sparse with $|E| = O(kn)$.
• Connectivity restoration (post-deletion): after deleting an edge $e_{del}$, compute and insert a minimal set of augmenting edges $E_{aug}$ restoring $\lambda(G) \ge k$, with the constraint $k$0.

The asymmetry in these constraints is worth noting: the paper enforces that neither task is a trivial reversal of the external update. This is a modeling choice rather than a technical necessity, but it forces genuine topological reconfiguration — for instance, when a cut isolates both endpoints of a deleted edge ($k$1, $k$2), restoration requires inserting two edges through an intermediate vertex instead of simply re-adding the deleted one.

The motivation is drawn from self-healing infrastructure: automated tie-switch closure in power distribution networks, virtual link provisioning in data centers subject to SLA redundancy margins, communication-graph pruning in multi-agent robotics, and consistent-update paradigms in SDN, where atomicity of topological transitions is required.

Structural foundation: cut localization

The key structural observation is a locality lemma: if $k$3 is $k$4-edge-connected and $k$5 is deleted yielding $k$6, then $k$7, and every cut of cardinality below $k$8 in $k$9 must separate $G$0 and $G$1. The proof is elementary — a single edge removal reduces any cut's capacity by at most one, and only if it crosses the cut — but it is pivotal: it implies that after a deletion, all connectivity damage is localized to cuts separating the endpoints of the deleted edge. This justifies running a single max-flow computation between those endpoints rather than a global connectivity recomputation, and it is what makes the restoration algorithm correct with only local information.

Redundancy elimination via sparse certificates

For the post-addition task, the framework maintains a Nagamochi–Ibaraki sparse certificate: a decomposition of $G$2 into edge-disjoint spanning forests $G$3, whose union preserves local connectivities up to level $G$4 by the standard certificate lemma ($G$5). The initial decomposition is computed in $G$6 time via the rank-based scanning procedure, and each forest is represented as a Link-Cut tree supporting MakeTree, FindRoot, link, and cut in $G$7 amortized time.

The update mechanism is a cascading displacement scheme. When a new edge arrives, TryAdd attempts to insert it into forest $G$8: if the endpoints lie in different components, the edge is linked in and the cascade terminates; otherwise, the edge on the tree path incident to $G$9 is cut and replaced, and the displaced edge is pushed to the next forest. An edge ejected from the final forest $e_{new} = \{u,v\}$0 is discarded as redundant. Correctness rests on two lemmas: TryAdd's swap preserves the connected-component partition of each forest, and connectivity in $e_{new} = \{u,v\}$1 implies connectivity in every earlier forest (a consequence of the nested availability of edges across the forest sequence). Together these yield the main theorem: an edge discarded from $e_{new} = \{u,v\}$2 has its endpoints connected in all $e_{new} = \{u,v\}$3 forests, hence joined by at least $e_{new} = \{u,v\}$4 edge-disjoint paths, so discarding it preserves $e_{new} = \{u,v\}$5.

Complexity: initialization costs $e_{new} = \{u,v\}$6; each addition is handled in $e_{new} = \{u,v\}$7 amortized time, since the cascade touches at most $e_{new} = \{u,v\}$8 forests with a constant number of Link-Cut operations per level. This matches the incremental min-cut results of Goranci et al. in spirit — both maintain edge-disjoint spanning forests — but here the certificate is used to select an edge for deletion rather than merely report cut values.

Connectivity restoration via residual-graph analysis

For the post-deletion task, the algorithm runs Dinic's algorithm on $e_{new} = \{u,v\}$9 with unit capacities between the deleted edge's endpoints. If the max flow is at least $e_{old} \neq e_{new}$0, nothing is done. If it equals $e_{old} \neq e_{new}$1 (the only possibility below $e_{old} \neq e_{new}$2, by the localization lemma), the residual graph yields two sets: $e_{old} \neq e_{new}$3, the vertices reachable from $e_{old} \neq e_{new}$4, and $e_{old} \neq e_{new}$5, the vertices from which $e_{old} \neq e_{new}$6 is reachable. These sets are disjoint (any common vertex would give an augmenting path, contradicting flow maximality), and adding any edge $e_{old} \neq e_{new}$7 with $e_{old} \neq e_{new}$8, $e_{old} \neq e_{new}$9 creates an augmenting path, raising the local connectivity to $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$0 and hence, by the localization lemma, restoring $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$1 globally.

Two cases arise:

Configuration	Augmentation	Edges added
$\lambda(x,y; G \setminus \{e_{old}\}) \ge k$2 not both singletons	Single bridging edge $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$3	1
$\lambda(x,y; G \setminus \{e_{old}\}) \ge k$4, $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$5	Path of length two via intermediate vertex $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$6	2

The singleton case exists precisely because the constraint forbids re-adding the deleted edge; the two-edge workaround restores connectivity while respecting that restriction. Note that the augmentation is minimal in the sense of using the fewest edges possible under this constraint, though the choice of $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$7, $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$8, or $\lambda(x,y; G \setminus \{e_{old}\}) \ge k$9 is arbitrary rather than optimized against any secondary criterion.

Complexity: Dinic's algorithm on unit-capacity networks runs in $|E| = O(kn)$0 time (Even–Tarjan bound), dominating the linear-time BFS used to extract $|E| = O(kn)$1 and $|E| = O(kn)$2. Applying Nagamochi–Ibaraki sparsification first, reducing to $|E| = O(kn)$3 edges while preserving $|E| = O(kn)$4-connectivity, tightens the bound to $|E| = O(kn)$5 per deletion. This is polynomial per operation — substantially slower than the polylogarithmic addition handler — and constitutes the computational bottleneck of the framework.

Limitations and open questions

Several limitations are explicit or implicit in the design. First, the deletion handler is not truly "dynamic" in the incremental sense: it performs a full max-flow computation per deletion rather than updating prior flow information, so no amortization across deletions is claimed. Second, correctness of the restoration step relies on the invariant having held before the deletion (so that the localization lemma applies); the paper does not address recovery from graphs that already violate $|E| = O(kn)$6, nor batch updates. Third, the sparsification preprocessing assumes $|E| = O(kn)$7 is constant; the dependence of the $|E| = O(kn)$8 bound on non-constant $|E| = O(kn)$9 is not analyzed. Fourth, the arbitrary selection of bridging endpoints leaves open whether endpoint choice can be optimized for auxiliary objectives (diameter, degree bounds, or routing load). Finally, the framework handles only single-edge insertions and deletions on simple graphs; extensions to vertex updates, multigraphs, or weighted settings are not considered.

Conclusion

The paper formulates active $e_{del}$0-edge-connectivity maintenance as a pair of constrained repair tasks and provides a complete solution: $e_{del}$1 amortized redundancy elimination built on Nagamochi–Ibaraki certificates and Link-Cut trees, and $e_{del}$2 connectivity restoration built on the Even–Tarjan bound for unit-capacity Dinic's algorithm together with a clean cut-localization argument. The framework guarantees both the connectivity invariant and an $e_{del}$3 edge budget at all times. Its main open weakness is the per-deletion max-flow cost, which suggests that replacing the monolithic flow computation with dynamic or local flow techniques is the natural next target for improving the restoration bound.