Decremental Strongly-Connected Components and Single-Source Reachability in Near-Linear Time

TL;DR

This paper introduces a nearly optimal decremental algorithm for maintaining strongly-connected components and single-source reachability in general graphs, significantly improving update times over previous methods.

Contribution

It presents the first decremental SCC algorithm with total update time O(m), nearly matching the lower bounds, and extends these results to decremental reachability problems.

Findings

Achieves O(m) total update time for decremental SCCs in general graphs.

Extends the approach to decremental single-source reachability with efficient bounds.

Improves upon previous algorithms with higher total update times for similar problems.

Abstract

Computing the Strongly-Connected Components (SCCs) in a graph $G=(V,E)$ is known to take only $O(m + n)$ time using an algorithm by Tarjan from 1972[SICOMP 72] where $m = |E|$, $n=|V|$. For fully-dynamic graphs, conditional lower bounds provide evidence that the update time cannot be improved by polynomial factors over recomputing the SCCs from scratch after every update. Nevertheless, substantial progress has been made to find algorithms with fast update time for \emph{decremental} graphs, i.e. graphs that undergo edge deletions. In this paper, we present the first algorithm for general decremental graphs that maintains the SCCs in total update time $\tilde{O}(m)$, thus only a polylogarithmic factor from the optimal running time. Previously such a result was only known for the special case of planar graphs [Italiano et al, STOC 2017]. Our result should be compared to the formerly best algorithm for general graphs achieving $\tilde{O}(m\sqrt{n})$ total update time by Chechik et.al. [FOCS 16] which improved upon a breakthrough result leading to $O(mn^{0.9 + o(1)})$ total update time by Henzinger, Krinninger and Nanongkai [STOC 14, ICALP 15]; these results in turn improved upon the longstanding bound of $O(mn)$ by Roditty and Zwick [STOC 04]. All of the above results also apply to the decremental Single-Source Reachability (SSR) problem, which can be reduced to decrementally maintaining SCCs. A bound of $O(mn)$ total update time for decremental SSR was established already in 1981 by Even and Shiloach [JACM 1981]. Using a well known reduction, we can maintain the reachability of pairs $S \times V$, $S \subseteq V$ in fully-dynamic graphs with update time $\tilde{O}(\frac{|S|m}{t})$ and query time $O(t)$ for all $t \in [1,|S|]$; this generalizes an earlier All-Pairs Reachability where $S = V$ [{\L}\k{a}cki, TALG 2013].

Equations

$${\hat{G}}_i=\text{textsc}Condensation((V,\bigcup _{j<i}{E}_j))\cup E_i$$

$${\hat{G}}_{\lfloor \lg n\rfloor +1}=\text{textsc}Condensation((V,\bigcup _{j<\lfloor \lg n\rfloor +1}{E}_j))\cup E_{\lfloor \lg n\rfloor +1}=\text{textsc}Condensation((V,E)).$$

$${\hat{G}}_i=\text{textsc}Condensation((V,\bigcup _{j<i}{E}_j))\cup E_i=\text{textsc}Condensation(G\setminus E(S_i))\cup E(S_i\setminus S_{i+1})).$$

$$|S_{Sep}|\le \frac{\min \{|V_{Sep}\cap S|,|(V\setminus (S_{Sep}\cup V_{Sep}))\cap S|\}2\log n}{d},$$

$$B_{out}(r)=\{v\in V|{\mathbf{dist}}_G(r,v,S)\le d/16\}$$

$$|B_{out}(r)\cap B_{in}(r)|>\frac{1}{3}|V|.$$

$$|\text{textsc}Flatten(X_{max}^k)|\le \frac{2}{3}|\text{textsc}Flatten(X_{Init})|<|\text{textsc}Flatten(X_{max}^{k-1})|.$$

$$Pr[r\in X_{max}^{k-1}|u_1,u_2,..]=Pr[r\in X_{max}^{k-1}]=\frac{|\text{textsc}Flatten(X_{max}^{k-1})|}{|\text{textsc}Flatten(X_{Init})}>\frac{2}{3}$$

$$|S_0|$$

$$|S_{i+1}|$$

$$O\left(\delta E(X)+\delta \sum _{X\in P}\log (n-|\text{textsc}Flatten(X)|)E(X)\right)$$

$$|L_i\cap S|\le \frac{\min \{{\sum }_{j<i}|L_j\cap S|,|(V\setminus {\sum }_{j<i}{L}_j)\cap S|\}2\log n}{d}$$

$$|L_i\cap S|\le \frac{{\sum }_{j<i}|L_j\cap S|2\log n}{d}$$

Full text

In this paper, we present the first algorithm for general decremental graphs that maintains the SCCs in total update time $\tilde{O}(m)$111We use $\tilde{O}(f(n))$ notation to suppress logarithmic factors, i.e. $g(n)=\tilde{O}(f(n))$ if $g(n)=O(f(n)\text{polylog}(n))$., thus only a polylogarithmic factor from the optimal running time. Previously such a result was only known for the special case of planar graphs [Italiano et al, STOC 17]. Our result should be compared to the formerly best algorithm for general graphs achieving $\tilde{O}(m\sqrt{n})$ total update time by Chechik et al. [FOCS 16] which improved upon a breakthrough result leading to $O(mn^{0.9+o(1)})$ total update time by Henzinger, Krinninger and Nanongkai [STOC 14, ICALP 15]; these results in turn improved upon the longstanding bound of $O(mn)$ by Roditty and Zwick [STOC 04].

All of the above results also apply to the decremental Single-Source Reachability (SSR) problem which can be reduced to decrementally maintaining SCCs. A bound of $O(mn)$ total update time for decremental SSR was established already in 1981 by Even and Shiloach [JACM 81].

Using a well known reduction, we use our decremental result to achieve new update/query-time trade-offs in the fully dynamic setting. We can maintain the reachability of pairs $S\times V$, $S\subseteq V$ in fully-dynamic graphs with update time $\tilde{O}(\frac{|S|m}{t})$ and query time $O(t)$ for all $t\in[1,|S|]$; this matches the best All-Pairs Reachability algorithm for $S=V$ [Łącki, TALG 13].

1 Introduction

For a directed graph $G=(V,E)$, with $n=|V|,m=|E|$, the Strongly-Connected Components (SCCs) of $G$ are the sets of the unique partition of the vertex set $V$ into sets $V_{1},V_{2},..,V_{k}$ such that for any two vertices $u\in V_{i},v\in V_{j}$, there exists a directed cycle in $G$ containing $u$ and $v$ if and only if $i=j$. In the Single-Source Reachability (SSR) problem, we are given a distinguished source $r\in V$ and are asked to find all vertices in $V$ that can be reached from $r$. The SSR problem can be reduced to finding the SCCs by inserting edges from each vertex in $V$ to the distinguished source $r$.

Finding SCCs in static graphs in $O(m+n)$ time is well-known since 1972[Tar72] and is commonly taught in undergraduate courses, also appearing in CLRS[Cor+09].

In this paper we focus on maintaining SCCs in a dynamic graph. The most general setting is the fully dynamic one, where edges are being inserted and deleted into the graph. While many connectivity problems for undirected graphs have been solved quite efficiently [HDT01, Wul13, Tho00, Tho07, Hua+17, NSW17], in fully-dynamic graphs, the directed versions of these problems have proven to be much harder to approach.

In fact, Abboud and Vassilevska[AW14] showed that any algorithm that can maintain whether there are more than 2 SCCs in a fully-dynamic graph with update time $O(m^{1-\epsilon})$ and query time $O(m^{1-\epsilon})$, for any constant $\epsilon>0$, would imply a major breakthrough on SETH. The same paper also suggests that $O(m^{1-\epsilon})$ update time and query time $O(n^{1-\epsilon})$ for maintaining the number of reachable vertices from a fixed source would imply a breakthrough for combinatorial Matrix Multiplication.

For this reason, research on dynamic SCC and dynamic single-source reachability has focused on the partially dynamic setting (decremental or incremental). In this paper we study the decremental setting, where the original graph only undergoes edge deletions (no insertions). We note that both lower bounds above extend to decremental algorithms with worst-case update time $O(m^{1-\epsilon})$, so all existing results focus on the amortized update time.

The first algorithm to maintain SSR faster than recomputation from scratch achieved total update time $O(mn)$[ES81]. The same update time for maintaining SCCs was achieved by a randomized algorithm by Roddity and Zwick[RZ08]. Their algorithm also establishes that any algorithm for maintaining SSR can be turned into a randomized algorithm to maintain the SCCs incurring only an additional constant multiplicative factor in the running time. Later, Łącki[Łąc13] presented a simple deterministic algorithm that matches $O(mn)$ total update time and that also maintains the transitive closure. For several decades, it was not known how to get beyond total update time $O(mn)$, until a recent breakthrough by Henzinger, Krinninger and Nanongkai[HKN14a, HKN15] reduced the total update time to expected time $O(\min(m^{7/6}n^{2/3},m^{3/4}n^{5/4+o(1)},m^{2/3}n^{4/3+o(1)}+m^{3/7}n^{12/7+o(1)}))=O(mn^{0.9+o(1)})$. Even more recently, Chechik et. al.[Che+16] showed that a clever combination of the algorithms of Roditty and Zwick, and Łącki can be used to improve the expected total update time to $\tilde{O}(m\sqrt{n})$. We point out that all of these recent results rely on randomization and in fact no deterministic algorithm for maintaining SCCs or SSR beyond the $O(mn)$ bound is known for general graphs. For planar graphs, Italiano et. al.[Ita+17] presented a deterministic algorithm with total update time $\tilde{O}(n)$.

Finally, in this paper, we present the first algorithm for general graphs to maintain SCCs in $\tilde{O}(m)$ expected total update time with constant query time, thus presenting the first near-optimal algorithm for the problem. We summarize our result in the following theorem.

Theorem 1.1**.**

Given a graph $G=(V,E)$ with $m$ edges and $n$ vertices, we can maintain a data structure that supports the operations:

• •

$\textsc{Delete}(u,v)$: Deletes the edge $(u,v)$ from the graph $G$,

• •

$\textsc{Query}(u,v)$: Returns whether $u$ and $v$ are in the same SCC in $G$,

in total expected update time $O(m\log^{4}n)$ and with worst-case constant query time. The same time bounds apply to answer for a fixed source vertex $s\in V$ queries on whether a vertex $v\in V$ can be reached from $s$. The bound holds against an oblivious adaptive adversary.

Our algorithm makes the standard assumption of an oblivious adversary which does not have access to the coin flips made by the algorithm. But our algorithm does NOT require the assumption of a non-adaptive adversary, which is ignorant of answers to queries as well: the reason is simply that SCC and SSR information is unique, so the answers to queries do not reveal any information about the algorithm. One key exception is that for SSR, if the algorithm is expected to return a witness path, then it does require the assumption of a non-adaptive adversary.

A standard reduction described in appendix A also implies a simple algorithm for maintaining reachability from some set $S\subseteq V$ to $V$ in a fully-dynamic graph with vertex set $V$ that is a data structure that answers queries for any $s\in S,v\in V$ on whether $s$ can reach $v$. The amortized expected update time is $\tilde{O}(|S|m/t)$ and query time $O(t)$ for every $t\in[1,|S|]$. We allow vertex updates, i.e. insertions or deletions of vertices with incident edges, which are more general than edge updates. This generalizes a well-known trade-off result for All-Pairs Reachability[RZ16, Łąc13] with $\tilde{O}(nm/t)$ amortized update time and query time $O(t)$ for every $t\in[1,n]$.

Finally, we point out that maintaining SCCs and SSR is related to the more difficult (approximate) shortest-path problems. In fact, the algorithms [ES81, HK95, HKN14a, HKN15] can also maintain (approximate) shortest-paths in decremental directed graphs. For undirected graphs, the decremental Single-Source Approximate Shortest-Path problem was recently solved to near-optimality[HKN14], and deterministic algorithms[BC16, BC17] have been developed that go beyond the $O(mn)$ barrier. We hope that our result inspires new algorithms to tackle the directed versions of these problems.

2 Preliminaries

In this paper, we let a graph $H=(V,E)$ refer to a directed multi-graph where we allow multiple edges between two endpoints and self-loops but say that a cycle contains at least two distinct vertices. We refer to the vertex set of $H$ by $V(H)$ and the edge set by $E(H)$. We denote the input graph by $G$, let $V=V(G)$ and $E=E(G)$ and define $n=|V|$ and $m=|E|$. If the context is clear, we simply write sets $X$ instead of their cardinality $|X|$ in calculations to avoid cluttering.

