An almost linear fully dynamic reachability algorithm

Dynamic graph algorithms Maintain some information

Dynamic Algorithms – Formal Definitions fully dynamic algorithm In a fully dynamic algorithm the graph can be updated using the following operations: InsertInsert – Add edges to the graph. DeleteDelete – Remove edges from the graph. partially dynamic algorithm A partially dynamic algorithm can be an incremental algorithm that supports only insertions or a decremental algorithm that supports only deletions. A query can reach at any moment and we should be ready to answer it correctly…

Dynamic graph algorithms Strong Connectivity

Reachability Fully dynamic reachability ,4 ? 1,2 ? Yes No

Our mission … Make the processing after each update faster than re-computing everything from scratch using a static algorithm. Answer queries as fast as we can.

Small Query Time: Maintain explicitly the transitive closure matrix. Query is done in O(1), each update may take  (n 2 ) time. Fully dynamic reachability

Small Query Time: Maintain explicitly the transitive closure matrix. Query is done in O(1), each update may take  (n 2 ) time. Fully dynamic reachability Small Update Time: A data structure which may have a non-constant query time but with smaller update time. Open problem: Is it possible to break the  (n 2 ) update barrier ? Yes: Updates in O(m+n log n) and queries in O(n)

Updatetime Querytime n2n2 n 1 n  nn  n2n2 n  mn  n n n m+n logn General graphs mn t DAG m t Fully dynamic reachability

An overview of the algorithm Our algorithm supports the following operations: Insert( E w ) – Insert the edges E w all touching w into the graph Delete( E’ ) – Delete all edges of E’ from the graph Query( u,v ) – Check whether there is a directed path from u to v G(V,E 0 ) Insert(E v ) G(V,E 0  E v ) Insert(E u ) G(V,E 0  E v  E u )

An overview of the algorithm G(V,E 0 ) Insert(E v ) G(V,E 0  E v ) Insert(E u ) G(V,E 0  E v  E u ) u v xy v x y Insert( E w ) : Create two trees to capture new paths Query(u,v ):  w, u  T in (w)  v  T out (w) Delete( E’ ): Delete E’ from all trees Our algorithm works as follows:

… Insert(E v 1 ) v1v1 Insert(E v 2 )Insert(E v 3 ) v2v2 v3v3 vlvl Insert(E v l ) An overview of the algorithm The main problem is to delete edges efficiently from this forest. In(v 1 ) Out(v 1 )

… v1v1 v2v2 v3v3 vlvl A simple solution for DAGs The total time required to maintain a decremental single source reachability (DSSR) tree in directed acyclic graph is only O(m) (Itliano ’88)  Each edge is scanned only once in each tree Insert( E w ) Query(u,v) Delete( E’ ) O ( n ) O ( 1 ) O ( m+n )

… v1v1 v2v2 v3v3 vlvl The problem with general graphs There is not any obvious way to generalize Itliano’s algorithm to general graphs. The best algorithm for DSSR requires O(mn) time. Insert( E w ) Query(u,v) Delete( E’ ) O ( n ) O ( 1 ) O ( mn ) O ( n ) O ( m+n log n )

… v1v1 v2v2 v3v3 vlvl Our Solution Our Solution Maintain the trees with respect to Strongly Connected Components Problem 1: We may have n trees each with different components! Problem 2: When a component is decomposed we have to update the edges such that an edge is never examine twice!

We solve Problem 1 using fully dynamic strong connectivity algorithm with update time of O(m  (m,n)). v1v1 In(v 1 ) Out(v 1 ) v2v2 In(v 2 ) Out(v 2 ) v4v4 In(v 4 ) Out(v 4 ) v5v5 In(v 5 ) Out(v 5 ) v3v3 In(v 3 ) Out(v 3 ) Fully dynamic strong connectivity with “persistency” Detect and report on decompositions Updating edge lists Updating edge lists

Supported operations: G 0 =(V,E 0 ) Insert(E’) Fully dynamic strong connectivity G 0 =(V,E 0 ) G 1 =(V,E 0  E’) G 1 =(V,E 1 ) Insert(E’’) G 1 =(V,E 1 ) G 2 =(V,E 1  E’’) G 2 =(V,E 2 ) Delete( E’ ) – Delete the set E’ from all versions. Query( u,v,i ) – Are u and v in the same component in G i Insert( E’ ) – Create a new version and add E’ to it. Note that these operations create a graph sequence G 0 (V,E 0 ), G 1 (V,E 1 ), …, G t (V,E t ) where E 0  E 1 …  E t. This containment is kept during all the update operations! O ( m  ( m,n )) O ( 1 )

