Sensitive Distance and Reachability Oracles for Large Batch Updates

TL;DR

This paper introduces a novel sensitive distance oracle for large directed graphs that efficiently handles multiple batch updates, improving upon previous algorithms by leveraging polynomial matrix kernel basis decomposition.

Contribution

It presents the first sensitive distance oracle capable of handling f ≥ log n updates with improved preprocessing, update, and query times, utilizing advanced polynomial matrix techniques.

Findings

Handles f ≥ log n updates efficiently

Uses kernel basis decomposition of polynomial matrices

Achieves truly subquadratic update and query times

Abstract

In the sensitive distance oracle problem, there are three phases. We first preprocess a given directed graph $G$ with $n$ nodes and integer weights from $[-W,W]$. Second, given a single batch of $f$ edge insertions and deletions, we update the data structure. Third, given a query pair of nodes $(u,v)$, return the distance from $u$ to $v$. In the easier problem called sensitive reachability oracle problem, we only ask if there exists a directed path from $u$ to $v$. Our first result is a sensitive distance oracle with $\tilde{O}(Wn^{\omega+(3-\omega)\mu})$ preprocessing time, $\tilde{O}(Wn^{2-\mu}f^{2}+Wnf^{\omega})$ update time, and $\tilde{O}(Wn^{2-\mu}f+Wnf^{2})$ query time where the parameter $\mu\in[0,1]$ can be chosen. The data-structure requires $O(Wn^{2+\mu} \log n)$ bits of memory. This is the first algorithm that can handle $f\ge\log n$ updates. Previous results (e.g. [Demetrescu et al. SICOMP'08; Bernstein and Karger SODA'08 and FOCS'09; Duan and Pettie SODA'09; Grandoni and Williams FOCS'12]) can handle at most 2 updates. When $3\le f\le\log n$, the only non-trivial algorithm was by [Weimann and Yuster FOCS'10]. When $W=\tilde{O}(1)$, our algorithm simultaneously improves their preprocessing time, update time, and query time. In particular, when $f=\omega(1)$, their update and query time is $\Omega(n^{2-o(1)})$, while our update and query time are truly subquadratic in $n$, i.e., ours is faster by a polynomial factor of $n$. To highlight the technique, ours is the first graph algorithm that exploits the kernel basis decomposition of polynomial matrices by [Jeannerod and Villard J.Comp'05; Zhou, Labahn and Storjohann J.Comp'15] developed in the symbolic computation community. [...]

Equations

$$\mathrm{adj}(A+U{V}^{\top })=\frac{\mathrm{adj}(A)\det (M)-\left(\mathrm{adj}(A)U\right)\mathrm{adj}(M)\left(V^{\top }\mathrm{adj}(A)\right)}{\det (A{)}^f}.$$

$$\mathrm{adj}(A{)}_{i,j}\frac{\det (M)}{\det (A{)}^f}-\frac{\stackrel{:=\vec{u}}{\overbrace{\left({\vec{e}}_i^{\top }\mathrm{adj}(A)U\right)}}\mathrm{adj}(\stackrel{=:M}{\overbrace{\mathbb{I}\cdot \det (A)+V^{\top }\mathrm{adj}(A)U}})\stackrel{:=\vec{v}}{\overbrace{\left(V^{\top }\mathrm{adj}(A){\vec{e}}_j\right)}}}{\det (A{)}^f}$$

$$\displaystyle\underbrace{\left(\begin{array}[]{cccc}d&d&d&d\\ d&d&d&d\\ \hline\cr d&d&d&d\\ d&d&d&d\end{array}\right)}_{B}\underbrace{\left(\begin{array}[]{cc|cc}d&d&d&d\\ d&d&d&d\\ d&d&d&d\\ d&d&d&d\end{array}\right)}_{A}=\left(\begin{array}[]{cc|cc}2d&2d&&\\ 2d&2d&&\\ \hline\cr&&2d&2d\\ &&2d&2d\end{array}\right).$$

$$\displaystyle\underbrace{\left(\begin{array}[]{cccc}d&d&d&d\\ d&d&d&d\\ \hline\cr d&d&d&d\\ d&d&d&d\end{array}\right)}_{B}\underbrace{\left(\begin{array}[]{cc|cc}d&d&d&d\\ d&d&d&d\\ d&d&d&d\\ d&d&d&d\end{array}\right)}_{A_{1}}\underbrace{\left(\begin{array}[]{cc|cc}2d&2d&&\\ 2d&2d&&\\ \hline\cr&&2d&2d\\ &&2d&2d\end{array}\right)}_{A_{2}}\cdots=\underbrace{\left(\begin{array}[]{cccc}\cline{1-1}\cr\vrule\lx@intercol\hfil dn\hfil\lx@intercol\vrule\lx@intercol&&&\\ \cline{1-2}\cr&\vrule\lx@intercol\hfil dn\hfil\lx@intercol\vrule\lx@intercol&&\\ \cline{2-2}\cr&&\ddots&\\ \cline{4-4}\cr&&&\vrule\lx@intercol\hfil dn\hfil\lx@intercol\vrule\lx@intercol\\ \cline{4-4}\cr\end{array}\right)}_{D}$$

$${\mathrm{cdeg}}_{\vec{s}}(M{)}_j:=\underset{i=1,...,n}{\max }{\vec{s}}_i+\mathrm{deg}(M_{i,j})\text{ for }j=1,...,m$$

$$\sum _{j=1}^m\sum _{i=1}^n\tilde{O}\left(\mathrm{deg}({\vec{v}}_i)+\mathrm{deg}(M_{i,j})\right)\le \tilde{O}\left(\sum _{j=1}^m\sum _{i=1}^n{\vec{s}}_i+\mathrm{deg}(M_{i,j})\right)\le \tilde{O}\left(n\sum _{j=1}^m{\mathrm{cdeg}}_{\vec{s}}(M{)}_j\right).$$

$$A_{i+1}=\mathrm{diag}(A_{i+1}^{(1)},...,A_{i+1}^{(2^i)}).$$

$$A_{i+1}^{(k)}=[N_{i+1,l}^{(k)},N_{i+1,r}^{(k)}].$$

$$M_i=[M_i^{(1)},...,M_i^{(2^i)}]$$

$$M_{i+1}^{(2k-1)}=M_i^{(k)}{N}_{i+1,l}^{(k)}\text{ and }{M}_{i+1}^{(2k)}=M_i^{(k)}{N}_{i+1,r}^{(k)}$$

$$\sum _{i=1}^{\lceil \log n^{\mu }\rceil }\tilde{O}(n(n/2^i{)}^{\omega -1}(1+d{2}^i))\cdot 2^i=\tilde{O}(d{n}^{\omega (1-\mu )+3\mu })$$

$$M_{\lceil \log n\rceil }^{(k)}=M_{\lceil \log n^{\mu }\rceil }\prod _{t=1}^{\lceil \log n\rceil -\lceil \log n^{\mu }\rceil }{N}_{\lceil \log n^{\mu }\rceil +t,c_t}^{(k_t)}$$

$${\vec{e}}_i^{\top }{M}_{\lceil \log n^{\mu }\rceil }\prod _{t=1}^r{N}_{\lceil \log n^{\mu }\rceil +t,c_t}^{(k_t)}={\vec{e}}_i^{\top }{M}_{\lceil \log n^{\mu }\rceil +r}^{(k_r)}$$

$$\tilde{O}(d{n}^2/2^{\lceil \log n^{\mu }\rceil +r})$$

$$\mathrm{adj}(A+U{V}^{\top })=\frac{\mathrm{adj}(A)\det (M)-\left(\mathrm{adj}(A)U\right)\mathrm{adj}(M)\left(V^{\top }\mathrm{adj}(A)\right)}{\det (A{)}^f}$$

$$\frac{\mathrm{adj}(A{)}_{i,j}\det (M)-\left({\vec{e}}_i\mathrm{adj}(A)U\right)\mathrm{adj}(M)\left(V^{\top }\mathrm{adj}(A){\vec{e}}_j\right)}{\det (A{)}^f}.$$

$$\frac{\mathrm{adj}(A{)}_{i,j}\det (M)-\mathrm{adj}(A{)}_{i,[n]}U\mathrm{adj}(M)V^{\top }\mathrm{adj}(A{)}_{[n],j}}{\det (A{)}^f}$$

$$(A+U{V}^{\top }{)}^{-1}=A^{-1}-A^{-1}U(\mathbb{I}+V^{\top }{A}^{-1}U{)}^{-1}{V}^{\top }{A}^{-1}$$

$$\det (A+U{V}^{\top })=\det (A)\cdot \det (\mathbb{I}+A^{-1}U{V}^{\top })=\det (A)\cdot \det (\mathbb{I}+V^{\top }{A}^{-1}U).$$

$$\det (M)$$

$$=\det (A{)}^f\cdot \det (\mathbb{I}+V^{\top }{A}^{-1}U)$$

$$=\det (A+U{V}^{\top })\cdot \det (A{)}^{f-1}$$

$$\frac{\left(\mathrm{adj}(A)U\right)\mathrm{adj}(M)\left(V^{\top }\mathrm{adj}(A)\right)}{\det (A{)}^f}$$

$$=$$

Full text

Our first result is a sensitive distance oracle with $\tilde{O}(Wn^{\omega+(3-\omega)\mu})$ preprocessing time, $\tilde{O}(Wn^{2-\mu}f^{2}+Wnf^{\omega})$ update time, and $\tilde{O}(Wn^{2-\mu}f+Wnf^{2})$ query time where the parameter $\mu\in[0,1]$ can be chosen. The data-structure requires $O(Wn^{2+\mu}\log n)$ bits of memory. This is the first algorithm that can handle $f\geq\log n$ updates. Previous results (e.g. [Demetrescu et al. SICOMP’08; Bernstein and Karger SODA’08 and FOCS’09; Duan and Pettie SODA’09; Grandoni and Williams FOCS’12]) can handle at most 2 updates. When $3\leq f\leq\log n$, the only non-trivial algorithm was by [Weimann and Yuster FOCS’10]. When $W=\tilde{O}(1)$, our algorithm simultaneously improves their preprocessing time, update time, and query time. In particular, when $f=\omega(1)$, their update and query time is $\Omega(n^{2-o(1)})$, while our update and query time are *truly subquadratic *in $n$, i.e., ours is faster by a polynomial factor of $n$. To highlight the technique, ours is the first graph algorithm that exploits the kernel basis decomposition of polynomial matrices by [Jeannerod and Villard J.Comp’05; Zhou, Labahn and Storjohann J.Comp’15] developed in the symbolic computation community.

As an easy observation from our technique, we obtain the first sensitive reachability oracle can handle $f\geq\log n$ updates. Our algorithm has $O(n^{\omega})$ preprocessing time, $O(f^{\omega})$ update time, and $O(f^{2})$ query time. This data-structure requires $O(n^{2}\log n)$ bits of memory. Efficient sensitive reachability oracles were asked in [Chechik, Cohen, Fiat, and Kaplan SODA’17]. Our algorithm can handle any constant number of updates in constant time. Previous algorithms with constant update and query time can handle only at most $f\leq 2$ updates. Otherwise, there are non-trivial results for $f\leq\log n$, though, with query time $\Omega(n)$ by adapting [Baswana, Choudhary and Roditty STOC’16].

1 Introduction

In the sensitive distance oracle problem111In literature this setting is also referred to as distance sensitivity oracle or emergency algorithm., there are three phases. First, we preprocess a given directed graph $G$ with $n$ nodes, $m$ edges, and integer weights from $[-W,W]$. Second, given a single batch of $f$ edge insertions and deletions, we update the data structure. Third, given a pair of nodes $(u,v)$, return the distance from $u$ to $v$. The time taken in each phase is called preprocessing time, update time, and query time respectively. In an easier problem called sensitive reachability oracle problem,* *the setting is the same except that we only ask if there exists a directed path from $u$ to $v$.

Although both problems are well-studied (as will be discussed below), all existing non-trivial algorithms only handle $f\leq\log n$ updates. In contrast, in the analogous problems in undirected graphs, algorithms that handle updates of any size are known. For example, there are sensitive connectivity oracles [PT07, DP10, DP17, HN16] (i.e. reachability oracles in which is undirected graphs) with $\operatorname{poly}(n)$ preprocessing time and $\operatorname{poly}(f,\log n)$ update and query time for *every *$f$. For sensitive distance oracles in undirected graphs (studied in [BK13, CLPR12, CCFK17]), Chechik, Langberg, Peleg, and Roditty [CLPR12] show that this is possible as well if approximate distance is allowed. It is interesting whether there is any inherent barrier for $f\geq\log n$ in directed graphs. In this paper, we show that there is no such barrier.

Sensitive distance oracle.

All previous works on this problem handle edge deletions only222Node deletions can be handled as well using a simple reduction.. The first result is in the case when $f=1$ by Demetrescu et al. [DTCR08]333The result was published in 2008, but previously announced at SODA and ISAAC 2002. since 2002. Their algorithm has $O(mn^{1.5})$ preprocessing time and $O(1)$ update and query time. This preprocessing time is improved by Bernstein and Karger to $\tilde{O}(n^{2}\sqrt{m})$ [BK08] and finally to $\tilde{O}(mn)$ [BK09]. The $\tilde{O}(mn)$ bound is optimal up to a sub-polynomial factor unless there is a truly subcubic algorithm for the all-pairs shortest path problem. Later, Grandoni and Williams [GW12] showed a new trade-off. For example, they can obtain $O(Wn^{2.88})$ preprocessing time and $O(n^{0.7})$ update and query time.

It was stated as an open question in [DTCR08, BK08, BK09] whether there is a non-trivial algorithm for handling more than one deletion. Duan and Pettie [DP09] give an affirmative answer for $f=2$. Their algorithm has $\mbox{poly}(n)$ preprocessing time and $\tilde{O}(1)$ update and query time. They however stated that “it is practically infeasible” to extend their algorithm to handle three deletions. Weimann and Yuster [WY13] later showed an algorithm for handling up to $f\leq\log n/\log\log n$ deletions. For any parameter $\mu\in[0,1]$, their algorithm has $\tilde{O}(Wn^{\omega+\mu})$ preprocessing time and $\tilde{O}(n^{2-\mu/f})$ update and query time. This algorithm remains the only non-trivial algorithm when $f\geq 3$.

To summarize, no previous algorithm can handle $f>\log n/\log\log n$ updates. Another drawback of all previous algorithms is that they inherently cannot handle changes of edge weights.444One restricted and inefficient approach for handling weight increases via edge deletions is as follows. For each edge $e$, we need to know all possible weights for $e$, say $w_{1}\leq\dots\leq w_{k}$. Then, we add multi-edges $e_{1},\dots,e_{k}$ with the same endpoints as $e$, and the weight of $e_{i}$ is $w_{i}$. To increase the weight from $w_{1}$ to $w_{j}$, we delete all edges $e_{1},\dots,e_{j-1}$. However, all previous algorithms handle only small number deletions. In the setting where we allow changes of edge weights, it is quite natural to ask for algorithms that handle somewhat large batches of updates.555For example, in a road network, there usually are not too many completely blocked road sections (i.e. deleted edges), but during rush-hour there can be many roads with increased congestion (i.e. edges with increased weight).

In this work, we show the first sensitive distance oracle that can handle any number of updates. Moreover, we allow both edge insertions, deletions, and changes of weights. Ours is the fastest oracle for handling $f\geq 3$ updates when $W=\tilde{O}(1)$:

Theorem 1.1**.**

For any parameter $\mu\in[0,1]$, there is a Monte Carlo data structure that works in three phases as follows:

Preprocess a directed graph with $n$ nodes and integer weights from $[-W,W]$ in $\tilde{O}(Wn^{\omega+(3-\omega)\mu})$ time and store $O(Wn^{2+\mu}\log n)$ bits. 2. 2.

Given updates to any set of $f$ edges, update the data structure in $\tilde{O}(Wn^{2-\mu}f^{2}+Wnf^{\omega})$ time and store additional $O(Wnf^{2}\log n)$ bits. 3. 3.

Given a pair of nodes $(u,v)$, return the distance from $u$ to $v$ or report that there is a negative cycle in $\tilde{O}(Wn^{2-\mu}f+Wnf^{2})$ time.

The algorithm is Monte Carlo randomized and is correct with high probability, i.e. the algorithm may return a larger distance with probability at most $1/n^{c}$ for any constant $c$. We note that, any algorithm that can handle edge deletions can also handle node deletions by using a standard reduction.

Let us compare this result to the algorithm by Weimann and Yuster [WY13]. First, instead of edge deletions only, we allow both edge insertions, deletions, and changes of weight. The second point is efficiency. For any $\mu\in[0,1]$, we improve the preprocessing time from $\tilde{O}(Wn^{\omega+\mu})$ to $\tilde{O}(Wn^{\omega+(3-\omega)\mu})$. Both of our update and query time are bounded above by $\tilde{O}(Wn^{2-\mu}f^{\omega})$. When $W=\tilde{O}(1)$, this improves their bound of $\tilde{O}(n^{2-\mu/f})$ for any $f\geq 2$ by a polynomial factor. In particular, when $\mu>0$ and $f=\omega(1)$, their bound is $\Omega(n^{2-o(1)})$, while ours is* truly subquadratic *in $n$. The last and most conceptually important point is that we remove the constraint that $f\leq\log n/\log\log n$. While their technique is inherently for small $f$, our approach is different and can handle any number of updates.

To highlight our technique, this is the first graph algorithm that exploits the powerful kernel basis decomposition of polynomial matrices by Jeannerod and Villard [JV05] and Zhou, Labahn and Storjohann [ZLS15] from the symbolic computation community. We explain the overview of our algebraic techniques in Section 1.1. We then compare our techniques to the previous related works in Section 1.2.

Sensitive reachability oracle.

It was asked as an open problem by Chechik et al. [CCFK17] whether there is a much more efficient data structure if the query is only about reachability between nodes and not distance. As an easy observation from our technique, we give a strong affirmative answer to this question:

Theorem 1.2**.**

There is a Monte Carlo sensitive reachability oracle that preprocess an $n$-node graph in $O(n^{\omega})$ time and stores $O(n^{2}\log n)$ bits. Then, given a set of $f$ edge insertions/deletions and node deletions, update the data structure in $O(f^{\omega})$ time and store additional $O(f^{2}\log n)$ bits. Then, given a query $(u,v)$, return if there is directed path from $u$ to $v$ in $O(f^{2})$ time.

Previously, there are only algorithms that handle $f=1$ edge deletions based on dominator trees [LT79, BGK*+*08, GT12, FGMT14] or $f\leq 2$ edge deletions [Cho16]. These algorithms have $O(1)$ update and query time. Another approach based on fault-tolerant subgraphs666The goal is to find sparse subgraphs preserving reachability information of the original graph even after some edges are deleted. gives algorithms with query time at least $\Omega(n)$ [BCR15, BCR16] and becomes trivial when $f\geq\log n$. When $f=O(1)$, our algorithm has $O(1)$ update and query time like the algorithms using the first approach. Moreover, ours is the first which handles updates of any size.

It was shown in [AW14, HLNW17] that, assuming the Boolean Matrix Multiplication conjecture, there cannot be any constant $\epsilon>0$ and a “combinatorial” algorithm for Theorem 1.2 which has $O(n^{3-\epsilon})$ preprocessing time, and can handle $2$ edge insertions using $O(n^{2-\epsilon})$ update and query time. Our result does not refute the conjecture as we use fast matrix multiplication.

1.1 Technical overview

Set the stage.

The first step of all our results is to reduce the problem on graphs to algebraic problems using the following known reduction (see Lemma 2.1 for a more detailed statement). Let $G$ be an $n$-node graph with integer weights from $[-W,W]$. Let $\mathbb{F}$ be a finite field of size at least $n^{3}$. We construct a polynomial matrix $A\in\mathbb{F}[X]^{n\times n}$ such that $A_{i,j}=a_{i,j}X^{W+c_{i,j}}$ where $c_{i,j}$ is the weight of edge $(i,j)$ and $a_{i,j}$ is a random element from $\mathbb{F}$. Then, with high probability, we can read off the distance from $i$ to $j$ in $G$ from the $(i,j)$ entry of the adjoint matrix $\operatorname{adj}(A)$ of $A$, for all pairs $(i,j)$. That is, it suffices to build a data structure on the above polynomial matrix $A$ that can handle updates and can return an entry of its adjoint $\operatorname{adj}(A)$. Updating $f$ edges in $G$ corresponds to adding $A$ with $C$ where $C\in\mathbb{F}[X]^{n\times n}$ has $f$ non-zero entries. Further we have with high probability that $\det(A)\neq 0$, so it is enough to focus on algorithms that work on non-singular matrices. From now, we let $\mathbb{F}$ be an arbitrary field and we use the number of field operations as complexity measure.

Warm up: slow preprocessing.

To illustrate the basic idea how to maintain the adjoint, we will prove the following:

Lemma 1.3**.**

Let $A\in\mathbb{F}[X]^{n\times n}$ be a polynomial matrix of degree $d$ with $\det(A)\neq 0$, then there exists an algorithm that preproceses $A$ in $\tilde{O}(dn^{\omega+1})$ operations. Then, for any $C\in\mathbb{F}[X]^{n\times n}$ with $f$ non-zero entries of degree at most $d$, we can query any entry of $\operatorname{adj}(A+C)$ in $\tilde{O}(dnf^{\omega+1})$ operations, if $\det(A+C)\neq 0$.

If $d=0$, then the preprocessing and query time are $O(n^{\omega})$ and $O(f^{\omega})$ respectively.

This immediately implies a weaker statement of Theorem 1.1 when $\mu=1$ and the edge updates and the pair to be queried are given at the same time. We remark that, from the simple proof below, this already gives us the first non-trivial sensitive distance oracle which can handle any number of $f$ updates. Previous techniques inherently require $f\leq\log n/\log\log n$. As the reachability problem can be considered a shortest path problem, where every edge has weight zero, we also obtain a result similar to Theorem 1.2 from Lemma 1.3 for $d=0$.

Corollary 1.4**.**

Let $G$ be some directed graph with integer weights in $[-W,W]$, then there exists an algorithm that preprocess $G$ in $\tilde{O}(Wn^{\omega+1})$ time. Then, given $f$ edge updates to $G$ and a query pair $(u,v)$, it returns the distance from $u$ to $v$ in the updated graph in $\tilde{O}(Wnf^{\omega+1})$ time.

Corollary 1.5**.**

Let $G$ be some directed graph, then there exists an algorithm that preprocess $G$ in $\tilde{O}(n^{\omega})$ time. Then, given $f$ edge updates to $G$ and a query pair $(u,v)$, it returns the reachability from $u$ to $v$ in the updated graph in $\tilde{O}(f^{\omega})$ time.

To prove Lemma 1.3, we use the key equality below based on the Sherman-Morrison-Woodbury formula. The proof is deferred to Appendix A.

Lemma 1.6**.**

Let $A$ be an $n\times n$ matrix and $U,V$ be $n\times f$ matrices, such that $\det(A),\det(A+UV^{\top})\neq 0$. Define the $f\times f$ matrix $M:=\mathbb{I}\cdot\det(A)+V^{\top}\operatorname{adj}(A)U$. Then, we have

[TABLE]

The algorithm for Lemma 1.3 is as follows: We preprocess $A$ by computing $\det(A)$ and $\operatorname{adj}(A)$. As $\det(A)$ and $\operatorname{adj}(A)$ have degree at most $dn$, this takes $\tilde{O}(dn\times n^{\omega})=\tilde{O}(dn^{\omega+1})$ field operations [BCS97, Chapter 1] (or just $O(n^{\omega})$ if $d=0$). Next, we write $C=UV^{\top}$ where $U,V\in\mathbb{F}[X]^{n\times f}$ have only one non-zero entry of degree $\leq d$ per column. To compute $\operatorname{adj}(A+UV^{\top})_{i,j}$, we simply compute

[TABLE]

where $\vec{e}_{i}$ is the $i$-th standard unit vector. This computation can be separated into the following steps:

Compute $\operatorname{adj}(A)_{i,j}$, $\vec{u}:=\vec{e}_{i}^{\top}\operatorname{adj}(A)U$ and $\vec{v}:=V^{\top}\operatorname{adj}(A)\vec{e}_{j}$. Note that because of the sparsity of $U$ and $V$, $\vec{u}$ and $\vec{v}$ are essentially just vectors of $f$ elements of $\operatorname{adj}(A)$, each multiplied by a non-zero element of $U$ and $V$. Thus this step can be summarized as obtaining $O(f)$ elements of $\operatorname{adj}(A)$. 2. 2.

Compute $V^{\top}\operatorname{adj}(A)U$ which are likewise just $f^{2}$ elements of $\operatorname{adj}(A)$, each multiplied by a non-zero element of $U$ and $V$. So this time we have to obtain $O(f^{2})$ entries of $\operatorname{adj}(A)$. 3. 3.

Compute the adjoint $\operatorname{adj}(M)$ and determinant $\det(M)$. 4. 4.

Compute $\det(A)^{f}$. 5. 5.

Compute $\operatorname{adj}(A)_{i,j}\frac{\det(M)}{\det(A)^{f}}$ and vector-matrix-vector product $\vec{u}\operatorname{adj}(M)\vec{v}$ and divide it by $\det(A)^{f}$. Then subtract the two values and we obtain $\operatorname{adj}(A+UV^{\top})_{i,j}$.

Steps 1 and 2 require only $\tilde{O}(dnf^{2})$ field operations as we just have to read $O(f^{2})$ entries of $\operatorname{adj}(A)$ and multiply them by some small $d$-degree polynomials from $U$ and $V$. In step 3 we have to compute the adjoint and determinant of a $f\times f$ matrix of degree $dn$. This takes $\tilde{O}(dnf^{\omega+1})$ operations. Step 4 computes $\det(A)^{f}$ where $\det(A)$ is of degree $dn$, which takes $\tilde{O}(dnf)$ operations. Step 5 takes $\tilde{O}(dnf^{3})$ because $\operatorname{adj}(M)$ is a degree $dnf$ matrix of dimension $f\times f$. The total number of operations is thus $\tilde{O}(dnf^{\omega+1})$. The algorithm does not require the upper bound of $f\leq\log n/\log\log n$ as in [WY13].

For the reachability case, when $d=0$, all entries of the matrices and vectors are just field elements, so steps 1 and 2 need only $O(f^{2})$ operations. Step 3 needs $O(f^{\omega})$ operations, while 4 can be done in just $O(\log f)$ operations, and the last step 5 requires only $O(f^{2})$ operations.

Key technique: kernel basis decomposition.

The biggest bottleneck in Lemma 1.3 is explicitly computing $\operatorname{adj}(A)$ and $\operatorname{adj}(M)$. For $\operatorname{adj}(A)$ it already takes $\Omega(dn^{3})$ operations in the preprocessing step just to write down the $n^{2}$ entries of $\operatorname{adj}(A)$ each of which has degree upto $dn$. What we need is an adjoint oracle, i.e. a data structure on $A$ with fast preprocessing that can still quickly answer queries about entries of $\operatorname{adj}(A)$.

By replacing this data structure in the five steps of the proof of Lemma 1.3, this immediately gives distance oracles in the sensitive setting which dominate previous results when $W=\tilde{O}(1)$. (This is how we obtain Theorem 1.1).

The key contribution of this paper is to realize that the technique in [JV05, ZLS15] actually gives the desired adjoint oracle. This technique, which we call the kernel basis decomposition, is introduced by Jeannerod and Villard [JV05] and then improved by Zhou, Labahn, and Storjohann [ZLS15]. It is originally used for inverting a polynomial matrix of degree $d$ in $\tilde{O}(dn^{3})$ operations. However, the following adjoint oracle is implicit in Section 5.3 of [ZLS15]777Section 5.3 of [ZLS15] discusses computing $v^{\top}A^{-1}$, where the result is given by a vector $u$ with entries of the form $p/q$ where $p,q$ are polynomials of degree at most $O(dn)$. Since $\det(A)$ can be computed in $\tilde{O}(dn^{\omega})$ [Sto03, LNZ17] and $\operatorname{adj}(A)=A^{-1}\det(A)$, we get Theorem 1.7. :

Theorem 1.7**.**

There is a data-structure that preprocesses $B\in\mathbb{F}[X]^{n\times n}$ where $\det(B)\neq 0$ and $\deg(B)\leq d$ in $\tilde{O}(dn^{\omega})$ operations. Then, given any $\vec{v}\in\mathbb{F}[X]^{n}$ where $\deg(\vec{v})\leq d$, it can compute $\vec{v}^{\top}\operatorname{adj}(B)$ in $\tilde{O}(dn^{2})$ operations.

However, to get $o(Wn^{2})$ query time as in Theorem 1.1, Theorem 1.7 is not enough. Fortunately, by modifying the technique from [ZLS15] in a white-box manner (see Section 3 for details), we can obtain the following trade-off which is essential for Theorem 1.1. The result essentially interpolates the exponents of the following two extremes: $\tilde{O}(dn^{3})$ preprocessing and $O(dn)$ query time when computing the adjoint explicitly, or $\tilde{O}(dn^{\omega})$ preprocessing and $O(dn^{2})$ query time when using Theorem 1.7.

Theorem 1.8**.**

For any $0\leq\mu\leq 1$, there is a data-structure that preprocesses $B\in\mathbb{F}[X]^{n\times n}$ where $\det(B)\neq 0$ and $\deg(B)\leq d$ in $O(dn^{\omega+(3-\omega)\mu})$ operations. Then, given any pair $(i,j)$, it returns $\operatorname{adj}(B)_{i,j}$ in $O(dn^{2-\mu})$ operations.

To see the main idea, we give a slightly oversimplified description of the oracle in Theorem 1.7 which allows us to show how to modify the technique to obtain Theorem 1.8. Below, we write a number for each matrix entry to indicate a bound on the degree, e.g. when we write $(4,4,4)^{\top}$ then we mean a 3-dimensional vector with entries of degree at most 4.

Suppose that we are now working with an $n\times n$ matrix $B$ of degree $d$. Then [ZLS15] (and [JV05] for a special type of matrices) is able to find a full-rank matrix $A$ of degree $d$ in $\tilde{O}(dn^{\omega})$ field operations, such that

[TABLE]

Here the empty sections of the matrices represent zeros in the matrix and the $d$s represent entries of degree at most $d$. This means the left part of $A$ is a kernel-base of the lower part of $B$ and likewise the right part of $A$ is a kernel-base of the lower part of $B$.

This procedure can now be repeated on the two smaller $n/2\times n/2$ matrices of degree $2d$. After $\log n$ such iterations we have:

[TABLE]

We call this chain $A_{1},\dots,A_{\log n}$ the kernel basis decomposition of $B$. Here, $B\prod_{i}A_{i}=D$, and each $A_{i}$ consists of $2^{i-1}$ block matrices on the diagonal of dimension $n/2^{i-1}$ and degree $d2^{i-1}$. So while the degree of these blocks doubles, the dimension is halved, which implies that all these $A_{i}$ can be computed in just $\tilde{O}(dn^{\omega})$ operations.

Observe that the inverse $B^{-1}$ can be written as $\prod_{i}A_{i}D^{-1}$. Also, $D^{-1}$ is a diagonal matrix, and so is easily invertible, i.e. we can write the entries of the inverse in the form of rationals $p/q$ where both $p$ and $q$ are of degree $O(dn)$. Therefore, we can represent the adjoint via $\operatorname{adj}(B)=B^{-1}\det(B)=\prod_{i}A_{i}D^{-1}\det(B)$

To compute $v^{\top}\operatorname{adj}(B)$ for any degree $d$ vector $v$ in $\tilde{O}(dn^{2})$ operations, we must compute $v^{\top}\prod_{i}A_{i}\det(B)D^{-1}$ from left to right. Each vector matrix product with some $A_{i}$ has degree $d2^{i-1}$ but at the same time the dimension of the diagonal blocks is only $n/2^{i-1}$, hence each product requires only $\tilde{O}(dn^{2})$ field operations. Scaling by $\det(B)$ and dividing by the entries of $D$ also requires only $O(dn^{2})$ as their degrees are bounded by $O(dn)$. This gives us Theorem 1.7.

The idea of Theorem 1.8 is to explicitly precompute a prefix $P=\prod_{i\leq k}A_{i}$ from the factors of $\prod_{i}A_{i}\det(B)D^{-1}$. This increases the preprocessing time but at the same time allows us to compute $\operatorname{adj}(B)_{i,j}=\vec{e}_{i}^{\top}P\prod_{i>k}A_{i}\det(B)D^{-1}\vec{e}_{j}$ faster.

1.2 Comparison with previous works

Previous dynamic matrix algorithms.

In contrast to algorithms for sensitive oracles that handle a single batch of updates, dynamic algorithms must handle an (infinite) sequence of updates. The techniques we used for our sensitive distance/reachability oracles are motivated from techniques developed for dynamic algorithms which we will discuss below.

There is a line of work initiated by Sankowski [San04, San07, vdBNS19] on maintaining inverse or adjoint of a dynamic matrix whose entries are field elements, not polynomials as in our setting. Let us call such matrix a non-polynomial matrix. By the similar reductions for obtaining applications on weighted graphs in this paper, dynamic non-polynomial matrix algorithms imply solutions to many dynamic algorithms on unweighted graphs.

Despite the similarity of the results and applications, there is a sharp difference at the core techniques of our algorithm for polynomial matrices and the previous algorithms for non-polynomial matrices. The key to all our results is fast preprocessing time. By using the kernel basis decomposition [ZLS15], we do not need to explicitly write down the adjoint of a polynomial matrix, which takes $\Omega(dn^{3})$ operations if the matrix has size $n\times n$ and degree $d$. This technique is specific for polynomial matrix and does not have a meaningful counterpart for a non-polynomial matrix. On the contrary, algorithms for non-polynomial matrices from [San04, San07, vdBNS19] just preprocess a matrix in a trivial way. That is, they compute the inverse and/or adjoint explicitly in $O(n^{\omega})$ operations. Their key contribution is how to handle update in $o(n^{2})$ operations.

We remark that Sankowski [San05b] did obtain a dynamic polynomial matrix algorithm by extending previous dynamic non-polynomial matrix algorithms. However, there are two limitations to this approach. First, the algorithm requires a matrix of the form $(\mathbb{I}-X\cdot A)$ where $A\in\mathbb{F}[X]^{n\times n}$. This restriction excludes some applications including distances on graphs with zero or negative weights because we cannot use the reduction Lemma 2.1. Second, the cost of the algorithm is multiplied by the degree of the adjoint matrix which is $O(dn)$ if $A$ has degree $d$. Hence, just to update one entry, this takes $O(dn\times n^{1.407})$ operations888The current best algorithm [vdBNS19] takes $O(n^{1.407})$ operations to update one entry of a non-polynomial matrix.. This is already slower than the time for computing from scratch an entry of adjoint/inverse $\tilde{O}(dn^{\omega})$ using static algorithms999The first limitation explains why there is only one application in [San05b], which is to maintain distances on unweighted graphs. To bypass the second limitation, Sankowski [San05b] “forces” the degrees to be small by executing all arithmetic operations under modulo $X^{k}$ for some small $k$. A lot of information about the adjoint is lost from doing this. However, for his specific application, he can still return the queried distances by combining with other graph-theoretic techniques. .

Previous sensitive distance oracles.

Previous sensitive distance oracles such as [WY13, GW12] also use fast matrix-multiplication, but only use it for computing a fast min-plus matrix product in a black box manner. All further techniques used by these algorithms are graph theoretic.

Our shift from graph-theoretic techniques to a purely algebraic algorithm is the key that enables us to support large sets of updates. Let us explain why previous techniques can inherently handle only small number of deletions. Their main idea is to sample many smaller subgraphs in the preprocessing. To answer a query in the updated graph, their algorithms simply look for a subgraph $H$ where (i) all deleted edges were not even in $H$ from the beginning, and (ii) all edges in the new shortest path are in $H$. To argue that $H$ exists with a good probability, the number of deletions cannot be more than $\log n$ where $n$ is the number of nodes. That is, these algorithms do not really re-compute the new shortest paths, instead they pre-compute subgraphs that “avoid” the updates.

Purely algebraic algorithms such as ours (and also [San05b, vdBNS19, vdBN19]) can overcome the limit on deletions naturally. For an intuitive explanation consider the following simplified example for unweighted graphs: Let $A$ be the adjacency matrix of an unweighted graph, then the polynomial matrix $(\mathbb{I}-X\cdot A)$ has the following inverse when considering the field of formal power series: $(\mathbb{I}-X\cdot A)^{-1}=\sum_{k\geq 0}X^{k}A^{k}$ (this can be seen by multiplying both sides with $\mathbb{I}-X\cdot A$). This means the coefficient of $X^{k}$ of $(\mathbb{I}-X\cdot A)^{-1}_{i,j}$ is exactly the number of walks of length $k$ from $i$ to $j$. So the entry $(\mathbb{I}-X\cdot A)^{-1}_{i,j}$ does not just tell us the distance between $i$ and $j$, the entry actually encodes all possible walks from $i$ to $j$. Thus finding a replacement path, when some edge is removed, becomes very simple because the information of the replacement path is already contained in entry $(\mathbb{I}-X\cdot A)^{-1}_{i,j}$. The only thing we are left to do is to remove all paths from $(\mathbb{I}-X\cdot A)^{-1}_{i,j}$ that use any of the removed edges. This is done via cancellations caused by applying the Sherman-Morrison formula.

Our algorithm exploits the adjoint instead of the inverse, but the interpretation is similar since for invertible matrices the adjoint is just a scaled inverse: $\operatorname{adj}(M)=M^{-1}\det(M)$. We also do not perform the computations over $\mathbb{Z}[X]$, but $\mathbb{F}[X]$ to bound the required bit-length to represent the coefficients.

1.3 Organization

We first introduce relevant notations, definitions, and some known reductions in Section 2. We construct the adjoint oracles from Theorems 1.7 and 1.8 based on kernel basis decomposition in Section 3. Finally, we show our algorithms for maintaining adjoint of polynomial matrices in Section 4.1, where we will also apply the reductions to get our distance and reachability oracles Theorems 1.1 and 1.2.

2 Preliminaries

Complexity Measures

Most of our algorithms work over any field $\mathbb{F}$ and their complexity is measured in the number of arithmetic operations performed over $\mathbb{F}$, i.e. the arithmetic complexity. This does not necessarily equal the time complexity of the algorithm as one arithmetic operation could require more than $O(1)$ time, e.g. very large rational numbers could require many bits for their representation. This is why our algebraic lemmas and theorems will always state “in $O(\cdot)$ operations” instead of “in $O(\cdot)$ time”.

For the graph applications however, when having an $n$ node graph, we will typically use the field $\mathbb{Z}_{p}$ for some prime $p$ of order $n^{c}$ for some constant $c$. This means each field element requires only $O(\log n)$ bits to be represented and all field operations can be performed in $O(1)$ time in the standard model (or $\tilde{O}(1)$ bit-operations).

Notation: Identity and Submatrices

The identity matrix is denoted by $\mathbb{I}$.

Let $I,J\subset[n]:=\{1,...,n\}$ and $A$ be a $n\times n$ matrix, then the term $A_{I,J}$ denotes the submatrix of $A$ consisting of the rows $I$ and columns $J$. For some $i\in[n]$ we may also just use the index $i$ instead of $\{i\}$. The term $A_{[n],i}$ thus refers to the $i$th column of $A$.

Matrix Multiplication

We denote with $O(n^{\omega})$ the arithmetic complexity of multiplying two $n\times n$ matrices. Currently the best bound is $\omega<{2.3729}$ [Gal14, Wil12].

Polynomial operations

Given two polynomials $p,q\in\mathbb{F}[X]$ with $\deg(p),\deg(q)\leq d$, we can add and subtract the two polynomials in $O(d)$ operations in $\mathbb{F}$. We can multiply the two polynomials in $O(d\log d)$ using fast-fourier-transformations, likewise dividing two polynomials can be done in $O(d\log d)$ as well [AHU74, Section 8.3]. Since we typically hide polylog factors in the $\tilde{O}(\cdot)$ notation, all operations using degree $d$ polynomials from $\mathbb{F}[X]$ can be performed in $\tilde{O}(d)$ operations in $\mathbb{F}$.

Polynomial Matrices

We will work with polynomial matrices/vectors, so matrices and vectors whose entries are polynomials. We define for $M\in\mathbb{F}[X]^{n\times m}$ the degree $\deg(M):=\max_{i,j}\deg(M_{i,j})$. Note that a polynomial matrix $M\in\mathbb{F}[X]^{n\times n}$ with $\det(A)\neq 0$ might not have an inverse in $\mathbb{F}[X]^{n\times n}$ as $\mathbb{F}[X]$ is a ring. However, the inverse $M^{-1}$ does exist in $\mathbb{F}(X)^{n\times n}$ where $\mathbb{F}(X)$ is the field of rational functions.

Adjoint of a Matrix

The adjoint of an $n\times n$ matrix $M$ is defined as $\operatorname{adj}(M)_{i,j}=(-1)^{i+j}\det(M_{[n]\setminus j,[n]\setminus i})$. In the case that $M$ has non-zero determinant, we have $\operatorname{adj}(M)=\det(M)\cdot M^{-1}$. Note that in the case of $M$ being a degree $d$ polynomial matrix, we have $\operatorname{adj}(M)\in\mathbb{F}[X]^{n\times n}$ and $\deg(\operatorname{adj}(M))<nd$.

Graph properties from polynomial matrices

Polynomial matrices can be used to obtain graph properties such as the distance between any pair of nodes:

Lemma 2.1** ([San05a, Theorem 5 and Theorem 7]).**

Let $\mathbb{F}:=\mathbb{Z}_{p}$ be a field of size $p\sim n^{c}$ for some constant $c>1$ and let $G$ be a graph with $n$ nodes and integer edge weights $(c_{i,j})_{1\leq i,j\leq n}\in[-W,W]$.

Let $A\in\mathbb{F}[X]^{n\times n}$ be a polynomial matrix, where $A_{i,i}=X^{W}$ and $A_{i,j}=a_{i,j}X^{W+c_{i,j}}$ and each $a_{i,j}\in\mathbb{F}$ is chosen independently and uniformly at random.

• •

If $G$ contains no negative cycle, then the smallest degree of the non-zero monomials of $\operatorname{adj}(A)_{i,j}$ minus $W(n-1)$ is the length of the shortest path from $i$ to $j$ in $G$ with probability at least $1-n^{1-c}$.

• •

Additionally with probability at least $1-n^{1-c}$, the graph $G$ has a negative cycle, if and only if $\det(A)$ has a monomial of degree less than $Wn$.

3 Adjoint Oracle

In this section we will outline how the adjoint oracle Theorem 1.7 by [ZLS15] can be extended to our Theorem 1.8.

Unfortunately this new result is not a blackbox reduction, instead we have to fully understand and exploit the properties of the algorithm presented in [ZLS15]. This is why a formally correct proof of Theorem 1.8 requires us to repeat many definitions and lemmas from [ZLS15]. Such a formally correct proof can be found in subsection 3.2. We will start with a high level description based on the high level idea of Theorem 1.7 presented in Section 1.1.

3.1 Extending the Oracle to Element Queries

We will now outline how the data-structure of kernel-bases, presented in Section 1.1, can be used for faster element queries to $\operatorname{adj}(B)$. Remember that Theorem 1.7 was based on representing $\operatorname{adj}(B)=\prod_{i=1}^{\log n}A_{i}D^{-1}\det(B)$, where each $A_{i}$ consists of $2^{i-1}$ diagonal blocks of size $n/2^{i-1}\times n/2^{i-1}$ and is of degree $d2^{i-1}$.

The idea for Theorem 1.8 is very simple: Choose some $0\leq\mu\leq 1$ and $k$ such that $2^{k}=n^{\mu}$, then during the pre-processing compute the kernel-base decomposition $\operatorname{adj}(B)=\prod_{i}A_{i}D^{-1}\det(B)$ and pre-compute the product $M:=\prod_{i=1}^{k}A_{i}$ explicitly. When an entry $(i,j)$ of $\operatorname{adj}(B)$ is required, we only have to compute $\vec{e}_{i}^{\top}M\prod_{i>k}A_{i}\vec{e}_{j}D_{j,j}^{-1}\det(B)$.

Complexity of the Algorithm

Let $A_{i}^{[j]}$ be the $(n/2^{i-1})\times(n/2^{i-1})$ matrix obtained when setting all of $A_{i}$ to 0, except for the diagonal block that includes the $j$th column. We will now argue, that $\vec{e}_{i}^{\top}M\prod_{r>k}A_{r}\vec{e}_{j}=\vec{e}_{i}^{\top}M\prod_{r>k}A_{r}^{[j]}\vec{e}_{j}$. This equality can be seen by computing the product from right to left:

• •

Consider the right-most product $A_{\log n}\vec{e}_{j}$. The vector $\vec{e}_{j}$ is non-zero only in the $j$th row, so only the $j$th column of $A_{\log n}$ matters, hence $A_{\log n}\vec{e}_{j}=A_{\log n}^{[j]}\vec{e}_{j}$.

• •

Consider the product $A_{i}A_{i+1}^{[j]}$. The matrix $A_{i+1}^{[j]}$ has few non-zero rows, so most columns of $A_{i}$ will be multiplied by zero and we thus most entries of $A_{i}$ do not matter for computing the product. Note that all entries of $A_{i}$ that do matter (i.e. are multiplied with non-zero entries of $A_{i+1}^{[k]}$) are inside the block $A_{i}^{[j]}$, because of the recursive structure of the matrices (i.e. the blocks of $A_{i+1}$ are obtained by splitting the blocks of $A_{i}$), see for instance Figure 1. This leads to $A_{i}A_{i+1}^{[j]}=A_{i}^{[j]}A_{i+1}^{[j]}$.

By induction we now have $\vec{e}_{i}^{\top}M\prod_{r>k}A_{r}\vec{e}_{j}=\vec{e}_{i}^{\top}M\prod_{r>k}A_{r}^{[j]}\vec{e}_{j}$.

The complexity of computing this product is very low, when multiplied from left to right. Consider the first products $\vec{e}_{i}MA_{k+1}^{[j]}$. The degree of matrix $M$ and $A_{k+1}^{[j]}$ are both bounded by $O(dn2^{k})$. The matrix $A_{k+1}^{[j]}$ is 0 except for a $(n/2^{k})\times(n/2^{k})$ block on the diagonal. Hence, this first product requires $\tilde{O}(d2^{k}(n/2^{k})^{2})$ field operations.

All products after this require fewer operations: On one hand the degree of vector and matrix double after each product, on the other hand the dimension of the non-zero block of $A_{r}^{[j]}$ is halved. Since the complexity of the vector matrix product scales linearly in the degree but quadratic in the dimension, the complexity is bounded by the initial product $\vec{e}_{i}MA_{k+1}^{[j]}$. The query complexity is thus $\tilde{O}(d2^{k}(n/2^{k})^{2})=\tilde{O}(dn^{2-\mu})$.

This is only a rough simplification of how the algorithm works. For instance the degrees of the $A_{1},...A_{\log n}$ are not simple powers of 2, instead only the average degree is bounded by a power of 2. Likewise the dimension $n$ and the size of the diagonal blocks do not have to be a power of two.

3.2 Formal Proof of the Adjoint Element Oracle

Before we can properly prove our Theorem 1.8, we first have to define/cite some terminology and lemmas from [ZLS15], as our Theorem is heavily based on their result.

First we will define the notation of shifted column degrees. Shifted column degrees can be used to formalize how the degree of a vector changes when multiplying it with a polynomial matrix.

Definition 3.1** ([ZLS15, Section 2.2]).**

Let $\mathbb{F}$ be some field, $M\in\mathbb{F}[X]^{n\times m}$ be some polynomial matrix and let $\vec{s}\in\mathbb{N}^{n}$ be some vector.

Then the $\vec{s}$-shifted column degrees of $M$ is defined via:

[TABLE]

Lemma 3.2**.**

Let $\mathbb{F}$ be some field, $M\in\mathbb{F}[X]^{n\times m}$ be some polynomial matrix and let $\vec{s}\in\mathbb{N}^{n}$ be some vector. Further let $\vec{v}\in\mathbb{F}[X]^{n}$ be a polynomial vector where $\deg(\vec{v}_{i})\leq\vec{s}_{i}$ for $i=1,...,n$.

Then $\deg((\vec{v}^{\top}M)_{j})\leq\operatorname{cdeg}_{\vec{s}}(M)_{j}$ and $\vec{v}^{\top}M$ can be computed in $\tilde{O}(n\sum_{j=1}^{m}\operatorname{cdeg}_{\vec{s}}(M)_{j})$.

Proof.

Multiplying $\vec{v}_{i}M_{i,j}$ requires $\tilde{O}(\deg(\vec{v}_{i})+\deg(M_{i,j}))$ field operations. Hence the total cost becomes

[TABLE]

∎

We will now give a formal description of the data-structure constructed in [ZLS15]. The following definitions and properties hold throughout this entire section.

Let $B\in\mathbb{F}[X]^{n\times n},\vec{s}\in\mathbb{N}^{n}$ such that $\operatorname{cdeg}_{\vec{0}}(B)_{j}\leq\vec{s}_{j}$, so $\vec{s}_{j}$ bounds the maximum degree in the $j$th column of $M$ (also called the column degree of $M$). Let $d:=\sum_{i}\vec{s}_{i}/n$ be the average column degree of $B$.

In [ZLS15] they construct in $\tilde{O}(dn^{\omega})$ field operations a chain of matrices $A_{1},...,A_{\lceil\log n\rceil}\in\mathbb{F}[X]^{n\times n}$ and a diagonal matrix $D\in\mathbb{F}[X]^{n\times n}$ such that $\operatorname{adj}(B)=(\prod_{i}A_{i})\det(B)D^{-1}$.

Here the matrices $(A_{i+1})_{i=0...\lceil\log n\rceil-1}$ are block matrices consisting each of $2^{i}$ diagonal blocks, i.e.

[TABLE]

The number of rows/column of each $A_{i+1}^{(k)}$ is $n/2^{i}$ upto a factor of 2. (Note that $A_{i}^{(k)}$ refers to the $k$th block on the diagonal of $A_{i}$, not to be confused with our earlier definition of $A_{i}^{[j]}$ in subsection 3.1).

Remember from the overview (Section 1.1) that each $A_{i}^{(k)}$ consists of two kernel bases, so each of these diagonal block matrices consists in turn of two matrices (kernel bases)

[TABLE]

Here $l$ and $r$ are not variables but denote the left and right submatrix.

We also write $M_{i}$ for the partial product $M_{i}:=\prod_{k=1}^{i}A_{k}$. Each $M_{i}$ can be decomposed into

[TABLE]

where each $M_{i}^{(k)}$ has $n$ rows and the number of columns in $M_{i}^{(k)}$ corresponds to the number of columns in $A_{i+1}^{(k)}$. We can compute $M_{i}$ as follows:

[TABLE]

We have the following properties for the degrees of these matrices:

Lemma 3.3** (Lemma 10 in [ZLS15]).**

Let $m\times m$ be the dimension of $M_{i}^{(k)}$, let $m_{l}$ and $m_{r}$ be the number of columns in $N_{i+1,l}^{(k)}$ and $N_{i+1,r}^{(k)}$ respectively and let $\vec{t}:=\operatorname{cdeg}_{\vec{s}}(M_{i}^{(k)})$, then

• •

$\sum_{j=1}^{m}\vec{t}_{j}\leq\sum_{j=1}^{n}\vec{s}_{j}=dn$, and

• •

$\sum_{j=1}^{m_{l}}\operatorname{cdeg}_{\vec{t}}(N_{i+1,l}^{(k)})_{j}\leq\sum_{j=1}^{n}\vec{s}_{j}=dn$* and *$\sum_{j=1}^{m_{r}}\operatorname{cdeg}_{\vec{t}}(N_{i+1,r}^{(k)})_{j}\leq\sum_{j=1}^{n}\vec{s}_{j}=dn$

(which also implies $\sum_{j=1}^{m}\operatorname{cdeg}_{\vec{t}}(A_{i+1}^{(k)})_{j}\leq 2dn$)

Lemma 3.4** (Lemma 11 in [ZLS15]).**

For a given $i$ and $k$ the matrix multiplications in (2) can be done in $\tilde{O}(n(n/2^{i})^{\omega-1}(1+d2^{i})))$ field operations.