We define a subgraph of $H$ to be a graph $H^{\prime}$ with $V(H^{\prime})=V(H)$ and $E(H^{\prime})\subseteq E(H)$. Observe that this deviates from the standard definition of subgraphs since we require the vertex set to be equivalent. We write $H\setminus E^{\prime}$ as a shorthand for the graph $(V(H),E(H)\setminus E^{\prime})$ and $H\cup E^{\prime}$ as a shorthand for $(V(H),E(H)\cup E^{\prime})$. For any $S\subseteq V(H)$, we define $E^{H}_{out}(S)$ to be the set $(S\times V(H))\cap E(H)$, i.e. the set of all edges in $H$ that emanate from a vertex in $S$; we analogously define $E^{H}_{in}(S)$ and $E^{H}(S)=E^{H}_{in}(S)\cup E^{H}_{out}(S)$. If the context is clear, we drop the superscript and simply write $E_{in}(S),E_{out}(S),E(S)$.

For any graph $H$, and any two vertices $u,v\in V(H)$, we denote by $\mathbf{dist}_{H}(u,v)$ the distance from $u$ to $v$ in $H$. We also define the notion of $S$-distances for any $S\subseteq V(H)$ where for any pair of vertices $u,v\in V(H)$, the $S$-distance $\mathbf{dist}_{H}(u,v,S)$ denotes the minimum number of vertices in $S\setminus\{v\}$ encountered on any path from $u$ to $v$. Alternatively, the $S$-distance corresponds to $\mathbf{dist}_{H^{\prime}}(u,v)$ where $H^{\prime}$ is a graph with edges $E_{out}(S)$ of weight $1$ and edges $E\setminus E_{out}(S)$ of weight [math]. It therefore follows that for any $u,v\in V(H)$, $\mathbf{dist}_{H}(u,v)=\mathbf{dist}_{H}(u,v,V)$.

We define the diameter of a graph $H$ by $\mathbf{diam}(H)=\max_{u,v\in V}\mathbf{dist}_{H}(u,v)$ and the $S$-diameter by $\mathbf{diam}(H,S)=\max_{u,v\in V(H)}\mathbf{dist}_{H}(u,v,S)$. Therefore, $\mathbf{diam}(H)=\mathbf{diam}(H,V)$. For convenience, we often omit the subscript on relations if the context is clear and write $\mathbf{dist}(u,v,S)$

We denote that a vertex $u$ reaches $v$ in $H$ by $u\leadsto_{H}v$, and if $u\leadsto_{H}v$ and $v\leadsto_{H}u$, we simply write $u\rightleftarrows_{H}v$ and say $u$ and $v$ are strongly-connected. We also use $\leadsto$ and $\rightleftarrows$ without the subscript if the underlying graph $H$ is clear from the context. We say that $H$ is strongly-connected if for any $u,v\in V(H)$, $u\rightleftarrows v$. We call the maximal subgraphs of $H$ that are strongly-connected, the strongly-connected components (SCCs). We denote by $\textsc{Condensation}(H)$ the condensation of $H$, that is the graph where all vertices in the same SCC in $H$ are contracted. To distinguish we normally refer to the vertices in $\textsc{Condensation}(H)$ as nodes. Each node in $\textsc{Condensation}(H)$ corresponds to a vertex set in $H$. The node set of a condensation $\textsc{Condensation}(H)$ forms a partition of $V(H)$. For convenience we define the function $\textsc{Flatten}(X)$ for a family of sets $X$ with $\textsc{Flatten}(X)=\bigcup_{x\in X}x$. This is useful when discussing condensations. Observe further that $\textsc{Condensation}(H)$ can be a multi-graph and might also contain self-loops. If we have an edge set $E^{\prime}$ with all endpoints in $H$, we let $\textsc{Condensation}(H)\cup E^{\prime}$ be the multi-graph obtained by mapping the endpoints of each vertex in $E^{\prime}$ to their corresponding SCC node in $\textsc{Condensation}(H)$ and adding the resulting edges to $\textsc{Condensation}(H)$.

Finally, for two partitions $P$ and $P^{\prime}$ of a set $U$, we say that partition $P$ is a melding for a partition $P^{\prime}$ if for every set $X\in P^{\prime}$, there exists a set $Y\in P$ with $X\subseteq Y$. We also observe that melding is transitive, thus if $P$ is a melding for $P^{\prime}$ and $P^{\prime}$ a melding for $P^{\prime\prime}$ then $P$ is a melding for $P^{\prime\prime}$.

3 Overview

We now introduce the graph hierarchy maintained by our algorithm, followed by a high-level overview of our algorithm.

High-level overview of the hierarchy.

Our hierarchy has levels [math] to $\lfloor\lg n\rfloor+1$ and we associate with each level $i$ a subset $E_{i}$ of the edges $E$. The sets $E_{i}$ form a partition of $E$; we define the edges that go into each $E_{i}$ later in the overview but point out that we maintain $E_{\lfloor\lg n\rfloor+1}=\emptyset$. We define a graph hierarchy $\hat{G}=\{\hat{G}_{0},\hat{G}_{1},..,\hat{G}_{\lfloor\lg n\rfloor+1}\}$ such that each graph $\hat{G}_{i}$ is defined as

[TABLE]

That is, each $\hat{G}_{i}$ is the condensation of a subgraph of $G$ with some additional edges. As mentioned in the preliminary section, we refer to the elements of the set $\hat{V}_{i}=V(\hat{G}_{i})$ as nodes to distinguish them from vertices in $V$. We use capital letters to denote nodes and small letters to denote vertices. We let $X_{i}^{v}$ denote the node in $\hat{V}_{i}$ with $v\in X_{i}^{v}$. Observe that each node $X$ corresponds to a subset of vertices in $V$ and that for any $i$, $\hat{V}_{i}$ can in fact be seen as a partition of $V$. For $\hat{G}_{0}=\textsc{Condensation}((V,\emptyset))\cup E_{0}$, the set $\hat{V}_{0}$ is a partition of singletons, i.e. $\hat{V}_{0}=\{\{v\}|v\in V\}$, and $X_{0}^{v}=\{v\}$ for each $v\in V$.

Observe that because the sets $E_{i}$ form a partition of $E$ and $E_{\lfloor\lg n\rfloor+1}=\emptyset$, the top graph $\hat{G}_{\lfloor\lg n\rfloor+1}$ is simply defined as

[TABLE]

Therefore, if we can maintain $\hat{G}_{\lfloor\lg n\rfloor+1}$ efficiently, we can answer queries on whether two vertices $u,v\in V$ are in the same SCC in $G$ by checking if $X_{\lfloor\lg n\rfloor+1}^{u}$ is equal to $X_{\lfloor\lg n\rfloor+1}^{v}$.

Let us offer some intuition for the hierarchy. The graph $\hat{G}_{0}$ contains all the vertices of $G$, and all the edges of $E_{0}\subseteq E$. By definition of $\textsc{Condensation}(\cdot)$, the nodes of $\hat{G}_{1}$ precisely correspond to the SCCs of $\hat{G}_{0}$. $\hat{G}_{1}$ also includes the edges $E_{0}$ (though some of them are contracted into self-loops in $\textsc{Condensation}((V,E_{0}))$), as well as the additional edges in $E_{1}$. These additional edges might lead to $\hat{G}_{1}$ having larger SCCs than those of $\hat{G}_{0}$; each SCC in $\hat{G}_{1}$ then corresponds to a node in $\hat{G_{2}}$. More generally, the nodes of $\hat{G}_{i+1}$ are the SCCs of $\hat{G}_{i}$.

As we move up the hierarchy, we add more and more edges to the graph, so the SCCs get larger and larger. Thus, each set $\hat{V}_{i}$ is a melding for any $\hat{V}_{j}$ for $j\leq i$; that is for each node $Y\in\hat{V}_{j}$ there exists a set $X\in\hat{V}_{i}$ such that $Y\subseteq X$. We sometimes say we meld nodes $Y,Y^{\prime}\in\hat{V}_{j}$ to $X\in\hat{V}_{i}$ if $Y,Y^{\prime}\subseteq X$ and $j<i$. Additionally, we observe that for any SCC $Y\subseteq\hat{V}_{i}$ in $\hat{G}_{i}$, we meld the nodes in SCC $Y$ to a node in $X\in\hat{V}_{i+1}$, and $X$ consists exactly of the vertices contained in the nodes of $Y$. More formally, $X=\textsc{Flatten}(Y)$.

To maintain the SCCs in each graph $\hat{G}_{i}$, our algorithm employs a bottom-up approach. At level $i+1$ we want to maintain SCCs in the graph with all the edges in $\bigcup_{j\leq i+1}E_{j}$, but instead of doing so from scratch, we use the SCCs maintained at level $\hat{G}_{i}$ as a starting point. The SCCs in $\hat{G}_{i}$ are precisely the SCCs in the graph with edge set $\bigcup_{j\leq i}E_{j}$; so to maintain the SCCs at level $i+1$, we only need to consider how the sliver of edges in $E_{i+1}$ cause the SCCs in $\hat{G}_{i}$ to be melded into larger SCCs (which then become the nodes of $\hat{G}_{i+2}$).

If the adversary deletes an edge in $E_{i}$, all the graphs $\hat{G}_{i-1}$ and below remain unchanged, as do the nodes of $\hat{G}_{i}$. But the deletion might split apart an SCC in $G_{i}$, which will in turn cause a node of $\hat{G}_{i+1}$ to split into multiple nodes. This split might then cause an SCC of $\hat{G}_{i+1}$ to split, which will further propagate up the hierarchy.

In addition to edge deletions caused by the adversary, our algorithm will sometimes move edges from $E_{i}$ to $E_{i+1}$. Because the algorithm only moves edges up the hierarchy, each graph $\hat{G}_{i}$ is only losing edges, so the update sequence remains decremental from the perspective of each $\hat{G}_{i}$. We now give an overview of how our algorithm maintains the hierarchy efficiently.

ES-trees.

A fundamental data structure that our algorithm employs is the ES-tree[ES81, HK95] that for a directed unweighted graph $G=(V,E)$ undergoing edge deletions, and a distinguished source $r\in V$ maintains the distance $\mathbf{dist}_{G}(r,v)$ for each $v\in V$. In fact, the ES-tree maintains a shortest-path tree rooted at $r$. We refer to this tree subsequently as ES out-tree. We call the ES in-tree rooted at $r$ the shortest-path tree maintained by running the ES-tree data structure on the graph $G$ with reversed edge set, i.e. the edge set where each edge $(u,v)\in E$ appears in the form $(v,u)$. We can maintain each in-tree and out-tree decrementally to depth $\delta>0$ in time $O(|E|*\delta)$; that is we can maintain the distances $\mathbf{dist}_{G}(r,v)$ and $\mathbf{dist}_{G}(v,r)$ exactly until one of the distances $\mathbf{dist}_{G}(r,v)$ or $\mathbf{dist}_{G}(v,r)$ exceeds $\delta$.

Maintaining SCCs with ES-trees.

Consider again graph $\hat{G}_{0}$ and let $X\subseteq\hat{V}_{0}$ be some SCC in $\hat{G}_{0}$ that we want to maintain. Let some node $X^{\prime}$ in $X$ be chosen to be the center node of the SCC (In the case of $\hat{G}_{0}$, the node $X^{\prime}$ is just a single-vertex set $\{v\}$). We then maintain an ES in-tree and an ES out-tree from $X^{\prime}$ that spans the nodes in $X$ in the induced graph $\hat{G}_{0}[X]$. We must maintain the trees up to distance $\mathbf{diam}(\hat{G}_{0}[X])$, so the total update time is $O(|E(\hat{G}_{0}[X])|*\mathbf{diam}(\hat{G}_{0}[X]))$.

Now, consider an edge deletion to $\hat{G}_{0}$ such that the ES in-tree or ES out-tree at $X^{\prime}$ is no longer a spanning tree. Then, we detected that the SCC $X$ has to be split into at least two SCCs $X_{1},X_{2},..,X_{k}$ that are node-disjoint with $X=\bigcup_{i}X_{i}$. Then in each new SCC $X_{i}$ we choose a new center and initialize a new ES in-tree and ES out-tree.

Exploiting small diameter.