Fully dynamic strong connectivity The components of all the graphs in the sequence are arranged in a hierarchy and can be represented as a forest of size O ( n ) G0G0 G1G1 G2G2 G3G3 The components:The forest: G0G0 G1G1 G2G2 G3G u v Query(u,v,1)  Version( LCA(u,v) )  1 Query(u,v,2)  Version( LCA(u,v) )  2 Version tag

H i+1 HiHi A new partitioning of the edges E 1,…, E t Definition 1: A partitioning of the graph sequence edges H i = { (u,v)  E i | Query(u,v,i)  (  Query(u,v,i-1)  (u,v)  E i-1 ) } H t+1 = E t \  H i i=1 t G i-1 =(V,E i-1 ) G i =(V,E i ) G i+1 =(V,E i+1 ) H i  H j = ø, E t =  H i i=1 t+1

G0G0 G1G1 G2G2 G3G3 FindScc(H 1,1)FindScc(H 2,2) Shift(H 1,H 2 ) Shift(H 2,H 3 ) FindScc(H 3,3) Shift(H 3,H 4 ) Cost Analysis: Note that an edge enters and leave H i just once Moving edges – Paid by the creation of the version they enter. Free Fixed edges – Paid by the current delete operation O(m) Processing a deletion H i edges Before…After !

G0G0 G1G1 G2G2 G3G3 The component forest

We solve Problem 1 using fully dynamic strong connectivity algorithm with update time of O(m  (m,n)). v1v1 In(v 1 ) Out(v 1 ) v2v2 In(v 2 ) Out(v 2 ) v4v4 In(v 4 ) Out(v 4 ) v5v5 In(v 5 ) Out(v 5 ) v3v3 In(v 3 ) Out(v 3 ) Fully dynamic strong connectivity with “persistency” Detect and report on decompositions Updating edge lists Updating edge lists

Every edge is examined only once! (If the graph is DAG) Total complexity is O(m). For general graphs use the graph components as vertices Decremental reachability tree T in(v ) T out(v) v v

Decremental reachability tree When a decomposition is reported (by the strong connectivity algorithm), we need to: Create edge list for the new components Connect the new components to the tree O(n log n) O(m) Total time

The list in[v] contains only uninspected incoming edges. The list out[v] contains all the outgoing edge. A vertex v is active if in[v] is not empty Decremental reachability tree Data structures Every component maintains a list of its active vertices v in[v] component Tree invariant: The first edge of the first vertex in the component active vertices list is the edge that connects the component to the tree. If the component is not connected then its active vertices list is empty

component - An active vertex- An uninspected incoming edge - A tree edge - A none active vertex Deletions of non tree edges - A deleted edge Deletions of a tree edge – we search for an edge (u,v) such that the component that contains u satisfies the tree invariant Decremental reachability tree Edge deletion

Decremental reachability tree Disconnecting a component component - An active vertex- An uninspected incoming edge - A tree edge - A none active vertex - A deleted edge Disconnecting a component. How do we find the components vertices ?

G0G0 G1G1 G2G2 G3G3 The component forest component u Out[u]

We generalized the decremented reachability tree to general graphs by using the components of the graph. Each edge in the connection process is still scanned only once. We have to deal with decomposition. We like to create active lists for new components in efficient way. Decremental reachability tree

Decremental reachability tree Decomposition component Component 2 Size = 5 Component 1 Size =2 The largest components among the new components inherits the list of the decomposed component. Using the component forest each vertex from a small component is removed from the list and added to its new component list. The component decomposed to two new components one of size 5 and one of size 2.

Decremental reachability tree Analysis Component 2 Size = 5 Component 1 Size =2 Scanning the component vertices can be done in time proportional to the component size. We only scan ‘small’ components. Let’s analyze the total cost: If a vertex is moved from one active list to another, the size of the component containing it must have decreased by a factor of at least 2.

Summing up The total connection cost is O(m) The total decomposition cost is O(n log n) For each tree Each update costs O(m + n log n)

Open problems Reduce the query time to m/n ? Reduce the update time to O(m+n) ? Design other fully dynamic algorithm for a graph sequence ? A single decremental reachability tree in general graph in o(mn) ?