We now have defined all the required lemmas and notation from [ZLS15] and we can now start proving Theorem 1.8.

The following lemma is analogous to Lemma 3.4, though now we want to compute only one row of product (2). This lemma will bound the complexity of the query operation in Theorem 1.8.

Lemma 3.5**.**

Let $v^{\top}:=\vec{e}_{r}^{\top}M_{i}^{(k)}$ be some row of $M_{i}^{(k)}$, then we can compute $v^{\top}N_{i+1,c}^{(k)}$ for both $c=l,r$ in $\tilde{O}(dn^{2}/2^{i})$.

Proof.

The matrices $N_{i+1,l}^{(k)}$ and $N_{i+1,r}^{(k)}$ form the matrix $A_{i+1}^{(k)}$, so we instead just compute the product $\vec{v}^{\top}A_{i+1}^{(k)}$. The matrix $A_{i+1}^{(k)}$ is of size $(n/2^{i})\times(n/2^{i})$ (up to a factor of 2). Let $\vec{t}:=\operatorname{cdeg}(\vec{v}^{\top})$ then by Lemma 3.3 we know $\sum_{j}\operatorname{cdeg}_{\vec{t}}(A_{i+1}^{(k)})_{j}\leq 2\sum_{j}\vec{s}_{j}=2dn$ and $\sum_{j}\vec{t}_{j}\leq dn$.