The above scheme clearly is quite efficient if $\mathbf{diam}(\hat{G}_{0})$ is very small. Our goal is therefore to choose the edge set $E_{0}$ in such a way that $\hat{G}_{0}$ contains only SCCs of small diameter. We therefore turn to some insights from [Che+16] and extract information from the ES in-tree and out-tree to maintain small diameter. Their scheme fixes some $\delta>0$ and if a set of nodes $Y\subseteq X$ for some SCC $X$ is at distance $\Omega(\delta)$ from/to $\textsc{Center}(X)$ due to an edge deletion in $\hat{G}_{0}$, they find a node separator $S$ of size $O(\min\{|Y|,|X\setminus Y|\}\log n/\delta)$; removing $S$ from $\hat{G}_{0}$ causes $Y$ and $X\setminus Y$ to no longer be in the same SCC. We use this technique and remove edges incident to the node separator $S$ from $E_{0}$ and therefore from $\hat{G}_{0}$. One subtle observation we want to stress at this point is that each node in the separator set appears also as a single-vertex node in the graph $\hat{G}_{1}$; this is because each separator node $\{s\}$ for some $s\in V$ is not melded with any other node in $\hat{V}_{0}$, as it has no edges in $\hat{G}_{0}$ to or from any other node.

For some carefully chosen $\delta=\Theta(\log^{2}n)$, we can maintain $\hat{G}_{0}$ such that at most half the nodes in $\hat{V}_{0}$ become separator nodes at any point of the algorithm. This follows since each separator set is small in comparison to the smaller side of the cut and since each node in $\hat{V}_{0}$ can only be $O(\log n)$ times on the smaller side of a cut.

Reusing ES-trees.

Let us now refine our approach to maintain the ES in-trees and ES out-trees and introduce a crucial ingredient devised by Roditty and Zwick[RZ08]. Instead of picking an arbitrary center node $X^{\prime}$ from an SCC $X$ with $X^{\prime}\in X$, we are going to pick a vertex $r\in\textsc{Flatten}(X)\subseteq V$ uniformly at random and run our ES in-tree and out-tree $\mathcal{E}_{r}$ from the node $X_{0}^{r}$ on the graph $\hat{G}_{0}$. For each SCC $X$ we denote the randomly chosen root $r$ by $\textsc{Center}(X)$. In order to improve the running time, we reuse ES-trees when the SCC $X$ is split into SCCs $X_{1},X_{2},..,X_{k}$, where we assume wlog that $r\in\textsc{Flatten}(X_{1})$, by removing the nodes in $X_{2},..,X_{k}$ from $\mathcal{E}_{r}$ and setting $\textsc{Center}(X_{1})=r$. Thus, we only need to initialize a new ES-tree for the SCC $X_{2},..,X_{k}$. Using this technique, we can show that each node is expected to participate in $O(\log n)$ ES-trees over the entire course of the algorithm, since we expect that if a SCC $X$ breaks into SCCs $X_{1},X_{2},..,X_{k}$ then we either have that every SCC $X_{i}$ is of at most half the size of $X$, or with probability at least $1/2$ that $X_{1}$ is the new SCC that contains at least half the vertices, i.e. that the random root is containing in the largest part of the graph. Since the ES-trees work on induced graphs with disjoint node sets, we can therefore conclude that the total update time for all ES-trees is $O(m\log n*\mathbf{diam}(\hat{G}_{0}))$.

We point out that using the ES in-trees and out-trees to detect node separators as described above complicates the analysis of the technique by Roditty and Zwick[RZ08] but a clever proof presented in [Che+16] shows that the technique can still be applied. In our paper, we present a proof that can even deal with some additional complications and that is slightly simpler.

A contrast to the algorithm of Chechik et al [Che+16].

Other than our hierarchy, the overview we have given so far largely comes from the algorithm of Chechik et al [Che+16]. However, their algorithm does not use a hierarchy of graphs. Instead, they show that for any graph $G$, one can find (and maintain) a node separator $S$ of size $\tilde{O}(n/\delta)$ such that all SCCs in $G$ have diameter at most $\delta$. They can then use ES-trees with random sources to maintain the SCCs in $G\setminus S$ in total update time $\tilde{O}(m\delta)$. This leaves them with the task of computing how the vertices in $S$ might meld some of the SCCs in $G\setminus S$. They are able to do this in total update time $\tilde{O}(m|S|)=\tilde{O}(mn/\delta)$ by using an entirely different technique of [Łąc13]. Setting $\delta=\tilde{O}(\sqrt{n})$, they achieve the optimal trade-off between the two techniques: total update time $\tilde{O}(m\sqrt{n})$ in expectation.

We achieve our $\tilde{O}(m)$ total update time by entirely avoiding the technique of [Łąc13] for separately handling a small set of separator nodes, and instead using the graph hierarchy described above, where at each level we set $\delta$ to be polylog rather than $\tilde{O}(\sqrt{n})$.

We note that while our starting point is the same as [Che+16], using a hierarchy of separators forces us to take a different perspective on the function of a separator set. The reason is that it is simply not possible to ensure that at each level of the hierarchy, all SCCs have small diameter. To overcome this, we instead aim for separator sets that decompose the graph into SCCs that are small with respect to a different notion of distance. The rest of the overview briefly sketches this new perspective, while sweeping many additional technical challenges under the rug.

Refining the hierarchy.

So far, we only discussed how to maintain $\hat{G}_{0}$ efficiently by deleting many edges from $E_{0}$ and hence ensuring that SCCs in $\hat{G}_{0}$ have small diameter. To discuss our bottom-up approach, let us define our graphs $\hat{G}_{i}$ more precisely.

We maintain a separator hierarchy $\mathcal{S}=\{S_{0},S_{1},..,S_{\lfloor\lg{n}\rfloor+2}\}$ where $\hat{V}_{0}=S_{0}\supseteq S_{1}\supseteq..\supseteq S_{\lfloor\lg{n}\rfloor+1}=S_{\lfloor\lg{n}\rfloor+2}=\emptyset$, with $|S_{i}|\leq n/2^{i}$, for all $i\in[0,\lfloor\lg{n}\rfloor+2]$ (see below that for technical reasons we need to define $S_{\lfloor\lg{n}\rfloor+2}$ to define $\hat{G}_{\lfloor\lg{n}\rfloor+1}$). Each set $S_{i}$ is a set of single-vertex nodes – i.e. nodes of the form $\{v\}$ – that is monotonically increasing over time.

We can now more precisely define each edge set $E_{i}=E(\textsc{Flatten}(S_{i}\setminus S_{i+1}))$. To avoid clutter, we abuse notation slightly referring henceforth to $\textsc{Flatten}(X)$ simply as $X$ if $X$ is a set of singleton sets and the context is clear. We therefore obtain

[TABLE]

In particular, note that $\hat{G}_{i}$ contains all the edges of $G$ except those in $E(S_{i+1})$; as we move up to level $\hat{G}_{i+1}$, we add the edges incident to $S_{i+1}\setminus S_{i+2}$. Note that if $s\in S_{i}\setminus S_{i+1}$, and our algorithm then adds $s$ to $S_{i+1}$, this will remove all edges incident to $s$ from $E_{i}$ and add them to $E_{i+1}$. Thus the fact that the sets $S_{i}$ used by the algorithm are monotonically increasing implies the desired property that edges only move up the hierarchy (remember that we add more vertices to $S_{i}$ due to new separators found on level $i-1$).

At a high-level, the idea of the hierarchy is as follows. Focusing on a level $i$, when the “distances” in some SCC of $\hat{G}_{i}$ get too large (for a notion of distance defined below), the algorithm will add a carefully chosen set of separator nodes $s_{1},s_{2},..$ in $S_{i}$ to $S_{i+1}$. By definition of our hierarchy, this will remove the edges incident to the $s_{i}$ from $\hat{G}_{i}$, thus causing the SCCs of $\hat{G}_{i}$ to decompose into smaller SCCs with more manageable “distances”. We note that our algorithm always maintains the invariant that nodes added to $S_{i+1}$ were previously in $S_{i}$, which from the definition of our hierarchy, ensures that at all times the separator nodes in $S_{i+1}$ are single-vertex nodes in $\hat{V}_{i+1}$; this is because the nodes of $\hat{V}_{i+1}$ are the SCCs of $\hat{G}_{i}$, and $\hat{G}_{i}$ contains no edges incident to $S_{i+1}$.

Exploiting $S$-distances.

For our algorithm, classic ES-trees are only useful to maintain SCCs in $\hat{G}_{0}$; in order to handle levels $i>0$ we develop a new generalization of ES-trees that use a different notion of distance. This enables us to detect when SCCs are split in graphs $\hat{G}_{i}$ and to find separator nodes in $\hat{G}_{i}$ as discussed above more efficiently.

Our generalized ES-tree (GES-tree) can be seen as a combination of the classic ES-trees[ES81] and a data structure by Italiano[Ita88] that maintains reachability from a distinguished source in a directed acyclic graph (DAG), and which can be implemented in total update time $O(m)$.

Let $S$ be some feedback vertex set in a graph $G=(V,E)$; that is, every cycle in $G$ contains a vertex in $S$. Then our GES-tree can maintain $S$-distances and a corresponding shortest-path tree up to $S$-distance $\delta>0$ from a distinguished source $X_{i}^{r}$ for some $r\in V$ in the graph $G$. (See Section 2 for the definition of $S$-distances.) This data structure can be implemented to take $O(m\delta)$ total update time.

Maintaining the SCCs in $\hat{G}_{i}$.

Let us focus on maintaining SCCs in $\hat{G}_{i}=\textsc{Condensation}(G\setminus E(S_{i}))\cup E(S_{i}\setminus S_{i+1})$. Since the condensation of any graph forms a DAG, every cycle in $\hat{G}_{i}$ contains at least one edge from the set $E(S_{i}\setminus S_{i+1})$. Since $E(S_{i}\setminus S_{i+1})$ is a set of edges that is incident to $S_{i}$, we have that $S_{i}$ forms a feedback node set of $\hat{G}_{i}$. Now consider the scheme described in the paragraphs above, but instead of running an ES in-tree and out-tree from each center $\textsc{Center}(X)$ for some SCC $X$, we run a GES in-tree and out-tree on $\hat{G}_{i}[X]$ that maintains the $S_{i}$-distances to depth $\delta$. Using this GES, whenever a set $Y\subseteq X$ of nodes has $S_{i}$-distance $\Omega(\delta)$, we show that we can find a separator $S$ of size $O(\min\{|S_{i}\cap Y|,|S_{i}\cap(X\setminus Y)|\}\log n/\delta)$ that only consists of nodes that are in $\{\{s\}|s\in S_{i}\}$; we then add the elements of set $S$ to the set $S_{i+1}$, and we also remove the nodes $Y$ from the GES-tree, analogously to our discussion of regular ES-trees above. Note that adding $S$ to $S_{i+1}$ removes the edges $E(S)$ from $\hat{G}_{i}$; since we chose $S$ to be a separator, this causes $Y$ and $X\setminus Y$ to no longer be part of the same SCC in $\hat{G}_{i}$. Thus, to maintain the hierarchy, we must then split nodes in $\hat{G}_{i+1}$ into multiple nodes corresponding to the new SCCs in $\hat{G}_{i}$: $X\setminus(Y\cup S)$, $Y\setminus S$ and every single-vertex set in $S$ ($Y$ might not form a SCC but we then further decompose it after we handled the node split). This might cause some self-loops in $\hat{G}_{i+1}$ to become edges between the newly inserted nodes (resulting from the split) and needs to be handled carefully to embed the new nodes in the GES-trees maintained upon the SCC in $\hat{G}_{i+1}$ that $X$ is part of. Observe that this does not result in edge insertions but only remaps the endpoints of edges. Further observe that splitting nodes can only increase $S_{i+1}$-distance since when they were still contracted their distance from the center was equivalent. Since $S_{i+1}$-distance still might increase, the update to might trigger further changes in the graph $\hat{G}_{i+1}$.

Thus, overall, we ensure that all SCCs in $\hat{G}_{i}$ have $S_{i}$-diameter at most $O(\delta)$, and can hence be efficiently maintained by GES-trees. In particular, we show that whenever an SCC exceeds diameter $\delta$, we can, by moving a carefully chosen set of nodes in $S_{i}$ to $S_{i+1}$, remove a corresponding set of edges in $\hat{G}_{i}$, which breaks the large-$S_{i}$-diameter SCC into SCCs of smaller $S_{i}$-diameter.

Bounding the total update time.

