Department of Computer Science, University of Vienna, Vienna, [email protected] LISN, CNRS & Paris-Saclay University, [email protected] Department of Computer Science, UniVie Doctoral School Computer Science DoCS, University of Vienna, Vienna, [email protected] \fundingMonika Henzinger and A. R. Sricharan: \flagLOGO_ERC-FLAG_EU_.jpgThis project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (Grant agreement No. 101019564 “The Design of Modern Fully Dynamic Data Structures (MoDynStruct)” and from the Austrian Science Fund (FWF) project “Fast Algorithms for a Reactive Network Layer (ReactNet)”, P 33775-N, with additional funding from the netidee SCIENCE Stiftung, 2020–2024 \EventEditorsShiri Chechik, Gonzalo Navarro, Eva Rotenberg, and Grzegorz Herman \EventNoEds4 \EventLongTitle30th Annual European Symposium on Algorithms (ESA 2022) \EventShortTitleESA 2022 \EventAcronymESA \EventYear2022 \EventDateSeptember 5–9, 2022 \EventLocationBerlin/Potsdam, Germany \EventLogo \SeriesVolume244 \ArticleNo34 \CopyrightMonika Henzinger, Ami Paz, and A. R. Sricharan \ccsdescTheory of computation Dynamic graph algorithms
Fine-Grained Complexity Lower Bounds for Families of Dynamic Graphs
Abstract
A dynamic graph algorithm is a data structure that answers queries about a property of the current graph while supporting graph modifications such as edge insertions and deletions. Prior work has shown strong conditional lower bounds for general dynamic graphs, yet graph families that arise in practice often exhibit structural properties that the existing lower bound constructions do not possess. We study three specific graph families that are ubiquitous, namely constant-degree graphs, power-law graphs, and expander graphs, and give the first conditional lower bounds for them. Our results show that even when restricting our attention to one of these graph classes, any algorithm for fundamental graph problems such as distance computation or approximation or maximum matching, cannot simultaneously achieve a sub-polynomial update time and query time. For example, we show that the same lower bounds as for general graphs hold for maximum matching and ()-distance in constant-degree graphs, power-law graphs or expanders. Namely, in an -edge graph, there exists no dynamic algorithms with both update time and query time, for any small . Note that for ()-distance the trivial dynamic algorithm achieves an almost matching upper bound of constant update time and query time. We prove similar bounds for the other graph families and for other fundamental problems such as densest subgraph detection and perfect matching.
keywords:
Dynamic graph algorithms, Expander graphs, Power-law graphs1 Introduction
A dynamic graph algorithm is a data structure that stores a graph and supports update operations, usually consisting of edge insertions and deletions, as well as query operations that ask about a specific property of the graph. The introduction of strong conditional lower bounds based on widely-believed complexity assumptions [1, 16] has had a fundamental influence on the field, pushing the design of new algorithms towards more specialized algorithms such as partially-dynamic or even offline-dynamic algorithms or towards approximate solutions. However, graphs arising in real-world applications often differ significantly from the very specifically crafted graphs for which the lower bound results are shown. Frequently, real-world graphs have some special structure, such as having a power-law degree distribution, a constant degree, or being planar. Expanders, on the other side, have recently been used to design dynamic algorithms for general graphs. This naturally leads to the question of determining the complexity of dynamic graph algorithms for these graph classes, and this is exactly the question investigated in this paper.
While the complexity of dynamic graph algorithms for planar graphs has already been studied quite extensively [25, 18, 22, 20, 3, 2, 1, 19, 8], the question is still widely open for other families of graphs, including power-law graphs, constant-degree graphs, and expanders. Certain problems become easier for these graph classes: As an -node111To avoid confusion with the parameter and matrix used in the online-matrix-vector multiplication conjecture, we use to denote the number of vertices and the number of edges in the dynamic graphs. constant-degree graph has edges, computing all-pairs shortest paths (APSP) takes only time , while the popular APSP conjecture postulates that for general graphs, there exists a small constant such that any algorithm in the word RAM model with -bit words requires expected time to compute APSP. Moreover, some problems become trivial in these graph classes, e.g., computing shortest paths with logarithmic additive error on expander graphs is trivial, due to their low diameter.
In this paper we will concentrate on graph problems that have real-world applications such as shortest-paths (which has applications in online navigation), matching (which has applications in reconfigurable datacenters), and densest subgraphs (which has applications in network analysis), yet we believe that our general approach can be applied to further graph problems. For these three problems, the known conditional lower bounds construct graphs that are far from being in the classes we consider: They have maximum degree and small cuts, and their degree distribution is unknown as it depends on the instance that is postulated to be hard.
Constant-degree graphs.
Various dynamic graph problems that admit strong lower bounds in general graphs have very efficient algorithms on constant-degree graphs. Let be the maximum degree in the graph. For local problems, where the solution at a node can be computed by simply analyzing information stored at the neighbors of such as maintaining a maximal matching, a maximal independent set, or a -vertex coloring, there exist simple dynamic algorithms with update time and constant query time. Additionally, for various problems that count or detect certain fixed subgraphs with nodes (such as triangle counting for ) there exists dynamic algorithms with update time and constant query time, even though they have polynomial conditional lower bounds in general graphs (see Table 1). These efficient algorithms for local problems rule out the possibility of any non-trivial lower bound in the constant-degree setting.
Furthermore, even for the non-local problem of maintaining a maximum matching Gupta and Peng [15] designed a -approximation algorithm for any small that runs in amortized time per update, where denotes the maximum cardinality matching after the -th update operation. As in a graph with maximum degree it holds that , their algorithm achieves an amortized update time of , which is in constant-degree graphs. This raises the question of how efficiently other non-local dynamic graph problems such exact maximum matching, shortest paths, and densest subgraph can be solved in dynamic constant-degree graphs and whether it is possible to show (conditional) lower bounds for them.
Problems | Lower bounds | Upper bounds | |||||
General graphs [16] | Erdős-Rényi avg-case [17] | constant (trivial) | |||||
Triangle | |||||||
counting | |||||||
subgraph | |||||||
counting | |||||||
-length | 1 | ||||||
-path count |
Expanders.
Expander decompositions are increasingly becoming a central tool for designing dynamic graph algorithms with improved running time bounds for various graph problems such as connectivity, minimum spanning tree, shortest paths, conductance, edge-connectivity, maximum flows, and minimum cuts [21, 13, 10, 9]. One of the central subproblems that these algorithms have to handle is to solve a graph problem on a dynamically changing expander. To understand the limitations of this approach it is crucial to understand which problems can be solved efficiently on expanders, and which cannot. We present novel lower bounds for dynamic problems on expanders, more specifically on constant-degree expanders.
Note that these results also have an interesting connection to the average-case hardness of dynamic graph algorithms. Recently, lower bounds on the average-case hardness were shown for various subgraph counting problems in dynamic Erdős-Rényi graphs (see Table 1 for some of them) [17]. As random graphs are usually expanders, giving lower bounds for a problem on dynamic expanders gives an indication that this problem might also be hard in the average case and can motivate further work in this direction.
Power-law graphs.
Graphs are called power-law graphs if the fraction of nodes with degree is proportional to for some constant . Static and dynamic power-law graphs arise surprisingly often in real-world networks, such as the Internet, the world-wide web, and citation graphs, as well as in physics, linguistics, and economics. Even though the existence of large dynamic power-law graphs was already pointed out in 2004 [14], no efficient dynamic algorithms have been developed specifically for this class of graphs. This leads to the question of whether sub-polynomial time dynamic algorithms are even possible for power-law graphs or not. In fact, dynamic power-law graphs were not only never studied, they were not even defined—removing even a single edge from a power-law graph changes the degree distribution and thus violates the power-law distribution. Hence, we first present several definitions of dynamic power-law graphs, where some slackness in the degree-distribution is allowed. Then we prove lower bounds that hold for all of these dynamic power-law graph definitions.
1.1 Our Results
Throughout the paper we use the standard assumption that queries output one value, such as the size, length or weight of the solution. Note that this makes it only more challenging to prove lower bounds. All our results are conditioned on the popular OMv conjecture [16], defined in Section 2, but to simplify the terminology we usually drop the word “conditional”. Our results are also summarized in Footnote 3.
-
1.
Main results. We study the hardness of dynamic algorithms for (i) constant-degree graphs, (ii) expanders, and (iii) power-law graphs, for the following graph problems: Determining (a) the size of a maximum matching, (b) the length of the shortest-path (i.e. -distance), and (c) the density of the densest subgraph. Specifically, we show the following tradeoff between the update time and the query time in an -edge graph for maximum matching and -distance: There is no dynamic algorithm which achieves both and for any small . Note that these bounds match the bounds given for general graphs in [16] and that the lower bound for -distance is almost tight as the simple algorithm that only records the edge change at update time and computes the solution from scratch at query time achieves and . For densest subgraph we show that there is no dynamic algorithm which achieves both and for any small , which is weaker than the lower bound on general graphs (of and ).
The only relevant prior work are conditional lower bounds for planar graphs [1], which have constant degree: In unweighted graphs they show for all-pairs-shortest paths a weaker tradeoff between update time and query time than we do, namely they prove . In weighted graphs they show for ()-distance a tradeoff of . Note that our result is stronger as it shows that in unweighted graphs no algorithm with and is possible.
-
2.
Degree–lower bound trade-off. While the constant-degree lower bounds are equal to the lower bounds for general graphs in terms of , they are naturally quadratically lower in terms of the number of nodes . To understand the behaviour of the bounds also with respect to , we extend our constant-degree lower bounds for maximum matching, perfect matching, and -distance to graphs with maximum degree , for any . We show the following result: There is no dynamic algorithm which achieves both and in a graph with maximum degree for any . These results hold even in bipartite graphs. Note that for these results match exactly the bounds for general graphs in [16], and for , they match the aforementioned results for constant-degree graphs.
-
3.
Approximation results. In constant-degree graphs we extend the lower bound to the problem of approximating the -distance within a factor of , for any small constant . This naturally extends the -approximation lower bounds on general graphs to the constant-degree case. In planar graphs, the -distance lower bound holds only for exact answers.
Note that a similar extension to approximation algorithms is not possible for maximum cardinality matching and for densest subgraph: (a) For maximum matching, for any small the above-mentioned -approximation algorithm [15] achieves an amortized update time of , which is constant for a constant , thereby precluding any non-trivial lower bounds for approximate maximum matching in the constant-degree setting. Stated differently, our work shows an interesting dichotomy for dynamic matching matching in constant-degree graphs: For the exact setting there is no dynamic algorithm which achieves both and for any small , while a -approximation can be achieved in constant time, for any small . (b) The same dichotomy arises for densest subgraph: For any small there exists a -approximation algorithm with polylogarithmic time per operation [24], while we show a polynomial lower bound for the exact value.
-
4.
Partially dynamic algorithms. We extend the constant-degree reductions for maximum matching and -distance also to the insertions-only and the deletions-only setting, achieving the same lower bound as in the fully dynamic setting.
-
5.
Perfect matching. A special case of maximum cardinality matching is determining whether a perfect matching exists in a bipartite graph. For constant-degree graphs and expander graphs we show the following lower bound: There is no dynamic algorithm which achieves both and for any small . This can also be extended to the varying-degree setting.
To summarize, our paper opens up the research field of dynamic graph algorithms for more specific, practical graph classes, in contrast with previous work that concentrated on general or planar graphs. We believe that our techniques can be extended to further classes of dynamic graphs or even in other domains of theoretical computer science, such as distributed graph algorithms or streaming algorithms. One further interesting implication of our work is presenting the limitations of dynamic graph algorithms on expanders, thus complementing recent algorithmic results that use expander decompositions in dynamic graphs.
Problem | Class | Section | ||
Maximum Matching | Section 3.1 | |||
constant degree & expansion | Section 3.3 | |||
power-law graphs | Section 3.4 | |||
, partially dynamic | Section B.2 | |||
Section 3.2 | ||||
-distance | Section 4.1 | |||
-approx, | Section 4.2 | |||
constant degree & expansion | Section 4.4 | |||
power-law graphs | Section 4.5 | |||
, partially dynamic | Section B.1 | |||
Section 4.3 | ||||
Densest Subgraph | Section 5.1 | |||
constant degree & expansion | Section 5.2 | |||
power-law graphs | Section 5.3 |
1.2 Our Techniques
We prove lower bounds by reductions from the online matrix vector (OMv) conjecture [16]. In these reductions, the input of an online problem, which is an matrix and a sequence of pairs of -vectors, is translated into a dynamic graph. The reduction is built so that there exists a pair satisfying if and only if the dynamic graph has some desired property at some point of time. While we follow the general framework of OMv lower bounds, the details are delicate, as the dynamic graphs we construct should fall into specific graph classes at all times, while still maintaining the graph property under consideration. We give a high-level overview of our reductions below.
One way to turn known OMv-to-dynamic graphs reductions into reductions that produce bounded-degree graphs is by replacing high-degree nodes by bounded-degree trees. This technique has a rather clear and straightforward effect on the distances in the graph, so it is applicable when considering distance-related problems. This, however, is far from being the case when considering other problems, such as maximum matchings. Here, replacing a high-degree node with a gadget could adversely affect the desired matching size, since the gadget might create several augmenting paths that would not have existed when it was a single high-degree node. To overcome this, we limit the possible maximum matching sizes, by designing a reduction graph with bounded-degree gadgets composed of paths, where the maximum matching is always either a perfect matching, or a near-perfect matching, i.e., the matching size is either or . This reduction thus involves a large matching and a small gap between the and cases, and hence cannot be extended to achieve a lower bound for the approximation of the maximum matching size. While this might seem as a limitation of our construction, recall that this is actually not the case: As described above, for any small there is a constant time -approximation dynamic algorithm for the problem, and, thus, such a lower bound cannot exist.
An even more delicate reduction we present is for proving a lower bound on the densest-subgraph problem. A straightforward reduction would change graph-edges for every bit of the input, which will allow us to make sure that the density of the densest subgraph changes by a significant amount when versus when . However, this would involve updates for each input pair, and the reduction would fail to yield any non-trivial lower bound. Thus, we are forced to change very few edges for each input bit, which renders an almost negligible effect on the density, making it difficult to control the exact density of the densest subgraph. Our reduction balances these two factors, using a construction where each gadget is a sufficiently dense regular graph, while having each bit of the input translate into the existence or nonexistence of merely two edges inside specific gadgets. As in the case of matchings, our lower bounds cannot be extended to approximations, as for any there exists a fast algorithm with polylogarithmic update time for computing -approximations to the densest subgraph.
We then extend these reductions from bounded-degree graphs to constant-degree constant-expansion graphs. First, the standard lower bound reductions contain sparse cuts if the inputs or are sparse, making a standard reduction graph far from being an expander. Thus, we have to augment the graph with many more edges to make sure that it has no sparse cuts regardless of and . We do this augmentation “inside a layer” to prevent the additional edges from creating undesired short paths between and , or spurious augmenting paths in the case of matchings. Sparse cuts also exist in parts of the graph that do not depend on or , and to handle these, we add edges of a constant-degree expander between a well-chosen set of nodes, thus guaranteeing the expansion without changing the required graph property. Finally, in the case of distance-related problems, we note that expander graphs can have at most logarithmic diameter, but the substitution of nodes by trees described above increases the diameter to be at least logarithmic, leaving only a very small slack for our construction.
When studying densest subgraphs on expanders, adding edges in order to avoid sparse cuts might change the location and structure of the densest subgraph in an undesired way. In order to guarantee the expansion in this case, we add a copy of all the graph nodes, build a constant-degree expander on the copies of the nodes, and then connect each node to its copy by a matching.
In dynamic power-law graphs where the node degrees may depend on the inputs and change over time, we have to guarantee that the degree changes incurred by the processing of different inputs do not cause a violation of the power-law distribution of degrees. As before, all the changes must also be done without changing the graph property under consideration, and without performing too many update operations. We address this problem by inserting or deleting edges in an online fashion in other parts of the reduction graph, to compensate for the changes incurred by processing the input vector pairs.
Organisation
Section 2 has notation and definitions. Section 3 presents the dynamic maximum matching lower bounds, Section 4 presents the dynamic -distance lower bounds, and Section 5 presents the dynamic densest subgraph lower bounds. The lower bounds for the partially dynamic setting are deferred to the appendix.
2 Preliminaries
Throughout the paper, we consider vectors and matrices that are boolean, and so a vector-matrix-vector multiplication outputs a single bit. Henzinger et al. [16] define the Online Matrix Vector (OMv) and the Online Vector Matrix Vector (OuMv) multiplication problems.
Definition 2.1 (Online Matrix Vector Multiplication).
Let be a boolean matrix. Preprocessing the matrix is allowed. Then, vectors arrive one at a time, and the task is to output the product before the next vector is revealed.
Definition 2.2 (Online Vector Matrix Vector Multiplication).
Let be a boolean matrix. Preprocessing the matrix is allowed. Then, vector pairs arrive one at a time, and the task is to output the bit before the next vector pair is revealed.
In their paper, they show that the OuMv problem can be reduced to the OMv problem, and conjecture that there is no truly subcubic time algorithm for OMv.
Conjecture 2.3 (OMv).
There is no algorithm for the OMv (and hence the OuMv) problem running in time for any constant .
We work with the OuMv problem for all the reductions in our paper. We denote the length of our input vectors by , and thus the matrix is of dimension . We use upper indices to indicate the vector’s location in the stream, but usually focus on one pair omitting these indices. We use lower indices for a location in the vector or matrix, e.g., and . We use to denote the number of nodes in our reduction graph.
Definition 2.4 (Expansion).
The expansion parameter of a graph is defined as
where is the number of edges from to . We call a graph with expansion a -expander. Works on dynamic algorithms use a different definition of expansion parameter , called volume expansion. However, when considering constant-degree graphs with constant expansion (as we do in this paper), both parameters are within a factor of each other, so we only consider the expansion parameter in our proofs.
We study power-law graphs as introduced in [4], and only consider the setting where . In the following definition, if the number of nodes in the graph is fixed, then we get that is roughly .
Definition 2.5 (Power Law).
A graph is said to follow an -power law distribution if the number of nodes with degree is inversely proportional to for some constant . That is,
where is the Riemann Zeta function.
Since dynamic graphs allow edge insertions and deletions, it is impossible to maintain an exact degree distribution at all times. Hence, we introduce the notion of approximate power-law distributions to afford some slack for dynamic changes. One natural relaxation is to allow to vary within an interval.
Definition 2.6 (-Varying Power Law).
A graph is said to follow an -varying power law distribution if the number of nodes with degree satisfies
This relaxation of an exact power law, while being natural, is a global relaxation rather than a local one. Thus we also define two locally approximate definitions below that allow similar slack for all degrees.
Definition 2.7 (Additively Approximate Power Law).
A graph is said to follow an -additively approximate power law distribution if the number of nodes of degree for a realisable degree satisfies
where we say that is a realisable degree if there is a node of degree in an -power law graph.
Definition 2.8 (Multiplicatively Approximate Power Law).
A graph is said to follow an -multiplicatively approximate power law distribution if the number of nodes of degree satisfies
Our lower bounds contain at most four nodes that are one degree away from an exact power-law distribution, and thus hold in all the models discussed above with any reasonable parameter regime. We note a couple of properties of power-law graphs that we use in our lower bounds.
The maximum realizable degree in a power law graph is , since
In terms of , the maximum degree in a power-law graph is .
We work in the setting where . Note that in this setting, the number of edges in the graph is given by
which is linear in the number of nodes for a fixed .
3 Lower Bounds for Dynamic Maximum Matching
In this section, we present our lower bound results for the maximum cardinality matching problem. The previous matching lower bounds on general graphs [16, 11] use reduction graphs that contain nodes with degree . Towards showing a lower bound on expanders, we first sparsify the original reduction.
In Section 3.1, we give a lower bound for maximum matching on graphs with maximum degree . In Section 3.2, we show that the distinction between the unbounded and constant-degree reductions is not discrete, by giving a lower bound reduction parameterized on the maximum degree allowed in the graph. In Section 3.3, we give a reduction graph that has constant expansion. Finally, we show our lower bounds for power-law graphs in Section 3.4.
3.1 Constant-Degree Graph
We first perform a simple reduction that shows that maintaining maximum matchings is hard even on graphs where the maximum degree is . We use the following gadget composed of paths to maintain matching properties in our reduction graph during sparsification—see Figure 1. Our gadget construction starts by replacing each node of a dense reduction by a path; we refer to each path as a ‘subgadget’. Connecting every node of this new subgadget with nodes outside the subgadget might create unwanted matchings of larger sizes, so instead we carefully choose a subset of the path nodes to connect outside the subgadget.
![[Uncaptioned image]](https://cdn.awesomepapers.org/papers/ae692c1e-c660-4b86-8a2f-3be011417ca8/x1.png)
Figure 1 shows odd and even paths (“odd” and “even” describe the number of nodes) with a “canonical” matching for each of them marked in red. Next, we detail the connections outside the subgadgets.
Consider an odd path on vertices, and a bipartition of the vertices into with . Indexing the vertices as and for , our canonical matching matches with , and leaves unmatched. We connect only the vertices outside the subgadget, while vertices in and only have edges inside the subgadget. For an even path on vertices indexed as above, our canonical matching is perfect, and matches to . Only vertex and all the vertices in are connected outside the subgadget, and all vertices , , only have edges within the subgadget.
Definition 3.1 (Reduction gadget).
A reduction gadget with subgadgets of size is a bipartite graph composed of subgraphs, each of which is a path on nodes.
Reduction Graph
The reduction graph is composed of two odd-sized reduction gadgets, and two even-sized reduction gadgets as follows.
-
•
A reduction gadget with one subgadget of size , on a set . The nodes are labelled for , and for , and the path is from to .
-
•
A reduction gadget with subgadgets of size each, on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for depending on whether the node is in or . The path in each subgadget goes from to .
-
•
A copy of the above structure, with node sets marked instead of , respectively.
-
•
For the matrix , add the edge if .
-
•
Given an input vector , for each , add the edge if .
-
•
Given an input vector , for each , add the edge if .
The total number of nodes in the reduction graph is . Note that our reduction graph is bipartite, and thus our lower bounds in this section hold for maintaining an exact maximum matching even on bipartite graphs.
Matchings in the Graph
We start by defining a base matching on the graph, which is made up of the canonical matchings on each of the gadgets. On the left side, matches to , and to for all . The matching on the right side is similar. Note that this matching always exists regardless of the input, and only and are unmatched in the entire graph. Thus . We claim that this graph has a perfect matching if and only if . Let denote the maximum cardinality matching.
Lemma 3.2.
If , then , and otherwise .
Proof 3.3.
Since is always a matching of size regardless of the input, the claim is equivalent to showing that if and only if there is an augmenting path with respect to the matching .
() Suppose that , with . Consider the path composed of the following subpaths, of which all except start with an unmatched edge and end with a matched edge, while both starts and ends with an unmatched edge.
-
•
-
•
-
•
-
•
Thus, is an augmenting path to the base matching , which gives us that the maximum matching has to have size , implying that the maximum matching is a perfect matching.
() Suppose now that there exists an augmenting path to the base matching that starts at and ends at .
-
•
Since is an -cut, there is at least one crossing edge, say , in . Thus = 1.
-
•
Since leaves the subgadget using , it should have entered the subgadget at some previous instance. Since is an unmatched edge and all the matching edges in are within the subgadget, should have entered the subgadget using an unmatched edge. As all the matching edges in are between and , cannot both enter and exit the subgadget through . Thus enters through . However, the only possible unmatched edge from leaving the subgadget is the edge . Thus uses the edge to enter the subgadget , and so .
-
•
The path now enters the subgadget through the unmatched edge . As before, all the matched edges in are between and , and so has to exit the subgadget using an unmatched edge from . However, the only possible unmatched edge from leaving the subgadget is the edge . Thus the edge is used by , giving us that .
This gives us that as required.
Complexity of the Reduction
We are now ready to prove the theorem.
Theorem 3.4.
For any constant , there is no dynamic algorithm maintaining a maximum matching or determining the existence of a perfect matching, on all -node graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
Proof 3.5.
Consider the reduction graph above. It consists of nodes. Every time we get a new input vector pair, we delete all the edges between and and insert edges according to the new input vectors. This takes updates in total. After that, we query once for the size of the maximum matching in this new graph, and return if and only if .
Thus for each pair of input vectors, we perform updates and query. In total, checking pairs takes us updates and query. If there were an algorithm for maximum matching on constant-degree graphs with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
3.2 Varying Degree Graph
We present a reduction that gives a lower bound parameterized on the maximum degree of the graph. Note that setting and in the following theorem give us the unbounded degree lower bound of [16] and Theorem 3.4 respectively.
Theorem 3.6.
For any and any constant , there is no dynamic algorithm maintaining a maximum matching or determining the existence of a perfect matching, on all -node graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
Given , we construct a reduction graph that has maximum degree . and the edges for and are the same as in the previous construction. We now detail the changes for and the edges that depend on .
-
•
is now an even reduction gadget with subgadgets of size each. The path in each subgadget goes from to , and similarly for and .
-
•
For the matrix , if , let and and add the edge to the graph.
Note that the augmenting paths in this reduction graph are the same as in the constant-degree reduction graph by a similar proof as in Lemma 3.9. By construction, each node in is connected to at most nodes in , and each node in is connected to at most nodes in . The proof of the theorem is similar to the proof of Theorem 3.4.
Proof 3.7.
The number of nodes in the reduction graph described in Section 3.2 is dominated by the number of nodes in and . Thus the total number of nodes in the reduction graph is nodes. Each node in and has at most edges of incident on it by a similar argument as in the proof of Theorem 4.9. Thus the maximum degree in the graph is as required. The rest is similar to Theorem 3.4.
Every time we get a new input vector pair, we delete all the edges between and and insert edges according to the new input. Thus, for each pair of input vectors, we perform updates and queries. In total, checking pairs takes us updates and queries. If there were an algorithm for maximum matching on graphs with maximum degree bounded by with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
3.3 Expander Graph
The previous matching lower bounds on general graphs [16, 11] use reduction graphs that contain nodes with degree . In this section, we construct a constant-degree reduction graph with constant expansion.
Reduction gadgets
While the reduction gadgets in Section 3.1 suffice for sparsification, we need additional constructions in order to guarantee constant expansion. In particular, it turns out that adding edges inside a subgadget does not suffice for constant expansion, and we are forced to add edges between subgadgets. Our construction adds edges on the same side of the bipartition across subgadgets, and our proof implicitly shows that if the newly added edges take part in any augmenting path, then there also exists an augmenting path in the subgraph devoid of any newly inserted edge.
The reduction graph consists of a left subgraph () and a right subgraph (), connected together by edges corresponding to the matrix . Note that for constant expansion, we need the number of edges of to be a constant fraction of the sizes of and . While it would be possible to construct a reduction graph with and that depend on the input matrix , we instead choose to augment the input matrix and vectors as it simplifies notation. We thus augment the input beforehand to ensure that there are edges crossing from to . To this end, we work with the vectors and of dimension , and the matrix of dimension . It is easy to see that .
Definition 3.8 (Reinforced gadget).
A reinforced gadget with subgadgets of size consists of subgraphs, each of which is a path on nodes. The nodes are bipartitioned into sets with the larger side of the partition labelled as in each subgadget. Thus . It is then augmented with the following edge-set: Consider a degree- expander graph on nodes, choose an arbitrary bijection between the expander nodes and , and add the expander edges to these nodes accordingly. The resulting graph is the reinforced gadget.
Note that reinforced gadgets are not bipartite. Thus, while the constant-degree lower bounds hold for bipartite matching, the expander result is for maximum matching on general graphs. In what follows, we drop the hats from and for simplicity, but continue our analysis with their dimensions as respectively.
Reduction Graph
We use the following reduction graph, composed of two odd-sized reinforced gadgets and two even-sized reinforced gadgets.
-
•
A reinforced gadget with one subgadget of size , on a set . The nodes are labelled for , and for . The path is from to , and the expander is on .
-
•
A reinforced gadget with subgadgets of size , on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for depending on whether the node is in or . The path in each subgadget goes from to , and the expander is on .
-
•
A copy of the above structure, with node sets marked instead of , respectively.
-
•
For the matrix , add the edge if .
-
•
Given an input vector , for each , add the edge if , and otherwise.
-
•
Given an input vector , for each , add the edge if , and add the edge otherwise.
The total number of nodes in the reduction graph is .

Matchings in the Graph
Our base matching is similar to the constant-degree case, and is made up of the canonical matchings on each of the gadgets. On the left side, matches to , and to for all . The matching on the right side is similar. Note that this matching always exists regardless of the input, and only and are unmatched in the entire graph. Thus . We claim that this graph has a perfect matching if and only if . Let denote the maximum cardinality matching.
Lemma 3.9.
If , then , and otherwise .
Complexity of the Reduction
On the arrival of a new vector pair, we first add all the edges corresponding to the new input (if they do not already exist), and then remove the previous vector pair’s edges, as opposed to the usual convention of first deleting the previous edges and inserting the new ones. This ensures that the graph remains an expander at all steps. Assuming that we have proved the expansion properties required, since number of edges in a constant-degree graph is , we get the following theorem for expanders.
Theorem 3.10.
For any constant , there is no dynamic algorithm maintaining a maximum matching or determining the existence of a perfect matching, on all -node graphs with constant degree and constant expansion, with amortized update time and query time, unless the OMv conjecture is false.
Proof 3.11.
Consider the reduction graph above. It consists of nodes. Every time we get a new input vector pair, we update and as detailed above. This takes updates in total. After that, we query once for the size of the maximum matching in this new graph, and return if and only if .
Thus for each pair of input vectors, we perform updates and query. In total, checking vector pairs takes us updates and query. If there were an algorithm for maximum matching on constant-degree graphs with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
Let us now show that the graph described is indeed an -expander graph, for some constant .
Lemma 3.12.
The reduction graph has constant expansion.
Throughout the rest of this section, let be an arbitrary subset of vertices in the reduction graph, with . To simplify our proofs, we consider the reduction graphs with , since then . We use “ expands” as a shorthand for for some constant .
Note that the node sets in the graph have the following sizes: ; ; , and . We divide the expansion proof into two sections based on whether its intersection with the middle layers ( or ) is large or small.
We first deal with the case when the intersection is large.
Lemma 3.13.
If or , then expands.
We encapsulate the proof ideas for this lemma in Table 3, and split the proof into three lemmas for convenience. First, we show that if its intersection with both the middle layers is very large, then expands. Our proof uses the canonical matching on .
Sizes | Proof ideas | Proof |
---|---|---|
Use the perfect matching on | Lemma 3.14 | |
Use the expander on | Lemma 3.16 | |
Use the edges of matrix | Lemma 3.18 |
Lemma 3.14.
If and , then expands.
Proof 3.15.
The two conditions together imply that . Thus
(by the canonical matching) | ||||
(since for all ) | ||||
(by upper bound on ) |
which proves our claim.
Next, we show that if the intersection with one of the middle layers is of medium size, then expands. We prove this by using the fact that there is an -expander on the middle layers.
Lemma 3.16.
If , then expands.
Proof 3.17.
Let be the smaller of the two sets and , then . Thus
(by definition of ) | ||||
(by expansion) | ||||
(by constraint on ) | ||||
(by upper bound on ) |
which proves our claim.
The above observation also holds when the size of is in the same range, using the expander on . Finally, we show that if one of the intersections is large and the other is small, then expands. We use the edges of the matrix to do this.
Lemma 3.18.
If and , then expands.
Proof 3.19.
Recall that our reduction graph has edges crossing from to . Thus
(by constraint on ) | ||||
(by construction) | ||||
(by constraint on ) | ||||
(by upper bound on ) |
which proves our claim.
A symmetric argument works by swapping and in the above proof. Lemmas 3.14, 3.16, and 3.18 together prove Lemma 3.13. We are left with the case when the intersection of with both the middle layers is small.
Lemma 3.20.
If and , then expands.
In this case, we show that the intersection of with the left side () and the right side () of the graph expand within their respective sides. This then proves expansion of , since
(by expansion within each side) | ||||
We now concentrate on proving the expansion of in , since the right side expansion follows by similar arguments.
Sizes | Proof ideas | Proof |
---|---|---|
Use the perfect matching on | Lemma 3.21 | |
Use the expander on | Lemma 3.23 |
Lemma 3.21.
If and , then expands.
Proof 3.22.
First, we lower bound the number of crossing edges by .
(by the canonical matching) | ||||
(by constraint on ) |
Then we lower bound by , which proves our claim. The final inequality uses the constraint that .
(by constraint on ) | ||||
(using ) |
as required.
Lemma 3.23.
If and , then expands.
Proof 3.24.
Recall that we are working in the case when .
(by expansion) |
Lower bounding by similar to Lemma 3.21 gives us the claim.
Now we are only left with the case when and . In what follows, we use the bound below on .
(by bound on ) | ||||
(by constraint on ) |
Sizes | Proof ideas | Proof |
---|---|---|
Use the edges of | Lemma 3.25 | |
Use the canonical matching on | Lemma 3.27 | |
Use the gadget expansion | Lemma 3.30 |
Lemma 3.25.
If , then expands.
Proof 3.26.
We use the fact that there is an edge from to regardless of the value of .
(by edges of ) | ||||
(by constraint on ) | ||||
(by constraint on ) |
which proves our claim.
Lemma 3.27.
If and , then expands.
Proof 3.28.
We use the matching on , as follows
(by the canonical matching on ) | ||||
(by constraint on and ) | ||||
(by constraint on ) |
which proves our claim.
For the final case, we will need the following lemma about each reinforced gadget being an expander.
Lemma 3.29.
A reinforced gadget has constant expansion.
We use this lemma as follows.
Lemma 3.30.
If and , then expands.
Proof 3.31.
In this case, we reason about and separately. Since the intersection of with each reinforced gadget covers less than half the nodes, i.e.,
we use the expansion of each reduction gadget from Lemma 3.29 to get
giving the expansion of as required.
Lemmas 3.21–3.30 together prove Lemma 3.20. Lemmas 3.13 and 3.20 together show Lemma 3.12. All that is left is to prove Lemma 3.29, which we do below.
See 3.29
Proof 3.32.
Let be a reinforced gadget, with the -expander on . Let be a subset of nodes of size . The proof of expansion follows in similar lines as before.
If the intersection with is large, then we use the matching edges (similar to Lemma 3.14). Concretely, if , then since and , we get that . Thus
(by the matching on ) | ||||
(by constraint on ) | ||||
(by constraint on ) | ||||
(since and ) |
If the intersection with is of medium size, then we use the expander on (similar to Lemma 3.16). Concretely, if , then let be the smaller of the two sets and . Then
(by definition of ) | ||||
(by expansion) | ||||
(by constraint on ) | ||||
(since ) |
We are left with the case when the intersection with is small, namely, . If , then we use the matching edges again.
(by the matching on ) | ||||
(by constraint on ) |
which leaves us with the final case when . Here, we use the expander on
(by expansion) | ||||
(by constraint on ) |
which shows that the reinforced gadget has constant expansion.
3.4 Power-law Graph
We first make the reduction graph robust with respect to degree changes. We use the following static graph in our reduction.
-
•
A reduction gadget with one subgadget of size , on a set as earlier.
-
•
A reduction gadget with subgadgets of size , on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for depending on whether the node is in or . The path in each subgadget goes from to .
-
•
A copy of the above structure, with node sets marked instead of .
-
•
If , then add the edges and .
-
•
If , then add the edges and .
-
•
The edges for an input pair of vectors will be detailed later.
Layer | Deg | Deg | Deg |
---|---|---|---|
The degree distribution for each layer on the left side of the reduction gadget in the current instance, before adding any edges for , is given in Table 6. For ease of notation, let us use to denote that there are nodes of degree in the graph. Thus the degree distribution in the entire reduction graph is as follows: . Some of the nodes will change their degree when we add edges for the input vector pair , and we take care of these changes later.
Let be the exponent for which we want to show our lower bound, and be the number of nodes we need in our reduction graph. First, choose such that
and pick any power-law graph on nodes. If is the number of nodes of degree in , then by construction we get that .
We would like to essentially embed our reduction graph into this power-law graph. For this, we would like to reduce by exactly for , which would allow us to embed our graph into . In what follows, we use the fact that . We “make space” for our nodes as follows.
-
•
Do the following times: Pick a node of degree . Let be its neighbour. Since and there are nodes of degree in , there exists a node of degree such that has a neighbour with . Delete the edges and add the edge . This gives us a node which we can assign degree to, in our reduction graph. We have also converted a degree node to a degree node, which we take care of in the next step.
-
•
Do the following times: Pick a node of degree . Let be its neighbours. Since , and there are nodes of degree left in , there exists a node of degree that has neighbours , with . Remove the edges , and add the edge . This gives us two nodes which we can assign degree to, in our reduction graph.
-
•
Similarly, free up nodes of degree for our reduction graph.
Note that we will have at most one extra node of each degree which we can leave unused because of the slack allowed in approximate power-law graphs.
We can now embed our reduction graph into a power-law graph with at most two nodes having different degrees, since there are an even number of nodes of degree in our reduction graph by parity, and we requisitioned degree nodes one-by-one and not in pairs. Thus, in particular, we are at most one degree node and one degree node away from a perfect power law graph.
We now come to the question of the input vectors . If , then we add the edge . Note that this changes the degree distribution in the following way: One degree node increases to degree , and a degree node increases to degree . We need to adjust for this in the power law graph, while making sure that the size of the maximum matching in the remaining graph is still known. We do this as follows:
During preprocessing, pick disjoint pairs of nodes in the graph such that and , such that with . is the graph . Let be the graph with the edges deleted and the edges added for all . Since preprocessing is allowed in the OMv conjecture, we can afford to find the sizes of the maximum matchings in all the graphs before we receive any input. Denote the sizes of these matchings as , .
On input , we do the following:
-
•
If , then add the edge .
-
•
If , then add the edge .
-
•
Let . Delete the edges and add the edges for all .
Now we ask for the size of the maximum matching in this graph. Let be the subgraph of which is the reduction graph, and let be the number of nodes in . Note that we already know the size of the maximum matching in to be . if and only if a maximum matching restricted to is perfect, and since is disjoint from , if and only if the maximum matching on is of size . We then roll back the graph to its previous state and process the new input vector pair.
We make updates and queries for each input pair, and the graph consists of nodes, which gives us the same lower bounds as in the constant-degree reduction.
4 Lower Bounds for Dynamic -Shortest Path
In this section, we present our lower bound results for the dynamic -shortest path problem. In Section 4.1, we give a lower bound for dynamic -distance on graphs with maximum degree . We extend this lower bound to -approximations in Section 4.2. In Section 4.3, we show that the distinction between the unbounded and constant-degree reductions is not discrete, by giving a lower bound reduction parameterized on the maximum degree allowed in the graph. In Section 4.4, we show that the lower bound on constant-degree graphs holds even on expanders, by constructing a more involved reduction graph. Finally, we prove the power-law graph lower bounds in Section 4.5.
4.1 Constant-Degree Graph
Consider the OuMv problem on vectors of length and an matrix. We first perform a simple reduction that shows that maintaining -distance is hard even on graphs where the maximum degree is .
Theorem 4.1.
For any constant , there is no dynamic algorithm maintaining -distance, SSSP or APSP, on all -node bipartite graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
Since the original reduction [16] could possibly have unbounded degree, we use binary forests to sparsify our reduction graph.
Definition 4.2 (Binary Forest).
A binary forest of trees of height is a graph composed of disjoint binary trees, each of height .
We naturally split the nodes of a binary forest between internal nodes and leaves. Intuitively, we would like to replace a high degree node of the original reduction with a binary forest to moderate the maximum allowed degree. Note that a binary forest has leaves in total.
4.1.1 Static Graph
We use the following static graph as the base for our reduction:
-
•
A -depth binary forest with a single tree. The set of internal nodes is marked ( for left) and the leaves ; the root of the tree is the source node , and the nodes of are marked as for .
-
•
A -depth binary forest with trees. The internal nodes are marked and the leaves . The roots of each of the trees are marked as , for , and the leaves of the tree with root are marked , for .
-
•
A copy of the above structure, with node sets marked instead of , respectively. The root of the single tree of is the target node .
-
•
Edges from to by the matrix , as detailed next.
-
•
For an input pair of vectors , edges between and by , and between and by , as detailed next.
The total number of nodes in the reduction graph is .
4.1.2 Input-Dependent Edges
We add the following edges depending on the input matrix and vectors :
-
•
For the matrix , add the edge if .
-
•
Given an input vector , for each , add the edge if .
-
•
Given an input vector , for each , add the edge if .
4.1.3 Distances in the Graph
We now show the correctness of the reduction, by considering the distance in different scenarios.
Lemma 4.3.
[constant-degree reduction] if and only if . Moreover, the graph is bipartite.
Proof 4.4.
We first show that any path from to has to be of length at least , by partitioning the node set into layers. We maintain the property that a node at level can have neighbours only in levels , , or . The layering is as follows: The layer of a node in is its distance from ; in is its distance from its closest root, plus ; in is its distance from its closest leaf, plus ; in is its distance from its closest leaf, plus . Specifically, the layer of node is . Thus , regardless of , , and . Moreover, the the fact that edges only connects consecutive layers implies that the graph is bipartite.
() If , then there exists indices such that . Then consider the path composed of the following sub-paths:
-
•
is the shortest path from to , which follows the tree and then the edge ( edges).
-
•
is the shortest path from to , which follows the tree rooted at and then the edge ( edges).
-
•
is the shortest path from to , which follows the tree rooted at and then the edge ( edges).
-
•
is the shortest path from to , which follows the tree ( edges).
is then a path of length from to .
() Assume that there is a path of length from to . By the layering, each edge in the path must connect a layer node and a layer node, and there is exactly one such edge in the path for each . Next, we use these two facts (sometimes implicitly) to show that the path must have the form of the above described path, and conclude that .
The path must contain an edge from to . The only such edges are of the form for some , implying . From there, the path must continue to some leaf of the tree rooted at . Since the only edge from that strictly increases in level is the edge , the path must contain such an edge, implying for some . From , the path must continue to the root , and then to over an edge , implying . The path ends trivially by going from to the root . Thus .
4.1.4 Complexity of the Reduction
We are now ready to prove the theorem.
See 4.1
Proof 4.5.
Consider the reduction graph above, which is bipartite by Lemma 4.3. It consists of nodes. Every time we get a new input vector pair, we delete all the edges between and and insert edges according to the new input vectors. This takes updates in total. After that, we query once for the -distance in this new graph, and return if and only if .
Thus for each pair of input vectors, we perform updates and query. In total, checking pairs takes us updates and query. If there were an algorithm for -distance on constant-degree graphs with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
4.2 -Approximation Lower Bound for Constant-Degree Graphs
We show that the above lower bounds on -distances also holds for -approx -distances by minimally modifying the reduction graph to exploit the following observation: If , then every path from to in the simple reduction graph needs to take at least three edges corresponding to the matrix , as opposed to just one such edge when .
We use the same reduction graph as before, but with one important difference: Earlier, we added a single edge if . Now, we add a path with new nodes between and . Note that since we only do this for and not for every new input vector pair, we can do this in just polynomial pre-processing time, which is allowed for in the OMv conjecture.
Formally, let . Add new nodes to the reduction graph, with the nodes labelled for and . If , add the path , to the reduction graph, while otherwise all the nodes remain disconnected.
The following lemma is an analogue of Lemma 4.3, and the proof follows from the proof of Lemma 4.3 and the above observation.
Lemma 4.6.
If , then , and otherwise . Moreover, the graph is bipartite.
Corollary 4.7.
For any constant , there is no dynamic algorithm maintaining -approximate -distance, SSSP or APSP, on all -node bipartite graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
Proof 4.8.
From Lemma 4.6, we get that any approximate reported distance where would imply that . Note that
(1) | ||||
(2) |
where Equation 1 follows from the fact that , and Equation 2 follows from the definition of . Thus any -approx algorithm would be able to distinguish between and .
The number of nodes in the reduction graph is . Thus for each pair of input vectors, we perform updates and queries. In total, checking pairs takes us updates and queries. If there were an algorithm for -approx -distance on constant-degree graphs with update time and query time , then we can decide if for all pairs in time for some constant , contradicting the OMv conjecture.
4.3 Varying-Degree Graph
We present a reduction that gives a lower bound parameterized on the maximum degree in the graph.
Theorem 4.9.
For any and any constant , there is no dynamic algorithm maintaining -distance, SSSP or APSP, on all -node bipartite graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
The reduction graph
For a value (that may depend on ), we construct a reduction graph on nodes that has maximum degree . The node sets and the edges that depend on and are the same as in the previous construction in Section 4.1. We detail the changes for and below.
-
•
A -depth binary forest with trees. The internal nodes are marked and the leaves are marked . The roots of each of the trees are marked as , for , and the leaves of the tree with root are marked , for , and similarly for and .
-
•
For the matrix , if , let and . Add the edge to the graph.
Note that the distances in this reduction graph are the same as in the constant-degree reduction graph by a similar proof as used to prove Lemma 4.3. Furthermore, each node in is connected to at most nodes in , and each node in is connected to at most nodes in .
We can now prove Theorem 4.9.
Proof 4.10.
The number of nodes in the reduction graph above is dominated by the number of nodes in and . Thus, the total number of nodes in the reduction graph is nodes. Since each node not in or have at most edges adjacent on it, its degree is trivially . Every node in and has one tree edge incident on it, and at most edges of incident on it by construction. Thus the maximum degree in the graph is as claimed. The rest is similar to Theorem 4.1. Every time we get a new input vector pair, we delete all the edges between and and insert edges according to the new input vectors.
For each pair of input vectors, we thus perform updates and queries. In total, checking pairs takes updates and queries. If there was an algorithm for -distance on graphs with maximum degree bounded by with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
4.4 Expander Graph
For our expander lower bound, we use the following gadgets, called reinforced forests.
Definition 4.11 (Reinforced forest).
A reinforced forest of trees of height is a graph composed of disjoint binary trees, each of them of height . These trees have leaves in total; consider a degree- expander graph on nodes, choose an arbitrary bijection between the expander nodes and the forest’s leaves, and add the expander edges to the leaves accordingly. Finally, in order to guarantee that the graph is bipartite, on each edge added from the expander, we add a dummy node. The resulting graph is the reinforced forest.
![[Uncaptioned image]](https://cdn.awesomepapers.org/papers/ae692c1e-c660-4b86-8a2f-3be011417ca8/reinforced-forest.png)
We naturally split the nodes of a reinforced forest between internal nodes and leaves.
Reduction Graph

We use the following graph as the base for our reduction (see Figure 3).
-
•
A -depth reinforced forest with a single tree. The set of internal nodes is marked and the leaves ; the root of the tree is the source node , and the nodes of are marked as for .
-
•
A -depth reinforced forest with trees. The internal nodes are marked and the leaves . We split this reinforced forest into sets of trees each, and label them (upper, middle, and lower). The roots of each of the trees are marked as , for , , and the leaves of the tree with root are marked , for .
-
•
A copy of the above structure, with node sets marked instead of , respectively. The root of the single tree of is the target node .
-
•
For the matrix , add the edge if , and add the edges and otherwise.
-
•
Given an input vector , for each , add the edge if , and otherwise.
-
•
Given an input vector , for each , add the edge if , and otherwise.
The following lemma characterizes -distance in the expander reduction graph based on the value of . We split the graph nodes into layers (indicated at the bottom of Figure 3) and use the fact that edges can only connect consecutive layers in order to prove this lemma in Section 4.4.1.
Lemma 4.12.
if and only if . Moreover, the graph is bipartite.
The number of nodes in the reduction graph is dominated by the nodes in , yielding the same asymptotic lower bounds as in the constant-degree case (Section 4.1). When a vector pair arrives, we first add all the potential edges and then remove the unnecessary ones, in a similar fashion as before, to preserve expansion. We defer the proof of expansion to Section 4.4.2. Thus, we get the following theorem for expander graphs.
Theorem 4.13.
For any constant , there is no dynamic algorithm maintaining -distance, SSSP or APSP, on all -node constant-degree bipartite graphs with constant expansion, with amortized update time and query time, unless the OMv conjecture is false.
4.4.1 Distances in the expander graph
We prove the following lemma for the expander reduction graph described in Section 4.4. This is basically the graph described in Section 4.1, with expander edges added in carefully chosen places, and one dummy node added on each such edge. Note that adding the dummy nodes does not change the expansion by more than a constant factor, does not not affect the asymptotic number of nodes, and the shortest paths never use the expander edges and thus the also stay unaffected by the dummy nodes addition. To simplify the writing, we thus ignore the dummy nodes in the following. See 4.12
Proof 4.14.
The proof uses the same ideas and layering as in the proof of Lemma 4.3. We include the dummy nodes of and in one layer before their (non-dummy) neighbors, and the other dummy nodes in one layer after their neighbors. This already shows that the graph is bipartite.
() This direction of the proof is the same as in the proof of Lemma 4.3, since we only add edges, and the same path as earlier still exists in the graph.
() We still make use of the layering argument for this direction, but the argument is slightly more nuanced than the one for the constant-degree case. Assume that there is a path of length from to . By the layering, each edge in the path must connect a layer node and a layer node, and there is exactly one such edge in the path for each . Next, we use these two facts (sometimes implicitly) to show that the path must have the form of the above described path, and conclude that .
-
•
The path must contain an edge from to . Suppose the edge was to a node in . Since no node in has an edge to , the path does not always connect two nodes of strictly increasing layers, contradicting the claimed length. Thus the edge is of the form for some , implying that .
-
•
From there, the path must continue to some leaf of the tree rooted at . Suppose the path continues to instead of . Since there are no edges from to , the path would have to connect two of the non-increasing at least once, which cannot happen on a length path. Thus the path uses the edge , implying that .
-
•
From , the path must continue to the root , and then to by using the edge , implying .
We have established that there exist indices such that , implying .
4.4.2 Expansion of the expander graph
Let us now verify that the graph is indeed an -expander graph, for some constant . Recall that the reinforced forests contain expanders, for some constant .
While a similar proof as in the maximum matching expander reduction works for this setting as well, we take a different approach here. Consider a reinforced forest with a set of internal nodes, a set of leaves, and an -expander on the leaves. Let be a set of nodes in the forest (we do not bound ).
Let , that may depend on . If , then . {claimproof} Consider first the case , in which the expander graph edges on guarantee , implying . Otherwise, apply the analogous argument on the set .
. {claimproof} Every node in is a tree node that has two children. In total, these node has edges going to children, of which at most children are in . Hence, .
Let constant. If then . {claimproof} If , consider the parent nodes of the leaves in : these have at least distinct parents, of which at most are in , and the others are in . Hence .
The proof of the following lemma is similar to that of Lemma 3.29.
Lemma 4.15.
A reinforced forest is an expander.
Proof 4.16.
Fix a set of nodes in the forest, . We consider different ranges of , and show that for each of them, for some constant .
-
1.
If , the inequalities and imply , and hence . Observation 4.4.2 implies .
-
2.
If , then by Observation 4.4.2 we have . Since and , the above implies .
-
3.
If , then
-
(a)
If , add to both sides of the inequality and multiply by to get . By Observation 4.4.2, .
-
(b)
If then . The expander edges on guarantee that .
-
(a)
Lemma 4.17.
The reduction graph is an expander.
Proof 4.18.
Consider a set of nodes. Note that the node sets in the graph have the following sizes: ; ; ; . We show that there exists a constant such that , by considering different ranges for the set size (which ranges in ). In most cases, we show that for some constant , which is enough since .
-
1.
If , then consider following sub-cases.
-
(a)
If , then since , we have , which implies . By Observation 4.4.2, .
-
(b)
If , the expander edges on (Observation 4.4.2 with ) guarantee .
-
(c)
If , note that there are edges in , of which at most are in (since is large), at most are in (since is small), and the remaining edges, at least of them, are in .
-
(a)
-
2.
If , then as in case 1(b), the expander edges on (Observation 4.4.2 with ) guarantee .
-
3.
If , consider the following sub-cases.
-
(a)
If , we are in a case symmetric to case 1(c): of the edges in , at most are in (since is small), at most are in (since is large), and the remaining edges, at least edges, are in .
-
(b)
If , again the expander edges on (Observation 4.4.2 with ) guarantee .
-
(c)
In the last case, namely , we are bound to analyze the subgraphs on and on separately. We will show that there is a constant such that and , which implies , as desired.
-
(a)
4.5 Power-law Graph
As in the case of maximum matching, we first make our reduction graph robust to degree changes. The following reduction is close in spirit to the expander graph reduction. The graph is as follows:
-
•
A -depth binary forest with a single tree, labelled as before, with as the root of the tree.
-
•
A -depth binary forest with trees, labelled . We split this binary forest into sets of trees each, and label them (upper, middle, and lower). The roots of each of the trees are marked as , for , , and the leaves of the tree with root are marked , for .
-
•
A copy of the above structure, with node sets marked instead of , respectively. The root of the single tree of is the target node .
-
•
For the matrix , add the edges and if , and add the edges and otherwise.
-
•
Given an input vector , for each , add the edge if , and otherwise.
-
•
Given an input vector , for each , add the edge if , and otherwise.
Note that this fixes the degree distribution present in the graph regardless of the input , unlike in the case of maximum matching where we needed to compensate for the degrees elsewhere in the graph. Table 7 shows the degree distribution on the left side of the reduction graph, regardless of the input bits.
Layer | Deg | Deg | Deg |
---|---|---|---|
Thus the degree distribution in the entire reduction graph is as follows: . As earlier, choose such that
and pick any power-law graph on nodes. We reduce the count of degree and nodes in the graph as earlier, and embed our reduction graph using these nodes. Unlike in the case of matchings, note that the -distance is not affected by the rest of the graph, and thus if and only if .
5 Lower Bounds for Dynamic Densest Subgraph
For a constant , we work with -regular graphs of two different sizes: -node gadget for each vector entry, and -node gadget for each matrix entry.
Definition 5.1 (Vector and Matrix Gadgets).
A vector gadget is a -edge connected -regular graph on nodes. A matrix gadget is a -edge connected -regular graph on nodes with one edge removed
A -edge connected graph is a graph that does not disconnect after the removal of any edges. Such a -regular graph is, e.g., a -dimensional torus, or a union of edge-disjoint cycles, each going through all the nodes. Note that the density of a vector gadget is , and the density of a matrix gadget is . We prove the following theorems for maintaining densest subgraphs.
Theorem 5.2.
For any constant , there is no dynamic algorithm maintaining an exact densest subgraph, on all -node graphs with maximum degree , with amortized update time and query time, unless the OMv conjecture is false.
Theorem 5.3.
For any constant , there is no dynamic algorithm maintaining an exact densest subgraph, on all -node graphs with constant degree and constant expansion, with amortized update time and query time, unless the OMv conjecture is false.
5.1 Constant-Degree Graph
5.1.1 The static graph
The reduction graph is composed of vector gadgets, and matrix gadgets as follows.
-
•
vector gadgets labelled resp. , for . The nodes in each gadget are labelled resp. , for .
-
•
matrix gadgets labelled , for . The missing edge in the gadget is between the two nodes labelled and .
-
•
An edge from to , and an edge from to for all . Note that this implies that every node of has degree and that the total number of edges incident to at least one node of is .
The total number of nodes in the reduction graph is .
5.1.2 Input-dependent edges
The above graph is adapted to the specific input instance as follows.
-
•
For the matrix , remove one arbitrary edge from the matrix gadget if .
-
•
Given an input vector , for each , remove two arbitrary edges from the vector gadget if .
-
•
Given an input vector , for each , remove two arbitrary edges from the vector gadget if .
5.1.3 Densest subgraphs in the graph
We use the following simple lemma in our density proof.
Lemma 5.4.
[16] For all numbers and , we have:
-
1.
If and , then .
-
2.
If and , then .
Let be the density of the densest subgraph in the current graph.
Lemma 5.5.
If , then , and otherwise .
Proof 5.6.
() First assume that . Then there are indices such that . Consider the subgraph . It consists of nodes and edges. Thus .
() Now assume that , and that there exists some subset with . We first claim that we can modify in a particular manner without loss of generality, and then derive a contradiction. Specifically, first we remove from all subgraphs that are not completely contained in .
Claim 1.
Let be a subgraph of a matrix gadget that is not the whole gadget. Then, after removing from , it still holds that .
Recall that every node in has degree at most . Let . It follows that there are at most edges incident to a node of in : If neither nor belong to then there are most edges incident to at least on node of in (all being edges between nodes of ), as at least one node of must have an edge to a node to the rest of that does not belong to . If either or , but not both belong to then there are at most edges incident to two nodes of and there is one edge between and the rest of . If both and belong to then there are at most edges incident to two nodes of (as there is no edge between and ) and there are two edges between and the rest of .
Thus the removal of from removes at most edges and nodes and, hence by Part 2 of Lemma 5.4, has density .
Next we remove all subgraphs such that .
Claim 2.
For all , if the bit and is fully contained in , then after removing the corresponding subgraph from , we still have .
As , there are edges incident to at least one node of . Thus, removing from removes nodes and at most edges from , i.e., a subgraph of density at most . By Part 2 of Lemma 5.4, has density .
Finally we add to every vector subgraph that is partially contained in .
Claim 3.
For all , after we add any partially contained subgraph or to it still holds that .
We only prove our claim for the gadget , since the proof for the gadget is analogous. Suppose some subset is contained in with . We will show that adding to adds at least edges. As , the claim follows from Part 1 of Lemma 5.4.
We are left with showing that adding to adds at least edges. Recall that is a -regular 6-edge connected graph with nodes from which 2 edges where removed if and no edges where removed if . We consider the following cases:
Case 1: or no removed edge is incident to a node in . In this case every node in has degree in . Let be the number of edges between and , and note that since is 6-edge connected. Thus, the sum of the degrees of the nodes in is . It follows that there are edges between nodes of . Thus, the total number of edges incident to nodes of in is and this is a lower bound of the number of edges that are added to when is added.
Case 2: and removed edges belong to and removed edges have both endpoints in with . As only 2 edges are removed, . As is 6-edge connected, let be the number of edges between and . In this case the sum of the degrees of the nodes of in is . Thus, the total number of edges incident to nodes of in is . Hence, the total number of edges incident to nodes of in is As this is at least . Since , it follows that at least edges are added to when is added.
Thus has the following structure: It has some matrix gadgets of set bits with all the nodes and both outgoing edges present, and it has some vector gadgets of set or unset bits with all nodes present as well. Let denote the number of matrix gadgets of set bits contained in , denote the number of vector gadgets of set bits in , and denote the number of vector gadgets of unset bits in . We now consider two cases:
Case 1: . Then consists only of matrix gadgets and no vector gadgets. Thus , which is a contradiction
Case 2: . Then the density of is given by
We claimed that , which is the same
Since , for every matrix gadget of a set bit, either the corresponding or must be unset. Thus we assign at most matrix gadgets to each unset vector gadget, giving us that , giving
which is a contradiction as desired since .
5.1.4 Complexity of the reduction
We are now ready to prove the theorem.
See 5.2
Proof 5.7.
Consider the reduction graph above with . It consists of nodes. Every time we get a new input vector pair, we reinsert all the removed edges in the vector gadgets , for all , and then delete edges according to the new input vectors. This takes updates in total. After that, we query once for the density of the densest subgraph in this new graph, and return if and only if .
Thus for each pair of input vectors, we perform updates and query. In total, checking pairs takes us updates and query. If there were an algorithm for maintaining the density of the densest subgraph on constant-degree graphs with update time (i.e., ) and query time (i.e., ), then we can decide if for all pairs in time, contradicting the OMv conjecture.
5.2 Expander Graph
The extension required to make the reduction hold even for expanders for the densest subgraph problem is simpler than the corresponding extensions for the previous problems. Pick such that there is a -regular expander for some . The static graph is constructed as follows.
-
•
The reduction graph from Section 5.1.1 as a subgraph together with the input-dependent edges from Section 5.1.2.
-
•
A -regular expander graph on nodes, for some , with constant expansion , together with a bijection from the nodes of to the .
-
•
An edge between every node of and the node of , giving a perfect matching connecting the nodes of with these of .
The total number of nodes in the reduction graph is .
The density arguments in this reduction graph are similar to the one in the constant-degree case, as in Lemma 5.5. The proof follows from the following fact: for any subset with density , removing all of the nodes of from cannot decrease the density of , since each node in has degree at most in . Thus, in the proof of Lemma 5.5 in the setting where , we add a first step removing all the nodes of from the subset and then proceed as before. This leads to the same lower bounds as in the constant-degree case. We have the following theorem for expander graphs:
See 5.3
To verify that the graph is indeed an -expander graph for some constant , we follow a similar pattern as in the proof of expansion for maximum matching in Section 3.3. Consider a reduction graph with , where is the node set of the expander . Let be some set of nodes (we do not bound ). We have the following observations. {observation} Let , that may depend on . If , then . {claimproof} Consider first the case , in which the expander graph edges on guarantee , implying . Otherwise, apply the analogous argument on the set .
. {claimproof} Every node in has a matching partner (by the bijection used to map the nodes of to ) in . In total, each of these nodes has edges going to their matching partners, of which at most partners are in . Hence, .
Let constant. If then . {claimproof} If , consider the matching partners of the nodes in : there are at least such partners in , of which at most are in , and the others are in . Hence .
Lemma 5.8.
The reduction graph is an expander.
Proof 5.9.
Now fix a set of nodes, with . We consider different ranges of , and show that for each of them, for some constant .
-
1.
If , the inequalities and imply , and hence . Observation 5.2 implies .
-
2.
If , then by Observation 5.2 we have . Since and , the above implies .
-
3.
If , then
-
(a)
If , add to both sides of the inequality and multiply by to get . By Observation 5.2, .
-
(b)
If then . The expander edges on guarantee that .
-
(a)
5.3 Power-law Graph
Let . We show our densest subgraph lower bounds for . We use a reduction graph similar to the one in the constant-degree case for our reduction. Our reduction graph consists of the vector and matrix gadgets as before, along with new nodes we introduce to moderate the degree. We add a cycle on four new nodes for each vector gadget, and a cycle on four new nodes for each matrix gadget.
-
•
vector gadgets labelled resp. , for . The nodes in each gadget are labelled resp. , for .
-
•
cycles and on nodes each, with the nodes labelled for ,
-
•
matrix gadgets labelled , for . The missing edge in the gadget is between the two nodes labelled and .
-
•
cycles on four nodes for each.
-
•
An edge from to , and an edge from to for all .
-
•
If , remove two arbitrary edges, say, , and the edges , and add the edges for to the graph.
-
•
Given an input vector , for each , do the following if . Remove two arbitrary edges from the vector gadget , say , and also remove the edges . Add the edges for . Similarly for an input vector .
Note that each node in a vector gadget always has degree , and each node in a matrix gadget has degree , regardless of input. Further, the degrees of the nodes in all the cycles are exactly for all inputs. The degree distribution of the reduction graph is . Choose such that
In a power-law graph with nodes, the sum of degrees of all nodes is given by , while the number of nodes of degree is . Thus for all such that , more than half the total degree comes from nodes of degree , since
(3) |
This is true in particular for all . Thus now we first construct the reduction graph as above on nodes, and this does not exceed for any because of the definition of . Now for every other degree that needs to be satisfied of degree , we simply add a new node and create a star with nodes of degree attached to it. Note that we can do this for all the remaining nodes because of Equation 3. If there are any remaining degree requirements to be satisfied, we simply add a perfect matching on that many nodes.
None of the stars or the perfect matchings can be part of a subgraph of density , since they all have density . Thus any subgraph of density must be from our reduction graph. Further, note that the cycle gadgets can be removed from any subgraph of density , since they have degree exactly . Thus if and only if , which proves our claim.
References
- [1] Amir Abboud and Søren Dahlgaard. Popular conjectures as a barrier for dynamic planar graph algorithms. In FOCS, pages 477–486. IEEE Computer Society, 2016.
- [2] Ittai Abraham, Shiri Chechik, Daniel Delling, Andrew V. Goldberg, and Renato F. Werneck. On dynamic approximate shortest paths for planar graphs with worst-case costs. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 740–753. SIAM, 2016. doi:10.1137/1.9781611974331.ch53.
- [3] Ittai Abraham, Shiri Chechik, and Cyril Gavoille. Fully dynamic approximate distance oracles for planar graphs via forbidden-set distance labels. In Proceedings of the Forty-Fourth Annual ACM Symposium on Theory of Computing, STOC ’12, page 1199–1218, New York, NY, USA, 2012. Association for Computing Machinery. doi:10.1145/2213977.2214084.
- [4] William Aiello, Fan Chung Graham, and Linyuan Lu. A random graph model for power law graphs. Exp. Math., 10(1):53–66, 2001. doi:10.1080/10586458.2001.10504428.
- [5] Bertie Ancona. Conditional Lower Bounds for Graph Sensitivity Problems. Master’s thesis, Massachusetts Institute of Technology, Cambridge, MA, 2019.
- [6] Bertie Ancona, Monika Henzinger, Liam Roditty, Virginia Vassilevska Williams, and Nicole Wein. Algorithms and hardness for diameter in dynamic graphs. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi, editors, 46th International Colloquium on Automata, Languages, and Programming, ICALP 2019, July 9-12, 2019, Patras, Greece, volume 132 of LIPIcs, pages 13:1–13:14. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.ICALP.2019.13.
- [7] Thiago Bergamaschi, Monika Henzinger, Maximilian Probst Gutenberg, Virginia Vassilevska Williams, and Nicole Wein. New techniques and fine-grained hardness for dynamic near-additive spanners. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 1836–1855. SIAM, 2021. doi:10.1137/1.9781611976465.110.
- [8] Panagiotis Charalampopoulos and Adam Karczmarz. Single-source shortest paths and strong connectivity in dynamic planar graphs. In ESA, volume 173 of LIPIcs, pages 31:1–31:23. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2020.
- [9] Julia Chuzhoy. Decremental all-pairs shortest paths in deterministic near-linear time. In Samir Khuller and Virginia Vassilevska Williams, editors, STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, Virtual Event, Italy, June 21-25, 2021, pages 626–639. ACM, 2021. doi:10.1145/3406325.3451025.
- [10] Julia Chuzhoy and Thatchaphol Saranurak. Deterministic algorithms for decremental shortest paths via layered core decomposition. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 2478–2496. SIAM, 2021. doi:10.1137/1.9781611976465.147.
- [11] Søren Dahlgaard. On the hardness of partially dynamic graph problems and connections to diameter. CoRR, abs/1602.06705, 2016. URL: http://arxiv.org/abs/1602.06705, arXiv:1602.06705.
- [12] Gramoz Goranci, Monika Henzinger, and Pan Peng. Dynamic effective resistances and approximate schur complement on separable graphs. In Yossi Azar, Hannah Bast, and Grzegorz Herman, editors, 26th Annual European Symposium on Algorithms, ESA 2018, August 20-22, 2018, Helsinki, Finland, volume 112 of LIPIcs, pages 40:1–40:15. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.ESA.2018.40.
- [13] Gramoz Goranci, Harald Räcke, Thatchaphol Saranurak, and Zihan Tan. The expander hierarchy and its applications to dynamic graph algorithms. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 2212–2228. SIAM, 2021. doi:10.1137/1.9781611976465.132.
- [14] Fan Chung Graham. Large dynamic graphs: What can researchers learn from them? SIAM News, 37(3), 2004.
- [15] Manoj Gupta and Richard Peng. Fully dynamic (1+ )-approximate matchings. In 2013 IEEE 54th Annual Symposium on Foundations of Computer Science, pages 548–557, 2013. doi:10.1109/FOCS.2013.65.
- [16] Monika Henzinger, Sebastian Krinninger, Danupon Nanongkai, and Thatchaphol Saranurak. Unifying and strengthening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In STOC, pages 21–30. ACM, 2015.
- [17] Monika Henzinger, Andrea Lincoln, and Barna Saha. The complexity of average-case dynamic subgraph counting. In Proceedings of the 2022 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 459–498. SIAM, 2022.
- [18] Monika Rauch Henzinger, Philip N. Klein, Satish Rao, and Sairam Subramanian. Faster shortest-path algorithms for planar graphs. J. Comput. Syst. Sci., 55(1):3–23, 1997. doi:10.1006/jcss.1997.1493.
- [19] Giuseppe F. Italiano, Adam Karczmarz, Jakub Lacki, and Piotr Sankowski. Decremental single-source reachability in planar digraphs. In Hamed Hatami, Pierre McKenzie, and Valerie King, editors, Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 1108–1121. ACM, 2017. doi:10.1145/3055399.3055480.
- [20] Giuseppe F. Italiano, Yahav Nussbaum, Piotr Sankowski, and Christian Wulff-Nilsen. Improved algorithms for min cut and max flow in undirected planar graphs. In Lance Fortnow and Salil P. Vadhan, editors, Proceedings of the 43rd ACM Symposium on Theory of Computing, STOC 2011, San Jose, CA, USA, 6-8 June 2011, pages 313–322. ACM, 2011. doi:10.1145/1993636.1993679.
- [21] Wenyu Jin and Xiaorui Sun. Fully dynamic c-edge connectivity in subpolynomial time. CoRR, abs/2004.07650, 2020. URL: https://arxiv.org/abs/2004.07650, arXiv:2004.07650.
- [22] P. N. Klein and S. Subramanian. A fully dynamic approximation scheme for shortest paths in planar graphs. Algorithmica, 22(3):235–249, Nov 1998. doi:10.1007/PL00009223.
- [23] David Peleg and Shay Solomon. Dynamic (1+)-approximate matchings: A density-sensitive approach. In Proceedings of the twenty-seventh annual ACM-SIAM symposium on Discrete algorithms, pages 712–729. SIAM, 2016.
- [24] Saurabh Sawlani and Junxing Wang. Near-optimal fully dynamic densest subgraph. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, page 181–193, New York, NY, USA, 2020. Association for Computing Machinery. doi:10.1145/3357713.3384327.
- [25] Sairam Subramanian. A fully dynamic data structure for reachability in planar digraphs. In Thomas Lengauer, editor, Algorithms - ESA ’93, First Annual European Symposium, Bad Honnef, Germany, September 30 - October 2, 1993, Proceedings, volume 726 of Lecture Notes in Computer Science, pages 372–383. Springer, 1993. doi:10.1007/3-540-57273-2\_72.
Appendix A Related Work
We describe further related work in this section.
Planar graphs. Prior work for fully dynamic shortest paths in planar graphs is summarized in Table 8 and Table 9. There is one further lower bound result in dynamic planar graphs, namely for bipartite maximum weigthed matching, showing a tradeoff of , where denotes the update time and the query time [1]. The planar graphs used in these lower bound constructions all have constant degree.
There exists also further work on upper bounds in planar graphs. Italiano et al. [20] designed a fully dynamic algorithm for maximum flow and minimum cut with update time in planar graphs. In the deletions-only setting in directed graphs Italiano et al. [19] gave an algorithm with time per operation.
Other graph classes. In -separable graphs Goranci et al. [12] give almost tight upper and lower bounds for maintaining -approximations of the all-pairs effective resistances.
In graphs with constant arboricity Peleg and Salomon [23] gave -approximate matching algorithm in constant time.
Insertions-only and deletions-only lower bounds. In general graphs Dahlgaard [11] presented lower bounds of for incremental or decremental maximum cardinality bipartite matching, of for incremental or decremental maximum flow in directed and weighted sparse graphs, and for incremental or decremental -approximating the diameter of an unweighted graph for any small constant . These lower bounds for diameter were later improved in [6]. Results for dynamic near-additive spanners were given in [7].
Sensitivity model. Ancona [5] studied diameter approximation and related problems in dynamic constant-degree graphs. She focused on a different model than ours, called the sensitivity model, and similarly to us, proved conditional lower bounds using reductions to the OMv conjecture.
Appendix B Partially Dynamic Lower Bounds
B.1 Dynamic -Distance
We show that our dynamic -distance lower bound for constant-degree graphs also holds for partially dynamic algorithms using the following reduction graph.
-
•
A -depth binary forest with a single tree. The internal nodes are marked and the leaves ; the root of the tree is the source node , and the nodes of are marked as for .
-
•
A -depth binary forest with trees. The internal nodes are marked and the leaves . The roots of each of the trees are marked as , for , and the leaves of the tree with root are marked , for .
-
•
An edge from to for .
-
•
paths on nodes. The nodes of the path are marked , . Edges from to for all .
-
•
A -depth binary forest with trees. The internal nodes are marked and the leaves . The roots of each of the trees are marked as , for , and the leaves of the tree with root are marked , for .
-
•
An edge from to for all .
-
•
A copy of the above structure, with node sets marked and instead of and . The root of the single tree of is the target node .
-
•
For the matrix , add the edge if .
-
•
Deletion of edges for each input pair as detailed next.
We perform the following deletions upon the arrival of the input vectors
-
•
Given the input vector , for each , delete the edge if .
-
•
Given the input vector , for each , delete the edge if .
Before the input vector arrives, delete all and edges for all . It is easy to see that there is a path of length if and only if .
Since the reduction graph consists of nodes and we make updates and query for each input pair, we get the same lower bounds as in the fully-dynamic setting. Note that this lower bound can be made to work for the insertions only setting as well by reversing the path and .
B.2 Dynamic Maximum Matching
We use the following reduction graph to make our fully dynamic maximum matching lower bounds hold for the partially dynamic setting as well.
-
•
A reduction gadget with subgadgets of size , on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for . The path in each subgadget goes from to .
-
•
A reduction gadget with subgadgets of size , on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for . The path in each subgadget goes from to .
-
•
Edges from to for all .
-
•
A reduction gadget with subgadgets of size , on a set . The subgadgets are labelled for , and the nodes of subgadget are labelled or for . The path in each subgadget goes from to .
-
•
An edge from to for all .
-
•
A copy of the above structure, with node sets marked instead of .
-
•
For the matrix , add the edge if .
-
•
Deletion of edges for each input pair as detailed next.
We perform the following deletions upon the arrival of the input vectors :
-
•
Delete the edge .
-
•
Given the input vector , for each , delete the edge if .
-
•
Given the input vector , for each , delete the edge if .
Before the input vector arrives, delete the edges , , , and for all . It is easy to see that there is a matching with only nodes unmatched if and only if .
Since the reduction graph consists of nodes and we make updates and query for each input pair, we get the same lower bounds as in the fully-dynamic setting. This reduction can be made to work for the insertions only setting by reversing the above construction.