By Lemma 3.2 the cost of computing $\vec{v}^{\top}A_{i+1}^{(k)}$ is $\tilde{O}(n/2^{i}\sum_{j=1}^{m}\operatorname{cdeg}_{\vec{t}}(A_{i+1}^{(k)})_{j})$, which given the degree bounds can be simplified to $\tilde{O}(dn^{2}/2^{i})$. ∎

The following lemma will bound the complexity for the pre-processing of Theorem 1.8.

Lemma 3.6**.**

If we already know the matrix $A_{i}$ for $i=1,...\lceil\log n\rceil$, then for any $0\leq\mu\leq 1$ we can compute $M_{\lceil\log n^{\mu}\rceil}$ in $\tilde{O}(dn^{\omega(1-\mu)+3\mu})$ field operations.

Proof.

To compute $M_{i+1}$, requires to compute all $2^{i}$ many $M_{i+1}^{(k)}$ for $k=1...2^{i}$. Assume we already computed matrix $M_{i}$, then we can compute $M_{i+1}^{(k)}$ for $k=1...2^{i}$ via Lemma 3.4. Inductively the total cost we obtain is:

[TABLE]

∎

The last lemma we require for the proof of Theorem 1.8 is that we can compute the determinant of $B$ in $\tilde{O}(dn^{\omega})$ field operations.