Finally, let us sketch how to obtain the total expected running time $O(m\log^{4}n)$. We already discussed how by using random sources in GES-trees (analogously to the same strategy for ES-trees), we ensure that each node is expected to be in $O(\log n)$ GES-trees maintained to depth $\delta=O(\log^{2}n)$. Each such GES-tree is maintained in total update time $O(m\delta)=O(m\log^{2}n)$, so we have $O(m\log^{3}n)$ total expected update time for each level, and since we have $O(\log n)$ levels, we obtain total expected update time $O(m\log^{4}n)$. We point out that we have not included the time to compute the separators in our running time analysis; indeed, computing separators efficiently is one of the major challenges to building our hierarchy. Since implementing these subprocedures efficiently is rather technical and cumbersome, we omit their description from the overview but refer to section 6 for a detailed discussion.

4 Generalized ES-trees

Even and Shiloach[ES81] devised a data structure commonly referred to as ES-trees that given a vertex $r\in V$ in a graph $G=(V,E)$ undergoing edge deletions maintains the shortest-path tree from $r$ to depth $\delta$ in total update time $O(m\delta)$ such that the distance $\mathbf{dist}_{G}(r,v)$ of any vertex $v\in V$ can be obtained in constant time. Henzinger and King[HK95] later observed that the ES-tree can be adapted to maintain the shortest-path tree in directed graphs.

For our algorithm, we devise a new version of the ES-trees that maintains the shortest-path tree with regard to $S$-distances. We show that if $S$ is a feedback vertex set for $G$, that is a set such that every cycle in $G$ contains at least one vertex in $S$, then the data structure requires only $O(m\delta)$ total update time. Our fundamental idea is to combine classic ES-trees with techniques to maintain Single-Source Reachability in DAGs which can be implemented in linear time in the number of edges[Ita88]. Since $\mathbf{dist}_{G}(r,v)=\mathbf{dist}_{G}(r,v,V)$ and $V$ is a trivial feedback vertex set, we have that our data structure generalizes the classic ES-tree. Since the empty set is a feedback vertex set for DAGs, our data structure also matches the time complexity of Italiano’s data structure. We define the interface formally below.

Definition 4.1**.**

Let $G=(V,E)$ be a graph and $S$ a feedback vertex set for $G$, $r\in V$ and $\delta>0$. We define a generalized ES-tree $\mathcal{E}_{r}$ (GES) to be a data structure that supports the following operations:

• •

$\textsc{InitGES}(r,G,S,\delta)$: Sets the parameters for our data structure. We initialize the data structure and return the GES.

• •

$\textsc{Distance}(r,v)$: $\forall v\in V$, if $\mathbf{dist}_{G}(r,v,S)\leq\delta$, $\mathcal{E}_{r}$ reports $\mathbf{dist}_{G}(r,v,S)$, otherwise $\infty$.

• •

$\textsc{Distance}(v,r)$: $\forall v\in V$, if $\mathbf{dist}_{G}(v,r,S)\leq\delta$, $\mathcal{E}_{r}$ reports $\mathbf{dist}_{G}(v,r,S)$, otherwise $\infty$.

• •

$\textsc{Delete}(u,v)$: Sets $E\leftarrow E\setminus\{(u,v)\}$.

• •

$\textsc{Delete}(V^{\prime})$: For $V^{\prime}\subseteq V$, sets $V\leftarrow V\setminus V^{\prime}$, i.e. removes the vertices in $V^{\prime}$ and all incident edges from the graph $G$.

• •

$\textsc{GetUnreachableVertex}()$: Returns a vertex $v\in V$ with $\max\{\mathbf{dist}_{G}(r,v,S),\mathbf{dist}_{G}(v,r,S)\}>\delta$ or $\bot$ if no such vertex exists.

Lemma 4.2**.**

The GES $\mathcal{E}_{r}$ as described in definition 4.1 can be implemented with total initialization and update time $O(m\delta)$ and requires worst-case time $O(1)$ for each operation $\textsc{Distance}(\cdot)$ and $\textsc{GetUnreachableVertex}()$.

We defer the full prove to the appendix B but sketch the proof idea.

Proof.

(sketch) Consider a classic ES-tree with each edge weight $w(u,v)$ of an edge $(u,v)$ in $E_{out}(S)$ set to $1$ and all other edges of weight [math]. Then, the classic ES-tree analysis maintains with each vertex $v\in V$ the distance level $l(v)$ that expresses the current distance from $s$ to $v$. We also have a shortest-path tree $T$, where the path in the tree from $s$ to $v$ is of weight $l(v)$. Since $T$ is a shortest-path tree, we also have that for every edge $(u,v)\in E$, $l(v)\leq l(u)+w(u,v)$. Now, consider the deletion of an edge $(u,v)$ from $G$ that removes an edge that was in $T$. To certify that the level $l(v)$ does not have to be increased, we scan the in-going edges at $v$ and try to find an edge $(u^{\prime},v)\in E$ such that $l(v)=l(u^{\prime})+w(u^{\prime},v)$. On finding this edge, $(u^{\prime},v)$ is added to $T$. The problem is that if we allow [math]-weight cycles, the edge $(u^{\prime},v)$ that we use to reconnect $v$ might come from a $u^{\prime}$ that was a descendant of $v$ in $T$. This will break the algorithm, as it disconnects $v$ from $s$ in $T$. But we show that this bad case cannot occur because $S$ is assumed to be a feedback vertex set, so at least one of the vertices on the cycle must be in $S$ and therefore the out-going edge of this vertex must have weight $1$ contradicting that there exists any [math]-weight cycle. The rest of the analysis follows closely the classic ES-tree analysis. ∎

To ease the description of our SCC algorithm, we tweak our GES implementation to work on the multi-graphs $\hat{G}_{i}$. We still root the GES at a vertex $r\in V$, but maintain the tree in $\hat{G}_{i}$ at $X_{i}^{r}$. The additional operations and their running time are described in the following lemma whose proof is straight-forward and therefore deferred to appendix C. Note that we now deal with nodes rather than vertices which makes the definition of $S$-distances ambitious (consider for example a node containing two vertices in $S$). For this reason, we require $S\subseteq\{\{v\}|v\in V\}\cap\hat{V}$ in the lemma below, i.e. that the nodes containing vertices in $S$ are single-vertex nodes. But as discussed in the paragraph “Refining the hierarchy" in the overview, our hierarchy ensures that every separator node $X\in S_{i}$ is always just a single-vertex node in $\hat{G}_{i}$. Thus this constraint can be satisfied by our hierarchy.

Lemma 4.3**.**

Say we are given a partition $\hat{V}$ of a universe $V$ and the graph $\hat{G}=(\hat{V},E)$, a feedback node set $S\subseteq\{\{v\}|v\in V\}\cap\hat{V}$, a distinguished vertex $r\in V$, and a positive integer $\delta$. Then, we can run a GES $\mathcal{E}_{r}$ as in definition 4.1 on $\hat{G}$ in time $O(m\delta+\sum_{X\in\hat{V}}E(X)\log X)$ supporting the additional operations:

• •

$\textsc{SplitNode}(X)$: the input is a set of vertices $X$ contained in node $Y\in\hat{V}$, such that either $E\cap(X\times Y\setminus X)$ or $E\cap(Y\setminus X\times X)$ is an empty set, which implies $X\not\rightleftarrows_{\hat{G}\setminus S}Y\setminus X$. We remove the node $Y$ in $\hat{V}$ and add node $X$ and $Y\setminus X$ to $\hat{V}$.

• •

$\textsc{Augment}(S^{\prime})$: This procedure adds the nodes in $S^{\prime}$ to the feedback vertex set $S$. Formally, the input is a set of single-vertex sets $S^{\prime}\subseteq\{\{v\}|v\in V\}\cap\hat{V}$. $\textsc{Augment}(S^{\prime})$ then adds every $s\in S^{\prime}$ to $S$.

We point out that we enforce the properties on the set $X$ in the operation $\textsc{SplitNode}(X)$ in order to ensure that the set $S$ remains a feedback node set at all times.

5 Initializing the the graph hierarchy $\hat{\mathcal{G}}$

We assume henceforth that the graph $G$ initially is strongly-connected. If the graph is not strongly-connected, we can run Tarjan’s algorithm[Tar72] in $O(m+n)$ time to find the SCCs of $G$ and run our algorithm on each SCC separately.

Our procedure to initialize our data structure is presented in pseudo-code in algorithm 1. We first initialize the level [math] where $\hat{G}_{0}$ is simply $G$ with the vertex set $V$ mapped to the set of singletons of elements in $V$.

Let us now focus on an iteration $i$. Observe that the graph $\hat{G}_{i}$ initially has all edges in $E$ (by initializing each $\hat{G}_{i}$ in line 1 or line 1). Our goal is then to ensure that all SCCs in $\hat{G}_{i}$ are of small $S_{i}$-diameter at the cost of removing some of the edges from $\hat{G}_{i}$. Invoking the procedure $\textsc{Split}(\hat{G}_{i},S_{i},\delta/2)$ provides us with a set of separator nodes $S_{Sep}$ whose removal from $\hat{G}_{i}$ ensure that the $S_{i}$ diameter of all remaining SCCs is at most $\delta$. The set $P$ is the collection of all these SCCs, i.e. the collection of the SCCs in $\hat{G}_{i}\setminus E(S_{Sep})$.

Lemma 5.1 below describes in detail the properties satisfied by the procedure $\textsc{Split}(\hat{G}_{i},S_{i},\delta/2)$. In particular, besides the properties ensuring small $S_{i}$-diameter in the graph $\hat{G}_{i}\setminus E(S_{Sep})$ (properties 1 and 2), the procedure also gives an upper bound on the number of separator vertices (property 3). Setting $\delta=64\lg^{2}n$, clearly implies that $|S_{Sep}|\leq|S_{i}|/2$ and ensures running time $O(m\log^{3}n)$.

Lemma 5.1**.**

$\textsc{Split}(\hat{G}_{i},S_{i},\delta/2)$* returns a tuple $(S_{Sep},P)$ where $P$ is a partition of the node set $\hat{V}_{i}$ such that*

for $X\in P$, and nodes $u,v\in X$ we have $\mathbf{dist}_{G\setminus E(S_{Sep})}(u,v,S)\leq\delta/2$, and 2. 2.

for distinct $X,Y\in P$, with nodes $u\in X$ and $v\in Y$, $u\not\rightleftarrows_{G\setminus E(S_{Sep})}v$, and 3. 3.

$|S_{Sep}|\leq\frac{32\lg^{2}n}{\delta}|S_{i}|$.

The algorithm runs in time $O\left(\delta m\lg n\right)$.

We then set $S_{i+1}=S_{Sep}$ which implicitly removes the edges $E(S_{i+1})$ from the graph $\hat{G}_{i}$. We then invoke the procedure $\textsc{InitNewPartition}(P,i,\delta)$, that is presented in algorithm 2. The procedure initializes for each $X\in P$ that corresponds to an SCC in $\hat{G}_{i}$ the GES-tree from a vertex $r\in\textsc{Flatten}(X)$ chosen uniformly at random on the induced graph $\hat{G}_{i}[X]$. Observe that we are not explicitly keeping track of the edge set $E_{i}$ but further remove edges implicitly by only maintaining the induced subgraphs of $\hat{G}_{i}$ that form SCCs. A small detail we want to point out is that each separator node $X\in S_{Sep}$ also forms its own single-node set in the partition $P$.

On returning to algorithm 1, we are left with initializing the graph $\hat{G}_{i+1}$. Therefore, we simply set $\hat{V}_{i+1}$ to $P$ and use again all edges $E$. Finally, we initialize $S_{\lfloor\lg n\rfloor+2}$ to the empty set which remains unchanged throughout the entire course of the algorithm.

Let us briefly sketch the analysis of the algorithm which is more carefully analyzed in subsequent sections. Using again $\delta=64\lg^{2}n$ and lemma 5.1, we ensure that $|S_{i+1}|\leq|S_{i}|/2$, thus $|S_{i}|\leq n/2^{i}$ for all levels $i$. The running time of executing the $\textsc{Split}(\cdot)$ procedure $\lfloor\lg n\rfloor+1$ times incurs running time $O(m\log^{4}n)$ and initializing the GES-trees takes at most $O(m\delta)$ time on each level therefore incurring running time $O(m\log^{3}n)$.

6 Finding Separators

Before we describe how to update the data structure after an edge deletion, we want to explain how to find good separators since it is crucial for our update procedure. We then show how to obtain an efficient implementation of the procedure $\textsc{Split}(\cdot)$ that is the core procedure in the initialization.

Indeed, the separator properties that we want to show are essentially reflected in the properties of lemma 5.1. For simplicity, we describe the separator procedures on simple graphs instead of our graphs $\hat{G}_{i}$; it is easy to translate these procedures to our multi-graphs $\hat{G}_{i}$ because the separator procedures are not dynamic; they are only ever invoked on a fixed graph, and so we do not have to worry about node splitting and the like.

To gain some intuition for the technical statement of our separator properties stated in lemma 6.1, consider that we are given a graph $G=(V,E)$, a subset $S$ of the vertices $V$, a vertex $r\in V$ and a depth $d$. Our goal is to find a separator $S_{Sep}\subseteq S$, such that every vertex in the graph $G\setminus S_{Sep}$ is either at $S$-distance at most $d$ from $r$ or cannot be reached from $r$, i.e. is separated from $r$.

We let henceforth $V_{Sep}\subseteq V$ denote the set of vertices that are still reachable from $r$ in $G\setminus S_{Sep}$ (in particular there is no vertex $S_{Sep}$ contained in $V_{Sep}$ and $r\in V_{Sep}$). Then, a natural side condition for separators is to require the set $S_{Sep}$ to be small in comparison to the smaller side of the cut, i.e. small in comparison to $\min\{|V_{Sep}|,|V\setminus(V_{Sep}\cup S_{Sep})|\}$.

Since we are concerned with $S$-distances, we aim for a more general guarantee: we want the set $S_{Sep}$ to be small in comparison to the number of $S$ vertices on any side of the cut, i.e. small in comparison to $\min\{|V_{Sep}\cap S|,|(V\setminus(V_{Sep}\cup S_{Sep}))\cap S|\}$. This is expressed in property 3 of the lemma.

Lemma 6.1** (Balanced Separator).**

There exists a procedure $\textsc{OutSeparator}(r,G,S,d)$ (analogously $\textsc{InSeparator}(r,G,S,d)$) where $G=(V,E)$ is a graph, $r\in V$ a root vertex, $S\subseteq V$ and $d$ a positive integer. The procedure computes a tuple $(S_{Sep},V_{Sep})$ such that

$S_{Sep}\subseteq S$, $V_{Sep}\subseteq V$, $S_{Sep}\cap V_{Sep}=\emptyset$, $r\in V_{Sep}$, 2. 2.

$\forall v\in V_{Sep}\cup S_{sep}$, we have $\mathbf{dist}_{G}(r,v,S)\leq d$ (analogously $\mathbf{dist}_{G}(v,r,S)\leq d$ for $\textsc{InSeparator}(r,G,S,d)$), 3. 3.

[TABLE]

and 4. 4.

for any $x\in V_{Sep}$ and $y\in V\setminus(S_{Sep}\cup V_{Sep})$, we have $u\not\leadsto_{G\setminus E(S_{Sep})}v$ (analogously $v\not\leadsto_{G\setminus E(S_{Sep})}u$ for $\textsc{InSeparator}(r,G,S,d)$).

The running time of both $\textsc{OutSeparator}(\cdot)$ and $\textsc{InSeparator}(\cdot)$ can be bounded by $O(E(V_{Sep}))$.

Again, we defer the proof of the lemma 6.1 to the appendix D, but sketch the main proof idea.

Proof.

To implement procedure $\textsc{OutSeparator}(r,G,S,d)$, we start by computing a BFS at $r$. Here, we assign edges in $E_{out}(S)$ again weight $1$ and all other edges weight [math] and say a layer consists of all vertices that are at same distance from $r$. To find the first layer, we can use the graph $G\setminus E_{out}(S)$ and run a normal BFS from $r$ and all vertices reached form the first layer $L_{0}$. We can then add for each edge $(u,v)\in E_{out}(S)$ with $u\in L_{0}$ the vertex $v$ to $L_{1}$ if it is not already in $L_{0}$. We can then contract all vertices visited so far into a single vertex $r^{\prime}$ and repeat the procedure described for the initial root $r$. It is straight-forward to see that the vertices of a layer that are also in $S$ form a separator of the graph. To obtain a separator that is small in comparison to $|V_{Sep}\cap S|$, we add each of the layers [math] to $d/2$ one after another to our set $V_{Sep}$, and output the index $i$ of the first layer that grows the set of $S$-vertices in $V_{Sep}$ by factor less than $(1+\frac{2\log n}{d})$. We then set $S_{Sep}$ to be the vertices in $S$ that are in layer $i$. If the separator is not small in comparison to $|(V\setminus(S_{Sep}\cup V_{Sep}))\cap S|$, we grow more layers and output the first index of a layer such that the separator is small in comparison to $|(V\setminus(S_{Sep}\cup V_{Sep}))\cap S|$. This layer must exist and is also small in comparison to $|V_{Sep}\cap S|$. Because we find our separator vertices $S_{Sep}$ using a BFS from $r$, a useful property of our separator is that all the vertices in $S_{Sep}$ and $V_{Sep}$ are within bounded distance from $r$.

Finally, we can ensure that the running time of the procedure is linear in the size of the set $E(V_{Sep})$, since these are the edges that were explored by the BFS from root $r$. ∎

Let us now discuss the procedure $\textsc{Split}(G,S,d)$ that we already encountered in section 5 and whose pseudo-code is given in algorithm 3. Recall that the procedure computes a tuple $(S_{Split},P)$ such that the graph $G\setminus E(S_{Split})$ contains no SCC with $S$-diameter larger $d$ and where $P$ is the collection of all SCCs in the graph $G\setminus E(S_{Split})$.

Let us sketch the implementation of the procedure $\textsc{Split}(G,S,d)$. We first pick an arbitrary vertex and invoke the procedures $\textsc{OutSeparator}(r,G^{\prime},S,d/4)$ and $\textsc{InSeparator}(r,G^{\prime},S,d/4)$ to run in parallel, that is the operations of the two procedures are interleaved during the execution. If one of these subprocedures returns and presents a separator tuple $(S_{Sep},V_{Sep})$, the other procedure is aborted and the tuple $(S_{Sep},V_{Sep})$ is returned. If $|V_{Sep}|\leq\frac{2}{3}|V|$, then we conclude that the separator function only visited a small part of the graph. Therefore, we use the separator subsequently, but denote the tuple henceforth as $(S^{\prime}_{Sep},V^{\prime}_{Sep})$. Otherwise, we decide the separator is not useful for our purposes. We therefore return to the subprocedure we previously aborted and continue its execution. We then continue with the returned tuple $(S^{\prime}_{Sep},V^{\prime}_{Sep})$.

From there on, there are two possible scenarios. The first scenario is that the subprocedure producing $(S^{\prime}_{Sep},V^{\prime}_{Sep})$ has visited a rather small fraction of the vertices in $V$ (line 3); in this case, we have pruned away a small number of vertices $V^{\prime}_{Sep}$ while only spending time proportional to the smaller side of the cut, so we can simply recurse on $V^{\prime}_{Sep}$. We also have to continue pruning away vertices from the original set $V$, until we have either removed all vertices from $G$ by finding these separators and recursing, or until we enter the else-case (line 3).

The else-case in line 3 is the second possible scenario: note that in this case we must have entered the else-case in line 3 and had both the $\textsc{InSeparator}(\cdot)$ and $\textsc{OutSeparator}(\cdot)$ explore the large side of the cut. Thus we cannot afford to simply recurse on the smaller side of the cut $V\setminus V^{\prime}_{sep}$, as we have already spent time $|V^{\prime}_{sep}|>|V\setminus V^{\prime}_{sep}|$. Thus, for this case we use a different approach. We observe that because we entered the else-case in line 3 and since we entered the else-case 3, we must have had that $|V_{Sep}|\geq\frac{2}{3}|V|$ and that $|V^{\prime}_{Sep}|\geq\frac{2}{3}|V|$. We will show that in this case, the root $r$ must have small $S$-distance to and at least $\frac{1}{3}|V|$ vertices. We then show that this allows us to efficiently prune away at most $\frac{2}{3}|V|$ vertices from $V$ at large $S$-distance to or from $r$. We recursively invoke $\textsc{Split}(\cdot)$ on the induced subgraphs of vertex sets that we pruned away.

We analyze the procedure in detail in multiple steps, and summarize the result in lemma 6.5 that is the main result of this section. Let us first prove that if the algorithm enters the else-case in line 3 then we add an SCC of size at least $\frac{1}{3}|V|$ to $P$.

Claim 6.2**.**

If the algorithm enters line 3 then the vertex set returned by $\mathcal{E}_{r}.\textsc{GetAllVertices}()$ in line 3 is of size at least $\frac{1}{3}|V|$.

Proof.

Observe first that since we did no enter the if-case in line 3, that $|V_{Sep}|>\frac{2}{3}|V|$ and $|V^{\prime}_{Sep}|>\frac{2}{3}|V|$ (since we also cannot have entered the if case in line 3).

Since we could not find a sufficiently good separator in either direction, we certified that the $S$-out-ball from $r$ defined

[TABLE]

has size greater than $\frac{2}{3}|V|$, and that similarly, the $S$-in-ball $B_{in}(r)$ of $r$ has size greater than $\frac{2}{3}|V|$. This implies that

[TABLE]

Further, we have that every vertex on a shortest-path between $r$ and a vertex $v\in B_{out}(r)\cap B_{in}(r)$ has a shortest-path from and to $r$ of length at most $d/16$. Thus the $S$-distance between any pair of vertices in $B_{out}(r)\cap B_{in}(r)$ is at most $d/8$. Now, let $SP$ be the set of all vertices that are on a shortest-path w.r.t. $S$-distance between two vertices in $B_{out}(r)\cap B_{in}(r)$. Clearly, $B_{out}(r)\cap B_{in}(r)\subseteq SP$, so $|SP|\geq|V|/3$. It is also easy to see that $G[SP]$ has $S$-diameter at most $d/4$.

At this point, the algorithm repeatedly finds a vertex $v$ that is far from $r$ and finds a separator from $v$. We will now show that the part of the cut containing $v$ is always disjoint from $SP$; since $|SP|>|V|/3$, this implies that at least $|V|/3$ vertices remain in $\mathcal{E}_{r}$.

Consider some vertex $v$ chosen in line 3. Let us say that we now run $\textsc{InSeparator}(v,G^{\prime},S,d/4)$; the case where we run $\textsc{OutSeparator}(v,G^{\prime},S,d/4)$ is analogous. Now, by property 2 in lemma 6.1, every $s\in S_{Sep}$ has $\mathbf{dist}(s,v,S)\leq d/4$. Thus, since we only run the InSeparator if we have $\mathbf{dist}(r,v,S)>d/2$, we must have $\mathbf{dist}(r,s,S)>d/4$. ∎

We point out that claim 6.2 implies that $\textsc{Split}(\cdot)$ only recurses on disjoint subgraphs containing at most a $2/3$ fraction of the vertices of the given graph. To see this, observe that we either recurse in line 3 on $G^{\prime}[V^{\prime}_{Sep}]$ after we explicitly checked whether $|V^{\prime}_{Sep}|\leq\frac{2}{3}|V|$ in the if-condition, or we recurse in line 3 on the subgraph pruned from the set of vertices that $\mathcal{E}_{r}$ was initialized on. But since by claim 6.2 the remaining vertex set in $\mathcal{E}_{r}$ is of size at least $|V|/3$, the subgraphs pruned away can contain at most $\frac{2}{3}|V|$ vertices.

We can use this observation to establish correctness of the $\textsc{Split}(\cdot)$ procedure.

Claim 6.3**.**

$\textsc{Split}(G,S,d)$* returns a tuple $(S_{Sep},P)$ where $P$ is a partition of the vertex set $V$ such that*

for $X\in P$, and vertices $u,v\in X$ we have $\mathbf{dist}_{G\setminus E(S_{Sep})}(u,v,S)\leq d$, and 2. 2.

for distinct $X,Y\in P$, with vertices $u\in X$ and $v\in Y$, $u\not\rightleftarrows_{G\setminus E(S_{Sep})}v$, and 3. 3.

$|S_{Split}|\leq\frac{32\log n}{d}\sum_{X\in P}\lg(n-|X\cap S|)|X\cap S|$.

Proof.