Lemma 3.7** ([Sto03, LNZ17]).**

Let $B\in\mathbb{F}[X]^{n\times n}$ be a matrix of degree at most $d$, then we can compute $\det(B)$ in $\tilde{O}(dn^{\omega})$ field operations.

Proof of Theorem 1.8.

The claim is that for any $0\leq\mu\leq 1$ we can, after $\tilde{O}(dn^{\omega(1-\mu)+3\mu})$ pre-processing of $B$, compute any entry $\operatorname{adj}(B)_{i,j}$ in $\tilde{O}(n^{2-\mu})$ operations.

Pre-processing

We first compute the determinant $\det(B)$ via Lemma 3.7 and construct the chain of matrices $A_{1},...A_{\lceil\log n\rceil}$ as in [ZLS15] in $\tilde{O}(dn^{\omega})$, then we compute $M_{\lceil\log n^{\mu}\rceil}$ in $\tilde{O}(dn^{\omega(1-\mu)+3\mu})$ using Lemma 3.6.

Queries

When answering a query for $\operatorname{adj}(A)_{i,j}$ we compute one entry $(M_{\lceil\log n\rceil})_{i,j}$, multiply it with $\det(A)$ and divide it by $D_{j,j}$, because $\operatorname{adj}(A)=(\prod_{i=1}^{\lceil\log n\rceil}A_{i})\det(A)D^{-1}=M_{\lceil\log n\rceil}\det(A)D^{-1}$.