Let us start with the first two properties which we prove by induction on the size of $|V|$ where the base case $|V|=1$ is easily checked. For the inductive step, observe that each SCC $X$ in the final collection $P$ was added to $P$ in line 3, 3 or 3. We distinguish by 3 cases:

a vertex $s$ was added as singleton set after appearing in a separator $S_{Sep}$ but then $\{s\}$ is strongly-connected and $s$ cannot reach any other vertex in $G\setminus E(S_{Sep})$ since it has no out-going edges, or 2. 2.

an SCC $X$ was added as part of a collection $P^{\prime\prime\prime}$ in line 3. But then we have that the collection $P^{\prime\prime\prime}$ satisfies the properties in $G[V^{\prime\prime}_{Sep}]$ by the induction hypothesis and since $V^{\prime\prime}_{Sep}$ was a cut side and $S^{\prime\prime}_{Sep}$ added to $S_{out}$, we have that there cannot be a path to and from any vertex in $G\setminus E(S_{out})$, or 3. 3.

we added the non-trivial SCC $X$ to $P$ after constructing an GES-tree from some vertex $r\in X$ and after pruning each vertex at $S$-distance to/from $r$ larger than $d/2$ (see the while loop on line 3). But then each vertex that remains in $X$ can reach $r$ within $S$-distance $d/2$ and is reached from $r$ within distance $d/2$ implying that any two vertices $u,v\in X$ have a path from $u$ to $v$ of $S$-distance at most $d$.

Finally, let us upper bound the number of vertices in $S_{Split}$. We use a classic charging argument and argue that each time we add a separator $S_{Sep}$ to $S_{Split}$ with sides $V_{Sep}$ and $V\setminus(V_{Sep}\cup S_{Sep})$ at least one of these sides contains at most half the $S$-vertices in $V\cap S$. Let $X$ be the smaller side of the cut (in term of $S$-vertices) then by property 3 from lemma 6.1, we can charge each $S$ vertex in $X$ for $\frac{32\log{n}}{d}$ separator vertices (since we invoke $\textsc{OutSeparator}(\cdot)$ and $\textsc{InSeparator}(\cdot)$ with parameter at least $d/16$).

Observe that once we determined that a separator $S_{Sep}$ that is about to be added to $S_{Split}$ in line 3 or 3, we only recurse on the induced subgraph $G^{\prime}[V_{Sep}]$ and let the graph in the next iteration be $G^{\prime}[V\setminus(V_{Sep}\cup S_{Sep})$.

Let $X$ be an SCC in the final collection $P$. Then each vertex $v\in X$ can only have been charged at most $\lg(n-|X\cap S|)$ times. The lemma follows. ∎

It remains to bound the running time. Before we bound the overall running time, let us prove the following claim on the running time of invoking the separator procedures in parallel.

Claim 6.4**.**

We spend $O(E(V^{\prime}_{Sep}\cup S^{\prime}_{Sep}))$ time to find a separator in line 3 or 3.

Proof.

Observe that we run the subprocedures $\textsc{OutSeparator}(r,G^{\prime},S,d/16)$ and $\textsc{InSeparator}(r,G^{\prime},S,d/16)$ in line 3 in parallel. Therefore, when we run them, we interleave their machine operations, computing one operation from $\textsc{OutSeparator}(r,G^{\prime},S,d/16)$ and then one operation from $\textsc{InSeparator}(r,G^{\prime},S,d/16)$ in turns. Let us assume that $\textsc{OutSeparator}(r,G^{\prime},S,d/16)$ is the first subprocedure that finishes and returns tuple $(S_{Sep},V_{Sep})$. Then, by lemma 6.1, the subprocedure used $O(E(V_{Sep}\cup S_{Sep}))$ time. Since the subprocedure $\textsc{InSeparator}(r,G^{\prime},S,d/16)$ ran at most one more operation than $\textsc{OutSeparator}(r,G^{\prime},S,d/16)$, it also used $O(E(V_{Sep}\cup S_{Sep}))$ operations. A symmetric argument establishes the same bounds, if $\textsc{InSeparator}(r,G^{\prime},S,d/16)$ finishes first. The overhead induced by running two procedures in parallel can be made constant.

Since assignments take constant time, the claim is vacuously true by our discussion if the if-case in line 3 is true. Otherwise, we compute a new separator tuple by continuing the execution of the formerly aborted separator subprocedure. But by the same argument as above, this subprocedure’s running time now clearly dominates the running time of the subprocedure that finished first in line 3. The time to compute $(S^{\prime}_{Sep},V^{\prime}_{Sep})$ is thus again upper bounded by $O(E(V^{\prime}_{Sep}))$ by lemma 6.1, as required. ∎

Finally, we have established enough claims to prove lemma 6.5.

Lemma 6.5** (Strengthening of lemma 5.1).**

$\textsc{Split}(G,S,d)$* returns a tuple $(S_{Split},P)$ where $P$ is a partition of the vertex set $V$ such that*

for $X\in P$, and vertices $u,v\in X$ we have $\mathbf{dist}_{G\setminus E(S_{Split})}(u,v,S)\leq d$, and 2. 2.

for distinct $X,Y\in P$, with vertices $u\in X$ and $v\in Y$, $u\not\rightleftarrows_{G\setminus E(S_{Split})}v$, and 3. 3.

$|S_{Split}|\leq\frac{32\log n}{d}\sum_{X\in P}\lg(n-|X\cap S|)|X\cap S|$**

The algorithm runs in time $O\left(d\sum_{X\in P}(1+\lg(n-|X|))E(X)\right)$.

Proof.

Since correctness was established in lemma 6.3, it only remains to bound the running time of the procedure. Let us first bound the running time without recursive calls to procedure $\textsc{Split}(G,S,d)$. To see that we only spend $O(|E(G)|d)$ time in $\textsc{Split}(G,S,d)$ excluding recursive calls, observe first that we can find each separator tuple $(S^{\prime}_{Sep},V^{\prime}_{Sep})$ in time $O(E(V^{\prime}_{Sep}))$ by claim 6.4. We then, either recurse on $G^{\prime}[V^{\prime}_{Sep}])$ and remove the vertices $V^{\prime}_{Sep}\cup S^{\prime}_{Sep}$ with their incident edges from $G^{\prime}$ or we enter the else-case (line 3). Clearly, if our algorithm never visits the else-case, we only spend time $O(|E(G)|)$ excluding the recursive calls since we immediately remove the edge set that we found in the separator from the graph.

We further observe that the running time for the GES-tree can be bounded by $O(|E(G)|d)$. The time to compute the separators to prune vertices away from the GES-tree is again combined at most $O(|E(G)|)$ by lemma 6.1 and the observation that we remove edges from the graph $G$ after they were scanned by one such separator procedure.

We already discussed that claim 6.2 implies that we only recurse on disjoint subgraphs with at most $\frac{2}{3}|V|$ vertices. We obtain that each vertex in a final SCC $X$ in $P$ participated in at most $O(\log(n-|X|))$ levels of recursion and so did its incident edges hence we can then bound the total running time by $O\left(d\sum_{X\in P}(1+\log(n-|X|))E(X)\right)$. ∎

7 Handling deletions

Let us now consider how to process the deletion of an edge $(u,v)$ which we describe in pseudo code in algorithm 4. We fix our data structure in a bottom-up procedure where we first remove the edge $(u,v)$ if it is contained in any induced subgraph $\hat{G}_{i}[X]$ from the GES $\mathcal{E}_{\textsc{Center}(X)}$.

Then, we check if any GES $\mathcal{E}_{\textsc{Center}(X)}$ on a subgraph $\hat{G}_{i}[X]$ contains a node that became unreachable due to the edge deletion or the fixing procedure on a level below. Whilst there is such a GES $\mathcal{E}_{\textsc{Center}(X)}$, we first find a separator $S_{Sep}$ from $X^{\prime}$ in lines 4 or 4. We now consider two cases based on the size of the set $\textsc{Flatten}(V_{Sep})$. Whilst focusing on the size of $\textsc{Flatten}(V_{Sep})$ instead of the size of $V_{Sep}$ seems like a minor detail, it is essential to consider the underlying vertex set instead of the node set, since the node set can be further split by node split updates from lower levels.

Now, let us consider the first case, when the set $V_{Sep}$ separated by $S_{Sep}$ is small (with regard to $\textsc{Flatten}(V_{Sep})$); in this case, we simply prune $V_{Sep}$ from our tree by adding $S_{Sep}$ to $S_{i+1}$, and then invoke $\textsc{Split}(\hat{G}_{i}[V_{Sep}],V_{Sep}\cap S_{i},\delta/2)$ to get a collection of subgraphs $P^{\prime}$ where each subgraph $Y\in P^{\prime}$ has every pair of nodes $A,B\in Y$ at $S_{i}$-distance $\delta/2$. (We can afford to invoke Split on the vertex set $V_{Sep}$ because we can afford to recurse to on the smaller side of a cut.)

The second case is when $V_{Sep}$ is large compared to the number of vertices in node set of the GES-tree. In this case we do not add $S_{Sep}$ to $S_{i+1}$. Instead we we declare the GES-tree $\mathcal{E}_{\textsc{Center}(X)}$ invalid, and delete the entire tree. We then partition the set $X$ that we are working with by invoking the Split procedure on all of $X$. (Intuitively, this step is expensive, but we will show that whenever it occurs, there is a constant probability that the graph has decomposed into smaller SCCs, and we have thus made progress.)

Finally, we use the new partition and construct on each induced subgraph a new GES-tree at a randomly chosen center. This is done by the procedure $\textsc{InitNewPartition}(P^{\prime},i,\delta)$ that was presented in subsection 5. We then apply the updates to the graph $\hat{G}_{i+1}$ using the GES-tree operations defined in lemma 4.3. Note, that we include the separator vertices as singleton sets in the partition and therefore invoke $\mathcal{E}_{X}.\textsc{SplitNode}(\cdot)$ on each singleton before invoking $\mathcal{E}_{X}.\textsc{Augment}(S^{\prime\prime}_{Sep})$ which ensures that the assumption from lemma 4.3 is satisfied. As in the last section, let us prove the following two lemmas whose proofs will further justify some of the details of the algorithm.

We start by showing that because we root the GES-tree for SCC $X$ at a random root $r$, if the GES-tree ends up being deleted in 4 in algorithm 4, this means that with constant probability $X$ has decomposed into smaller SCCs, and so progress has been made.

Lemma 7.1** (c.f. also [Che+16], Lemma 13).**

Consider an GES $\mathcal{E}_{r}=\mathcal{E}_{\textsc{Center}(X)}$ that was initialized on the induced graph of some node set $X_{Init}$, with $X\subseteq X_{Init}$, and that is deleted in line 4 in algorithm 4. Then with probability at least $\frac{2}{3}$, the partition $P^{\prime\prime}$ computed in line 4 satisfies that each $X^{\prime}\in P^{\prime\prime}$ has $|\textsc{Flatten}(X^{\prime})|\leq\frac{2}{3}|\textsc{Flatten}(X_{Init})|$.

Proof.

Let $i$ be the level of our hierarchy on which $\mathcal{E}_{r}$ was initialized, i.e. $\mathcal{E}_{r}$ was initialized on graph $\hat{G}_{i}[X_{Init}]$, and went up to depth $\delta$ with respect to $S_{i}$-distances (see Algorithm 2).

Let $u_{1},u_{2},..$ be the sequence of updates since the GES-tree $\mathcal{E}_{r}$ was initialized that were either adversarial edge deletions, nodes added to $S_{i}$ or node splits in the graph $\hat{G}_{i}[X_{Init}]$. Observe that this sequence is independent of how we choose our random root $r$, since they occur at a lower level, and so do not take any GES-trees at level $i$ into account. Recall, also, that the adversary cannot learn anything about $r$ from our answers to queries because the SCCs of the graph are objective, and so do not reveal any information about our algorithm. We refer to the remaining updates on $\hat{G}_{i}[X_{Init}]$ as separator updates, which are the updates adding nodes to $S_{i+1}$ and removing edges incident to $S_{i+1}$ or between nodes that due to such edge deletions are no longer strongly-connected. We point out that the separator updates are heavily dependent on how we chose our random source. The update sequence that the GES-tree undergoes up to its deletion in line 4 is a mixture of the former updates that are independent of our chosen root $r$ and the separator updates.

Let $G^{j}$ be the graph $\hat{G}_{i}$ after the update sequence $u_{1},u_{2},...,u_{j}$ is applied. Let $X_{max}^{j}$ be the component of $S_{i}$-diameter at most $\delta/2$ that maximizes the cardinality of $\textsc{Flatten}(X_{max}^{j})$ in $G^{j}$. We choose $X_{max}^{j}$ in this way because we want to establish an upper bound on the largest SCC of $S_{i}$-diameter at most $\delta/2$ in $G^{j}$. We then show that that if a randomly chosen source deletes a GES-tree (see line 4) after $j$ updates, then there is a good probability that $X_{max}^{j}$ is small. Then by the guarantees of lemma 5.1, the $\textsc{Split}(\cdot)$ procedure in line 4 partitions the vertices into SCCs $X^{\prime}$ of $S_{i}$-diameter at most $\delta/2$, which all have small $|\textsc{Flatten}(X^{\prime})|$ because $X_{max}^{j}$ is small.

More precisely, let $G^{j}_{r}$, be the graph is obtained by applying all updates up to update $u_{j}$ to $\hat{G}_{i}[X_{Init}]$; here we include the updates $u_{1},...,u_{j}$, as well as all separator updates up to the time when $u_{j}$ takes place. (Observe that $G^{j}$ is independent from the choice of $r$, but $G^{j}_{r}$ is not.) Let $X_{max,r}^{j}$ be the component of $S_{i}$-diameter at most $\delta/2$ that maximizes the cardinality of $\textsc{Flatten}(X^{j}_{max,r})$ in this graph $G^{j}_{r}$. It is straight-forward to see that since $S_{i}$-distances can only increase due to separator updates, we have $|\textsc{Flatten}(X_{max,r}^{j})|\leq|\textsc{Flatten}(X_{max}^{j})|$ for any $r$. Further $|\textsc{Flatten}(X_{max,r}^{j})|$ upper bounds the size of any component $X^{\prime}\in P^{\prime\prime}$, i.e. $|\textsc{Flatten}(X^{\prime})|\leq|\textsc{Flatten}(X_{max,r}^{j})|$ if the tree $\mathcal{E}_{r}$ is deleted in line 4 while handling update $u_{j}$; the same bound holds if $\mathcal{E}_{r}$ is deleted after update $u_{j}$, because the cardinality of $\textsc{Flatten}(X_{max,r}^{j})$ monotonically decreases in $j$, i.e. $|\textsc{Flatten}(X_{max,r}^{j})|\leq|\textsc{Flatten}(X_{max,r}^{j-1})|$ since updates can only increase $S_{i}$-distances.

Now, let $k$ be the index, such that

[TABLE]

i.e. $k$ is chosen such that after the update sequence $u_{1},u_{2},...,u_{k}$ were applied to $\hat{G}_{i}[X_{Init}]$, there exists no SCC $X$ in $G^{k}$ of diameter at most $\delta/2$ with $|\textsc{Flatten}(X)|>\frac{2}{3}|\textsc{Flatten}(X_{Init})|$.

In the remainder of the proof, we establish the following claim: if we chose some vertex $r\in\textsc{Flatten}(X^{k-1}_{max})$, then the GES-tree would not be been deleted before update $u_{k}$ took place. Before we prove this claim, let us point out that this implies the lemma: observe that by the independence of how we choose $r$ and the update sequence $u_{1},u_{2},..$, we have that

[TABLE]

where the before-last equality follows from the fact that we choose the root uniformly at random among the vertices in $\textsc{Flatten}(X_{Init})$. Thus, with probability at least $\frac{2}{3}$, we chose a root whose GES-tree is deleted during or after the update $u_{k}$ and therefore the invoked procedure $\textsc{Split}(\cdot)$ ensures that every SCC $X^{\prime}\in P^{\prime\prime}$ satisfies $|\textsc{Flatten}(X^{\prime})|\leq|\textsc{Flatten}(X_{max}^{k})|\leq\frac{2}{3}|\textsc{Flatten}(X_{Init})|$, as required.

Now, let us prove the final claim. We want to show that if $r\in X^{k-1}_{max}$, then the GES-tree would not have been deleted before update $u_{k}$. To do so, we need to show that even if we include the separator updates, the SCC containing $r$ continues to have size at least $\frac{2}{3}|\textsc{Flatten}(X_{Init})|$ before update $u_{k}$. In particular, we argue that before update $u_{k}$, none of the separator updates decrease the size of $X^{k-1}_{max}$. The reason is that the InSeparator computed in Line 4 of Algorithm 4 is always run from a node $X$ whose $S_{i}$-distance from $r$ is at least $\delta$. (The argument for an OutSeparator in Line 4 is analogous.) Now, the InSeparator from $X$ is computed up to $S_{i}$-distance $\delta/2$, so by Property 2 of Lemma 6.1, we have that all nodes pruned away from the component have $S_{i}$-distance at most $\delta/2$ to $X$; this implies that these nodes have $S_{i}$-distance more than $\delta/2$ from $r$, and so cannot be in $X^{k-1}_{max}$, because $X^{k-1}_{max}$ was defined to have $S_{i}$-diameter at most $\delta/2$. Thus none of the separator updates affect $X^{k-1}_{max}$ before update $u_{k}$, which concludes the proof of the lemma.

∎

Next, let us analyze the size of the sets $S_{i}$. We analyze $S_{i}$ using the inequality below in order to ease the proof of the lemma. We point out that the term $\lg(n-|X\cup S_{i}|)$ approaches $\lg n$ as the SCC $X$ splits further into smaller pieces. Our lemma can therefore be stated more easily, see therefore corollary 7.3.

Lemma 7.2**.**

During the entire course of deletions our algorithm maintains

[TABLE]

Proof.

We prove by induction on $i$. It is easy to see that $S_{0}$ has cardinality $n$ since we initialize it to the node set in procedure 1, and since each set $S_{i}$ is an increasing set over time.

Let us therefore focus on $i>0$. Let us first assume that the separator nodes were added by the procedure $\textsc{OutSeparator}(\cdot)$ (analogously $\textsc{InSeparator}(\cdot)$). Since the procedure is invoked on an induced subgraph $\hat{G}_{i}[X]$ that was formerly strongly-connected, we have that either $V_{Sep}$ or $X\setminus(V_{Sep}\cup S_{Sep})$ (or both) contain at most half the $S_{i}$-nodes originally in $X$. Let $Y$ be such a side. Since adding $S_{Sep}$ to $S_{i}$ separates the two sides, we have that RHS of the equation is increased by at least $\frac{32\log n}{\delta}|Y\cap S_{i}|$ since $\lg(n-|Y\cap S_{i}|)|Y\cap S_{i}|-\lg(n-|X\cap S_{i}|)|Y\cap S_{i}|\geq|Y\cap S_{i}|$. Since we increase the LHS by at most $\frac{4\log n}{\delta}|Y\cap S_{i}|$ by the guarantees in lemma 6.1, the inequality is still holds.

Otherwise, separator nodes were added due to procedure $\textsc{Split}(\cdot)$. But then we can straight-forwardly apply lemma 6.5 which immediately implies that the inequality still holds.

Finally, the hierarchy might augment the set $S_{i}$ in line 4, but we observe that $f(s)=\lg(n-s)*s$ is a function increasing in $s$ for $s\leq\frac{1}{2}n$ which can be proven by finding the derivative. Thus adding nodes to the set $S_{i}$ can only increase the RHS whilst the LHS remains unchanged. ∎

Corollary 7.3**.**

During the entire course of deletions, we have $|S_{i+1}|\leq\frac{16\lg^{2}n}{\delta}|S_{i}|$, for any $i\geq 0$.

8 Putting it all together

By corollary 7.3, using $\delta=64\lg^{2}n$, we enforce that each $|S_{i}|\leq n/2^{i}$, so $\hat{G}_{\lfloor\lg{n}\rfloor+1}$ is indeed the condensation of $G$. Thus, we can return on queries asking whether $u$ and $v$ are in the same SCC of $G$, simply by checking whether they are represented by the same node in $\hat{G}_{\lfloor\lg{n}\rfloor+1}$ which can be done in constant time.

We now upper bound the running time of our algorithm by $O(m\log^{5}n)$ and then refine the analysis slightly to obtain the claimed running time of $O(m\log^{4}n)$.

By lemma 7.1, we have that with probability $\frac{2}{3}$, that every time a node leaves a GES, its induced subgraph contains at most a fraction of $\frac{2}{3}$ of the underlying vertices of the initial graph. Thus, in expectation each vertex in $V$ participates on each level in $O(\log n)$ GES-trees. Each time it contributes to the GES-trees running time by its degree times the depth of the GES-tree which we fixed to be $\delta$. Thus we have expected time $O(\sum_{v\in V}\mathbf{deg}(v)\delta\log n)=O(m\log^{3}n)$ to maintain all the GES-trees on a single level by lemma 4.3. There are $O(\log n)$ levels in the hierarchy, so the total expected running time is bounded by $O(m\log^{4}n)$.

By lemmas 6.5, the running time for invoking $\textsc{Split}(G[X],S,\delta/2)$ can be bounded by $O(E(X)\delta\log n)=O(E(X)\log^{3}n)$. After we invoke $\textsc{Split}(G[X],S,\delta/2)$ in algorithm 4, we expect with constant probability again by lemma 7.1, that each vertex is at most $O(\log n)$ times in an SCC on which the $\textsc{Split}(\cdot)$ procedure is invoked upon. We therefore conclude that total expected running time per level is $O(m\log^{4}n)$, and the overall total is $O(m\log^{5}n)$.

Finally, we can bound the total running time incurred by all invocations of $\textsc{InSeparator}(\cdot)$ and $\textsc{OutSeparator}(\cdot)$ outside of $\textsc{Split}(\cdot)$ by the same argument and obtain total running time $O(m\log^{2}n)$ since each invocation takes time $O(E(G))$ on a graph $G$.

This completes the running time analysis, establishing the total expected running time $O(m\log^{5}n)$. We point out that the bottleneck of our algorithm are the invocations of $\textsc{Split}(\cdot)$. We can reduce the total expected cost of these invocations to $O(m\log^{4}n)$ by using the more involved upper bound on the running time of $\textsc{Split}(\cdot)$ of

[TABLE]

where we use $|\textsc{Flatten}(X)|$ instead of $|X|$ to capture node splits. Then, we can bound the costs incurred by the first part of the bound by $O(m\log^{4}n)$; for the second part we also get a bound $O(m\log^{4}n)$ by using a telescoping sum argument on the size of the graph.

This concludes our proof of theorem 1.1.

9 Conclusion

In this article, we presented the first algorithm that maintains SCCs or SSR in decremental graphs in almost-linear expected total update time $\tilde{O}(m)$. Previously, the fastest algorithm for maintaining the SCCs or SSR achieved expected total update time $\tilde{O}(m\sqrt{n})$. Three main open questions arise in the context of our new algorithm:

• •

Can the complexity of the Single-Source Shortest-Path problem in decremental directed graphs be improved beyond total expected update time of $O(mn^{0.9+o(1)})$[HKN14a, HKN15] and can it even match the time complexity achieved by our algorithm?

• •

Does there exist a deterministic algorithm to maintain SCCs/SSR in a decremental graph beyond the $O(mn)$ total update time complexity?

• •

And finally, is there a algorithm that solves All-Pairs Reachability in fully-dynamic graphs with update time $\tilde{O}(m)$ and constant query time? Such an algorithm is already known for dense graphs[DI04] but is still unknown for graphs of sparsity $O(n^{2-\epsilon})$.

Acknowledgements

The second author of the paper would like to thank Jacob Evald for some helpful comments on organization and correctness.

Appendix A Fully-Dynamic Reachability from many sources

Theorem A.1**.**

Given a directed graph $G=(V,E)$, $S\subseteq V$, we can maintain a data structure that supports the operations:

• •

$\textsc{Insert}(u,E_{u})$: Adds $u$ to $V$ with edges $E_{u}$ where each edge in $E_{u}$ has an endpoint $u$.

• •

$\textsc{Delete}(u)$: Deletes $u$ from $V$.

• •

$\textsc{Query}(u,v)$: For $u\in S,v\in V$, returns whether $u$ has a path to $v$.

with expected amortized update time $O\left(\frac{|S|m\log^{4}{n}}{t}\right)$ and worst-case query time $O(t)$ for any $t\in[1,|S|]$. The bound holds against an oblivious adaptive adversary.