Here the expensive part is to compute the entry of $M_{\lceil\log n\rceil}$, which is done by computing one row of $M_{\lceil\log n\rceil}^{(k)}$ for some appropriate $k$. Via (2), we know

[TABLE]

for some sequence $k_{t}\in[2^{\lceil\log n^{\mu}\rceil+t}]$, $c_{t}\in\{l,r\}$.

So we only have to compute the product of the $i$th row of $M_{\lceil\log n^{\mu}\rceil}$ with a sequence of $(N_{\lceil\log n^{\mu}\rceil+t,c_{t}}^{(k_{t})})_{t=1...\lceil\log n\rceil-1}$ matrices. Computing this product from left to right means we compute the following intermediate results

[TABLE]

for every $r=1,...,\lceil\log n\rceil-\lceil\log n^{\mu}\rceil$. So each intermediate result is just the $i$th row of some matrix $M_{\lceil\log n^{\mu}\rceil+r}^{(k_{r})}$. This means such a vector-matrix product can be computed via Lemma 3.5 in

[TABLE]

Here the first product for $r=1$ is the most expensive and the total cost for all $\lceil\log n\rceil-\lceil\log n^{\mu}\rceil$ many vector-matrix products becomes $\tilde{O}(dn^{2-\mu})$.

∎