The algorithm to implement theorem A.1 can be described as follows: Initiate the data structure by constructing a decremental SSR structure as described in theorem 1.1 from each vertex $s\in S$. Initialize a set $I$ to be the empty set. Consider an update: if a deletion occurs, remove the edges incident to $u$ from each SSR structure, if an insertion occurs reinitialize the SSR structures at $u$ on the most recent graph $G$ and add $u$ to $I$. If $|I|\geq t$, reinitialize the entire data structure. On query for $(u,v)$, $u\in S$, check the SSR structure at $u$ whether it reaches $v$. Then check for each $r$ in $I$ whether $u$ reaches $r$ and $r$ reaches $v$. If any of these queries is successful, return that $u$ reaches $v$. Otherwise, return that $u$ cannot reach $v$. It is straight-forward to argue for correctness, and the running time is attained since the SSR structure require $O(|S|m\log^{4}{n})$ total time which can be amortized over $t$ updates. Each insertion additionally requires time $O(m\log^{4}{n})$ to (re)initialize the SSR structure at $u$. The query time is clearly $O(t)$ since we check reachability from and to each $r\in I$ in constant time. The theorem follows.

Appendix B Proof of Lemma 4.2

Proof.

We define the edge weight $w(u,v)$ of an edge $(u,v)$ to be $w(u,v)=1$ if $(u,v)\in E_{out}(S)$ and $w(u,v)=0$ otherwise. On invocation of $\textsc{InitGES}(r,G,S,\delta)$, we find a shortest-path tree $T$ to depth $\delta$ from $r$ in $G$ by running a weighted BFS. Each edge in $T$ is called a tree edge and each edge in $E\setminus T$ is a non-tree edge. We assign each vertex $v\in V$, a distance label $l(v)$ that is initialized to $\mathbf{dist}_{G}(r,v)$. We also maintain with each vertex a set $\textsc{LevelEdges}(v)$ that is initialized to $E_{in}(v)\setminus E_{out}(v)$ that is all edges in $E_{in}(v)$ after removing self-loops.

Now, consider an update of the form $\textsc{Delete}(u,v)$. If $(u,v)\not\in T$, then simply remove $(u,v)$ from $G$ and $\textsc{LevelEdges}(v)$ and return since the shortest-path tree $T$ did not change. If $(u,v)\in T$, we remove $(u,v)$ from $T$ and add $v$ to the min-queue $Q$ with value $l(v)$. We let $Q.\textsc{Min}()$ return the minimum value of any element in $Q$ and if $Q$ is empty, we let $Q.\textsc{Min}()=\infty$.

Whilst $Q.\textsc{Min}()<\delta+1$, we obtain the vertex $v=Q.\textsc{MinElement}()$. We then iteratively extract an edge $(y,v)$ from $\textsc{LevelEdges}(v)$ and check if $l(v)=l(y)+w(y,v)$. We stop if we found such an edge or if $\textsc{LevelEdges}(v)$ is empty. In the former case, we add $(y,v)$ to $T$ and remove $v$ from $Q$ since $T$ contains a new path of length $l(v)$ from $r$ to $v$. In the latter case, we know that $v$ cannot be reconnected in $T$ at the same distance. We therefore increase the level $l(v)$ by one. We then remove all edges $(v,z)\in T\cap E_{out}(v)$ from $T$ and add each $z$ to the queue $Q$ with its current level $l(z)$ as value. We also update the level of $v$ in $Q$ and if $l(v)\leq\delta$, we add all edges in $E_{in}(v)\setminus E_{out}(v)$ again to $\textsc{LevelEdges}(v)$. Once $Q.\textsc{Min}()\geq\delta+1$, we remove all remaining vertices from $Q$, set their distance level to $\infty$ and remove their incident edges from the graph $G$.

We observe that the queue $Q$ can be implemented with constant operation time using two lists since we never add a vertex with level larger than the current min-elements level plus one. Clearly, we check each edge $(y,v)$ in $\textsc{LevelEdges}(v)$ once for any level of $v$ and the condition $l(v)=l(y)+w(y,v)$ can be checked in constant time. The set $\textsc{LevelEdges}(v)$ partitions the edges and since removing edges in $E_{out}(v)\cap T$ if $l(v)$ increases can be amortized over edge checks for each disconnected vertex, we conclude that the total running time can be bound by $O(\sum_{v\in V}E_{in}(v)\delta)=O(m\delta)$.

Let us now argue for correctness of the algorithm. We observe that we only delete an edge $(y,v)$ from $T$ if $l(v)>l(y)+w(y,v)$ which happens if $l(y)$ is increased or $(y,v)$ is removed. After removing $(y,v)$, we take the first edge $(u,v)$ in $\textsc{LevelEdges}(v)$ that reconnects at the same level $l(v)$, i.e. if $l(v)=l(u)+w(u,v)$. Since the levels only increase over time and edge weights are fixed, we have that once $l(v)<l(u)+w(u,v)$, we cannot use $(u,v)$ to reconnect $v$ at the same level. Thus, if $\textsc{LevelEdges}(v)$ is empty, we certified that $v$ cannot be reconnected at level $l(v)$. We also observe that after the loop to fix a vertex in $Q$ finished, that for all edges in $T$, $l(v)=l(y)+w(y,v)$, because we remove an edge $(y,v)$ from $T$ if $l(y)$ increases. Now assume that when $Q.\textsc{Min}()=\infty$, that $T$ is always a tree of the vertices in $V$ that have level $<\infty$. It follows that $T$ is a shortest-path tree by the discussion above. To see that $T$ is indeed always a tree, observe that since $l(v)=l(y)+w(y,v)$ is always enforced on edges in $T$ and edge weights are non-negative, that we have for any two vertices $y,v\in V$ on a common cycle that $l(y)=l(v)$, implying that all edge weights are [math]. But since the edge weights of $E_{out}(S)$ are set to $1$, this implies that the cycle does not contain a vertex in $S$. But this contradicts the assumption that $S$ is a feedback vertex set.

Clearly, the operation $\textsc{Distance}(r,v)$ can be implemented by returning $l(v)$ in constant time. To obtain $\textsc{Distance}(v,r)$, we also construct our data structure on the reversed edge set of $G$ from $r$. To support $\textsc{Delete}(V^{\prime})$, we simply delete all incident edges from vertices in $V^{\prime}$ using $\textsc{Delete}(u,v)$ and remove all vertices $V^{\prime}$ from $V$. The operation $\textsc{GetUnreachableVertex}()$ can be implemented by keeping a list of all vertices with level $\infty$. ∎

Appendix C Proof of lemma 4.3

Proof.

Let us first describe how to implement the operations efficiently. We maintain additional pointers from each vertex $v\in V$ to the set $X\in\hat{V}$ with $v\in X$ and store with each vertex in $\hat{V}$ the number of vertices it represents. For $\textsc{SplitVertex}(X)$, we use any vertex in $x\in X$ to locate the vertex $Y\in\hat{V}$ with $X\subseteq Y$. If $X=Y$, we return. Otherwise, we compare the sizes of $X$ and $Y\setminus X$ and if $X$ has larger cardinality, we invoke $\textsc{SplitVertex}(Y\setminus X)$ and return. Let us therefore assume that $X$ is smaller than $Y\setminus X$. Then, we create a new vertex $X$ in $\hat{G}$ and move all edges in $E(X)$ from $E(Y)$. In particular, we also let the set $\textsc{LevelEdge}(X)=\textsc{LevelEdges}(Y)\cap E_{in}(X)$. We might also move the tree edge in $T$ depending on whether its endpoint maps to $X$ or $Y\setminus X$. Finally, we set $l(X)$ to $l(Y)$, remove the vertices in $X$ from $Y$, add the vertices in $\hat{V}$ that have no in-coming tree edge and do not contain $r$ to the queue $Q$ and invoke the fixing process described in the preceding lemma.

Clearly, the operation of moving the edges from $Y$ to $X$ takes time $O(E(X))$. Since each time an edge is moved, at least one of its endpoints underlying vertex set halves, we have that each edge is moved at most $O(\log X)$ times, where $X$ is the initial endpoint of larger cardinality. The second part of the upper bound of the lemma follows.

It is also straight-forward to see that after shifting the edges, the level of the vertices $X$ and $Y\setminus X$ is at least $l(Y)$ and that each edge in $E_{in}(Y)\setminus\textsc{LevelEdges}(Y)$ was already certified to not reconnect $X$ or $Y\setminus X$ to level $l(Y)$. Thus, the fixing process is simply part of the standard fixing process and can be included in the analysis presented for the last lemma.

Finally, we implement the operation $\textsc{Augment}(S^{\prime})$ by increasing the weight of each edge $E_{out}(S^{\prime}\setminus S)$ to 1. We then remove each tree edge $(s^{\prime},v)\in T\cap E_{out}(S^{\prime}\setminus S)$ from $T$; add each such $v$ to $Q$ and invoke the fixing procedure. It is straight-forward to show that the costs of this procedure are subsumed by the fixing procedure. ∎

Appendix D Proof of Lemma 6.1

Proof.

Let an out-layer $L_{out}(r,G,S,i)$ be defined to the vertices that are at distance exactly $i$ from $r$, i.e. $L_{out}(r,G,S,i)=\{v\in V|\mathbf{dist}_{G}(r,v,S)=i\}$. Thus, $L_{out}(r,G,S,i)\cap L_{out}(r,G,S,j)=\emptyset$ for $i\neq j$. We can compute $L_{out}(r,G,S,0)$ in time $O(E_{out}(L_{out}(r,G,S,0)))$ time, by initializing a queue $Q_{0}$ with element $r$ and then iteratively extracting a vertex $v$ from $Q_{0}$ and adding for each $(v,w)\in E_{out}(v)$ the vertex $w$ to $Q_{0}$ if $w\not\in S$ and if $w$ was not visited by the algorithm before. Initializing the queue $Q_{i+1}$ with the vertex set $L_{out}(r,G,S,i)\cap S$, we can use the same strategy for computing $L_{out}(r,G,S,i+1)$ in time $O(E_{out}(L_{out}(r,G,S,i))+E_{out}(L_{out}(r,G,S,i+1)))$. This corresponds to running a BFS on an edge set with weights in $\{0,1\}$. Upon finding the first $i$ such that

[TABLE]

is satisfied, and then output $S_{Sep}=L_{i}\cap S$ and $V_{Sep}=\cup_{j\leq i}L_{i}\setminus S_{Sep}$. Since we never extract the vertices in $S_{Sep}$ from the queue but only look at the out-going edges from $V_{Sep}$ we conclude that the procedure takes time $O(E_{out}(V_{Sep}))$.

To see, that there exists at least one layer $i$ satisfying this inequality, let layer $i^{\prime}$ be the minimal layer such that $\sum_{j<i^{\prime}}|L_{j}\cap S|>\frac{1}{2}|S|$. If $i^{\prime}\geq d/2$, then we claim there exists at least one layer $i\leq i^{\prime}$ with

[TABLE]

Otherwise, i.e. if $i^{\prime}\geq d/2$, there we claim that there exists at least one layer $i\leq i^{\prime}$ with

[TABLE]

Let us assume the former case. Consider for the sake of contradiction that we cannot find an appropriate $i\leq d/2$, i.e. $|L_{i}\cap S|>\frac{\sum_{j<i}|L_{j}\cap S|\log{n}}{d}$ for any $i$. Then, we have $\sum_{j<i}|L_{j}\cap S|>(1+\frac{2\log{n}}{d})^{i}$ since the set grows by factor $(1+\frac{2\log{n}}{d})$ with each iteration and it would be trivially satisfied if $L_{0}\cap S=\emptyset$. But then the final set must be of size greater than $n=e^{\log{n}}\leq(1+\frac{2\log{n}}{d})^{d/2}$, thus establishing a contradiction. The case where $i^{\prime}\geq d/2$ is symmetric.

For point 4. in our lemma, we observe that removing a layer implies that the layers visited can not reach the layers not visited yet. Assume for contradiction that this is not true, then we have an edge $(x,y)$ with $x\in V_{Sep}$ and $y\in V\setminus(S_{Sep}\cup V_{Sep})$ but then $y$ has to be in the same or the next layer that $x$ is contained. In the first case, $y\in V_{Sep}$ which contradicts that $y\in V\setminus(S_{Sep}\cup V_{Sep})$. In the latter case, Either $y\in V_{Sep}$ or $y$ is in the removed layer $S_{Sep}$ but both contradicts again that $y\in V\setminus(S_{Sep}\cup V_{Sep})$. ∎