4 Sensitive Distance and Reachability Oracles

In this section we will use the adjoint oracle from Section 3 to obtain the results presented in Section 1. A high-level description of that algorithm was already outlined in Section 1.1.

This section is split into two parts: First we will describe in Section 4.1 our results for maintaining the adjoint of a polynomial matrix, which will conclude with the proof of Theorem 1.1. The second subsection 4.2 will explain how to obtain the sensitive reachability oracle Theorem 1.2. These graph theoretic results will be stated more accurately than in the overview by adding trade-off parameters and memory requirements.

All proofs in this section assume that the matrix $A$ stays non-singular throughout all updates, which is the case w.h.p for matrices constructed via the reduction of Lemma 2.1.

4.1 Adjoint oracles

Theorem 4.1**.**

Let $\mathbb{F}$ be some field and $A\in\mathbb{F}[X]^{n\times n}$ be a polynomial matrix with $\det(A)\neq 0$ of degree $d$. Then for any $0\leq\mu\leq 1$ we can create a data-structure storing $O(dn^{2+\mu})$ field elements in $\tilde{O}(dn^{\omega(1-\mu)+3\mu})$ field operations, such that:

We can change $f$ columns of $A$ and update our data-structure in $\tilde{O}(dn^{2-\mu}f^{2}+dnf^{\omega})$ field operations storing additional $O(dnf^{2})$ field elements. This updated data-structure allows for querying entries of $\operatorname{adj}(A)$ in $\tilde{O}(dnf^{2}+dn^{2-\mu}f)$ field operations and queries to the determinant of the new $A$ in $O(dn)$ operations.

Proof.

We start with the high-level idea: We will express the change of $f$ entries of $A$ via the rank $f$ update $A+UV^{\top}$, where $U,V\in\mathbb{F}^{n\times f}$ and both matrices have only one non-zero entry per column. Via Lemma 1.6 we have for $M:=\mathbb{I}\cdot\det(A)+V^{\top}\operatorname{adj}(A)U$ that

[TABLE]

Our algorithm is as follows:

Initialization

During the initialization use Theorem 1.8 on matrix $A$ in $\tilde{O}(dn^{\omega+(3-\omega)\mu})$ operations, which will allow us later to query entries $\operatorname{adj}(A)_{i,j}$ in $\tilde{O}(dn^{2-\mu})$ operations. We also compute $\det(A)$ via Lemma 3.7 in $\tilde{O}(dn^{\omega})$ operations.

Updating the data-structure

The first task is to compute the matrix $M$. Note that for element updates to $A$, the matrices $U$ and $V$ have only one non-zero entry per column, so $V^{\top}\operatorname{adj}(A)U$ is just an $f\times f$ submatrix of $A$ where each entry is multiplied by one non-zero entry of $U$ and $V$. Thus we can compute $M=\mathbb{I}\cdot\det(A)+V^{\top}\operatorname{adj}(A)U$ in $\tilde{O}(df^{2}n^{2-\mu})$ operations, thanks to the pre-processing of $A$. Next, we pre-processing the matrix $M$ using Theorem 1.7, which requires $\tilde{O}(dnf^{\omega})$ as the degree of $M$ is bounded by $O(dn)$. We also compute $\det(M)$ in $\tilde{O}(dnf^{\omega})$ operations.

Thus the update complexity is bounded by $\tilde{O}(df^{2}n^{2-\mu}+dnf^{\omega})$ operations.

Querying entries

To query an entry $(i,j)$ of $\operatorname{adj}(A+UV^{\top})$ we have to compute

[TABLE]

Here $\operatorname{adj}(A)_{i,j}\det(M)$ can be computed in $\tilde{O}(dn^{2-\mu}+dnf)$ operations. The vectors $\vec{e}_{i}\operatorname{adj}(A)U$ and $V^{\top}\operatorname{adj}(A)\vec{e}_{j}$ are just $f$ entries of $\operatorname{adj}(A)$ where each entry is multiplied by one non-zero entry of $U$ or $V$, so we can compute them in $\tilde{O}(dn^{2-\mu}f)$ operations. Multiplying one of these vectors with $\operatorname{adj}(M)$ requires $\tilde{O}(dnf^{2})$ operations because of the pre-processing of $M$ via Theorem 1.7. The product of $\left(\vec{e}_{i}\operatorname{adj}(A)U\right)\operatorname{adj}(M)$ with $\left(V^{\top}\operatorname{adj}(A)\vec{e}_{j}\right)$ can be computed in $\tilde{O}(dnf^{2})$ operations. Subtracting $\operatorname{adj}(A)_{i,j}\det(M)$ from the product and dividing by $\det(A)^{f}$ can be done in $\tilde{O}(dnf)$ operations.

The query complexity is thus $\tilde{O}(dnf^{2}+dn^{2-\mu}f)$ operations.

Maintaining the determinant

We have $\det(A+UV^{\top})=\det(M)/\det(A)^{f-1}$ (as can be seen in the proof of Appendix A). The division requires only $\tilde{O}(dnf)$ operations.

∎

In this section we will state the result from Section 1 in a more formal way. We will state trade-off parameters, memory consumption and we will separate the sensitive setting into two phases: update and query.

Theorem 4.2** (Corresponds to Theorem 1.1).**

Let $G$ be a graph with $n$ nodes and edge weights in $[-W,W]$. For any $0\leq\mu\leq 1$ we can create in $\tilde{O}(Wn^{\omega(1-\mu)+3\mu})$ time a Monte Carlo data-structure that requires $O(Wn^{2+\mu}\log n)$ bits of memory, such that:

We can then change $f$ edges (additions and removals) and update our data-structure in $\tilde{O}(Wn^{2-\mu}f^{2}+Wnf^{\omega})$ time using additional $O(Wnf^{2}\log n)$ bits of memory. This updated data-structure allows for querying the distance between any pair of nodes in $\tilde{O}(Wnf^{2}+Wn^{2-\mu}f)$ time, or report that there exists a negative cycle in $O(1)$ time.

Proof of Theorem 4.2.

We construct the matrix as specified in Lemma 2.1. Since the field size is polynomial in $n$, the arithmetic operations can be executed in $O(1)$ time in the standard model and saving one field element requires $O(\log n)$ bits.

The determinant of the matrix is computed during the update, where we will also check for negative cycles by checking if the determinant has a non-zero monomial of degree less than $Wn$. This way we can answer the existence of a negative cycle in $O(1)$ time, when a query to a distance is performed.

Theorem 4.2 is now implied by Theorem 4.1.

∎

4.2 Sensitive reachability oracle

So far we have only proven the distance applications. Using the same techniques the result can also be extended to a sensitive reachability oracle.

Reachability can be formulated as a distance problem where every edge has cost 0. In that case the matrix constructed in Lemma 2.1 has degree 0, so the matrix is in $\mathbb{F}^{n\times n}$ and we do not have to bother with polynomials anymore. The algorithm for the following result is essentially the same as Theorem 4.1, but since we no longer have polynomial matrices, we no longer require more sophisticated adjoint oracles and can instead use simpler subroutines.

Theorem 4.3** (Corresponds to Theorem 1.2).**

Let $G$ be a graph with $n$ nodes. We can construct in $O(n^{\omega})$ time a Monte Carlo data-structure that requires $O(n^{2}\log n)$ bits of memory, such that:

We can change any $f$ edges (additions and removals) and update our data-structure in $O(f^{\omega})$ time using additional $O(f^{2}\log n)$ bits of memory. This updated data-structure allows for querying the reachability between any pair of nodes in $O(f^{2})$ time.

Proof.

We will now construct a data-structure that, after some initial pre-processing of some matrix $A\in\mathbb{F}^{n\times n}$, allows us to quickly query elements of $\operatorname{adj}(A+UV^{\top})$ for any sparse $U,V\in\mathbb{F}^{n\times f}$ where $U$ and $V$ have at most one non-zero entry per column.

Pre-processing

We compute $\det(A)$ and $\operatorname{adj}(A)$ explicitly in $O(n^{\omega})$ field operations.

Update

We receive matrices $U,V\in\mathbb{F}^{f\times n}$, where each column has only one non-zero entry. We compute $V^{\top}\operatorname{adj}(A)U$ in $O(f^{2})$ operations because of the sparsity of $U$ and $V$. This means we can now compute for $M:=\mathbb{I}\cdot\det(A)+V^{\top}\operatorname{adj}(A)U$ the matrix $\operatorname{adj}(M)$ and $\det(M)$ in $O(f^{\omega})$ operations.

Query

When querying an entry $(i,j)$ of $\operatorname{adj}(A+UV^{\top})$ we have to compute:

[TABLE]

The vectors $\vec{u}^{\top}:=\operatorname{adj}(A)_{i,[n]}U$ and $\vec{v}:=V^{\top}\operatorname{adj}(A)_{[n],j}$ can be computed in $O(f)$ operations as they are just $O(f)$ entries of the adjoint, each multiplied by one non-zero entry of $U$ or $V$. The product $\vec{u}^{\top}\operatorname{adj}(M)\vec{v}$ can be computed in $O(f^{2})$ operations.

Thus the entry of $\operatorname{adj}(A+UV^{\top})$ can be computed in $O(f^{2})$ operations.

∎

5 Open Problems

We present the first graph application of the kernel basis decomposition by [JV05, ZLS15], and we are interested in seeing if there are further uses of that technique outside of the symbolic computation area.

Our sensitive distance oracle has subqubic preprocessing time and subquadratic query time. When restricting to only a single edge deletion, Grandoni and V. Williams where able to improve this to subqubic preprocessing and sublinear query time [GW12]. An interesting open question is whether a similar result can be obtained for multiple edge deletions. Even supporting just two edge deletions with subqubic preprocessing and sublinear query time would a good first step. Alternatively, disproving the existence of such a data-structure would also be interesting. Currently the best (conditional) lower bound by V. Williams and Williams [WW18, HLNW17] refutes such an algorithm, if its complexity has a $\text{polylog}(W)$ dependency on the largest edge weight $W$. For algorithms with $\text{poly}(W)$ dependency no such lower bound is known.

All our data-structures maintain only the distance, or in case of reachability, return a boolean answer. So another open problem would be to find a data-structure, that does not just return the distance, but also the actual path.

Finally, our data-structures are randomized Monte-Carlo. We wonder if there is a deterministic equivalent. In case of the previous result by Weimann and Yuster [WY13], a deterministic equivalent was found by Alon et al. [ACC19].

Acknowledgment

This project has received funding from the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation programme under grant agreement No 715672. This work was mostly done while Thatchaphol Saranurak was at KTH Royal Institute of Technology.

Appendix A Proof of Lemma 1.6

Proof of Lemma 1.6.

Via the Sherman-Morrison-Woodbury formula we have

[TABLE]

and via the Sylvester determinant identity $\det(\mathbb{I}+AB)=\det(\mathbb{I}+BA)$ we have

[TABLE]

This allows us to write the determinant of $M:=\mathbb{I}\cdot\det(A)+V^{\top}\operatorname{adj}(A)U$ as follows:

[TABLE]

Which yields $\operatorname{adj}(A)\cdot\det(M)\det(A)^{-f}=A^{-1}\det(A+UV^{\top})$ because $\operatorname{adj}(A)=A^{-1}\det(A)$. Likewise we obtain:

[TABLE]

Thus we obtain Lemma 1.6 by multiplying the Sherman-Morrison-Woodbury identity with $\det(A+UV^{\top})$. ∎