Popular Conjectures as a Barrier for Dynamic Planar Graph Algorithms

Popular Conjectures as a Barrier for
Dynamic Planar Graph Algorithms

Amir Abboud Part of the work was performed while visiting the Simons Institute for the Theory of Computing, Berkeley, CA. Research partially supported by Virginia Vassilevska Williams’s NSF Grants CCF-1417238 and CCF-1514339, and BSF Grant BSF:2012338. Stanford University
abboud@cs.stanford.edu
Søren Dahlgaard Part of this work was done while the author was visiting Stanford University. Research partly supported by Mikkel Thorup’s Advanced Grant DFF-0602-02499B from the Danish Council for Independent Research under the Sapere Aude research career programme. University of Copenhagen
soerend@di.ku.dk
Abstract

The dynamic shortest paths problem on planar graphs asks us to preprocess a planar graph such that we may support insertions and deletions of edges in as well as distance queries between any two nodes subject to the constraint that the graph remains planar at all times. This problem has been extensively studied in both the theory and experimental communities over the past decades and gets solved millions of times every day by companies like Google, Microsoft, and Uber. The best known algorithm performs queries and updates in time, based on ideas of a seminal paper by Fakcharoenphol and Rao [FOCS’01]. A -approximation algorithm of Abraham et al. [STOC’12] performs updates and queries in time. An algorithm with a more practical runtime would be a major breakthrough. However, such runtimes are only known for a -approximation in a model where only restricted weight updates are allowed due to Abraham et al. [SODA’16], or for easier problems like connectivity.

In this paper, we follow a recent and very active line of work on showing lower bounds for polynomial time problems based on popular conjectures, obtaining the first such results for natural problems in planar graphs. Such results were previously out of reach due to the highly non-planar nature of known reductions and the impossibility of “planarizing gadgets”. We introduce a new framework which is inspired by techniques from the literatures on distance labelling schemes and on parameterized complexity.

Using our framework, we show that no algorithm for dynamic shortest paths or maximum weight bipartite matching in planar graphs can support both updates and queries in amortized time, for , unless the classical all-pairs-shortest-paths problem can be solved in truly subcubic time, which is widely believed to be impossible. We extend these results to obtain strong lower bounds for other related problems as well as for possible trade-offs between query and update time. Interestingly, our lower bounds hold even in very restrictive models where only weight updates are allowed.

1 Introduction

The dynamic shortest paths problem on planar graphs is to preprocess a planar graph , e.g. the national road network, so that we are able to efficiently support the following two operations:

  • At any point, we might insert or remove an edge in , e.g. in case a road gets congested due to an accident. Such updates are subjected to the constraint that the planarity of the graph is not violated. We may also consider another natural variant in which we are only allowed to update the weights of existing edges.

  • We want to be able to quickly answer queries that ask for the length of the shortest path between two given nodes and , in the most current graph .

This is a problem that gets solved millions of times every day by companies like Google, Microsoft, and Uber on graphs such as road networks with many millions of nodes. It is thus a very important question in both theory and practice whether there exists data structures that can perform updates and (especially) queries on graphs with nodes in polylogarithmic or even time.

Shortest paths problems on planar graphs provide an ideal combination of mathematical simplicity and elegance with faithful modeling of realistic applications of major industrial interest. The literature on the topic is too massive for us to survey in this paper: the current draft of the book “Optimization Problems in Planar Graphs” by Klein and Mozes [42] dedicates four chapters to the algorithmic techniques for shortest paths by the theory community. While near-optimal algorithms are known for most variants of shortest paths on static planar graphs, the dynamic setting has proven much more challenging.

Since an -shortest path in a planar graph can be found in near-linear time (linear time for non-negative weights) [39, 28], there is a naïve algorithm for the dynamic problem that spends time on queries. After progress on other related problems on dynamic planar graphs [29, 30, 24, 31, 61, 44, 39], the first sublinear bound was obtained in the seminal paper of Fakcharoenphol and Rao [28], which introduced new techniques that led to major results for other problems like Max Flow (even on static graphs) [17, 47]. The amortized time per operation was and if negative edges are allowed, and follow up works of Klein [43], Italiano et al. [40], and Kaplan et al. [41] reduced the runtime to (even allowing negative weights), and most recently, Gawrychowski and Karczmarz [33] reduced it further to . In fact these algorithms give a trade-off on the update and query time of and , for all . The problem has also been extensively studied from an engineering viewpoint on real-world transportation networks (see [21] for a survey). State of the art algorithms [13, 20, 22, 34, 60] are able to exploit further structure of road networks (beyond planarity) and process updates to networks with tens of millions of nodes in milliseconds.

In a recent SODA’16 paper, Abraham et al. [6] study worst case bounds under a restricted but realistic model of dynamic updates in which a base graph is given and one is allowed to perform only weight updates subject to the following constraint: For any updated graph it must hold that for all and some parameter . (Note that this will hold if, for example, the weight of each edge only changes to within a factor of .) In this model, the authors obtain a -approximation algorithm that maintains updates in time. Without this restriction, the best known -approximation algorithms use updates [44, 7]. Thus, when is small, this model allows for a major improvement over the above results which require polynomial time updates. But is it enough to allow for exact algorithms with subpolynomial updates? Such a result would explain the impressive experimental performance of state of the art algorithms.

On the negative side, Eppstein showed that time is required in the cell probe model [27] for planar connectivity (and therefore also shortest path). However, an unconditional lower bound is far beyond the scope of current techniques (see [18]). In recent years, much stronger lower bounds were obtained for dynamic problems under certain popular conjectures [57, 54, 3, 46, 38, 5, 19]. For example, Roditty and Zwick [57] proved an lower bound for dynamic single source shortest paths in general graphs under the following conjecture.

Conjecture 1 (APSP Conjecture).

There exists no algorithm for solving the all pairs shortest paths (APSP) problem in general weighted (static) graphs in time for any .

However, the reductions used in these results produce graphs that are fundamentally non-planar, such as dense graphs on three layers, and popular approaches for making them planar, e.g. by replacing each edge crossing with a small “planarizing gadget”, are provably impossible (this was recently shown for matching [36] and is easier to show for problems like reachability and shortest paths). Due to this and other challenges no (conditional) polynomial lower bounds were known for any natural problem on (static or dynamic) planar graphs.

On a more general note, an important direction for future research on the fine-grained complexity of polynomial time problems (a.k.a. Hardness in P) is to understand the complexity of fundamental problems on restricted but realistic classes of inputs. A Recent result along these lines is the observation that the lower bound for computing the diameter of a sparse graph [56] holds even when the treewidth of the graph is [4]. In this paper, we take a substantial step in this direction, proving the first strong (conditional) lower bounds for natural problems on planar graphs.

1.1 Our Results

We present the first conditional lower bounds for natural problems on planar graphs using a new framework based on several ideas for conditional lower bounds on dynamic graphs combined with ideas from parameterized complexity [50, 51] and labeling schemes [32]. We believe that this framework is of general interest and might lead to more interesting results for planar graphs. Our framework shows an interesting connection between dynamic problems and distance labeling and also slightly improves the result of [32] providing a tight lower bound for distance labeling in weighted planar graphs (this is discussed in Section 1.2).

Our first result is a conditional polynomial lower bound for dynamic shortest paths on planar graphs. Like several recent results [64, 2, 1, 5, 58, 19], our lower bound is based on the APSP conjecture. Perhaps the best argument for this conjecture is the fact that it has endured decades of extensive algorithmic attacks. Moreover, due to the known subcubic equivalences [64, 1, 58], the conjecture is false if and only if several other fundamental graph and matrix problems can be solved substantially faster.

Theorem 1.

No algorithm can solve the dynamic APSP problem in planar graphs on nodes with amortized query time and update time such that for any unless Conjecture 1 is false. This holds even if we only allow weight updates to .

Thus, under the APSP conjecture, there is no hope for a very efficient dynamic shortest paths algorithm on planar graphs with provable guarantees. We show that an algorithm achieving time for both updates and queries is unlikely, implying that the current upper bounds achieving time are not too far from being conditionally optimal. Furthermore, our result implies that any algorithm with subpolynomial query time must have linear update time (and the other way around). Thus, the naïve algorithm of simply computing the entire shortest path every time a query is made is (conditionally) optimal if we want update time.

An important property of Theorem 1 is that our reduction does not even violate planarity with respect to a fixed embedding. Thus, we give lower bounds even for plane graph problems, which in many cases allow for improved upper bounds over flexible planar graphs (e.g. for reachability[23, 11]). Moreover, our graphs are grid graphs which are subgraphs of the infinite grid, a special and highly structured subclass of planar graphs. Finally, as stated in Theorem 1 our lower bound holds even for the edge weight update model of Abraham et al. [6], where each edge only ever changes its weight to within a factor of . While they obtain fast time -approximation algorithm in this model, we show that an exact answer with the same query time likely requires linear update time and that an algorithm with runtime for both is highly unlikely. Thus, further theoretical restrictions need to be added in order to explain the impressive performance on real road networks.

We also extend Theorem 1 to the case in which we only need to maintain one distance (the -shortest path problem). While this problem is equivalent to the APSP version in general (as we may connect and to any two nodes we wish to know the distance between) this may violate planarity and especially a fixed embedding. We show that this problem exhibits similar trade-offs under Conjecture 1 even if we are only allowed to update weights. Finally, we note that in the case of directed planar graphs allowing negative edge weights our techniques can be extended to show the same hardness result for any approximation under Conjecture 1.

Next, we seek a lower bound for the unweighted version of the problem, which arguably, is of more fundamental interest. Typically, a conditional lower bound under the APSP conjecture for a weighted problem can be modified into a lower bound for its unweighted version under the Boolean Matrix Multiplication (BMM) Conjecture [25, 57, 64, 3, 1]. While for combinatorial algorithms the complexity of BMM is conjectured to be cubic, it is known that using algebraic techniques there is an algorithm, where [63, 49]. When reducing to dynamic problems, however, lower bounds under BMM are often under a certain online version of BMM for which, Henzinger et al. [38] conjecture that there is no truly subcubic algorithms, even using algebraic techniques. This Online Matrix Vector Multiplication (OMv) Conjecture is stated formally in Section 5.

The OMv conjecture implies strong lower bounds for many dynamic problems on general graphs [38], via extremely simple reductions [3, 38]. Our next result is a significantly more involved reduction from OMv to dynamic shortest paths on planar graphs, giving unweighted versions of the theorems above. The lower bounds are slightly weaker but they still rule out algorithms with subpolynomial update and query times, even in grid graphs. We remark that all lower bounds under the APSP conjecture in this paper, such as Theorem 1, also hold under OMv.

Theorem 2.

No algorithm can solve the dynamic APSP problem in unit weight planar graphs on nodes with amortized query time and update time such that for any unless the OMv conjecture of [38] is false. This holds even if we only allow weight updates.

For instance, Theorem 2 shows that no algorithm is likely to have amortized time for both queries and updates. It also shows that if we want to have for one we likely need time for the other.

Combined with previous results, our theorems reveal a mysterious phenomenon: there are two contradicting separations between planar graphs and small treewidth graphs, in terms of the time complexity of dynamic problems related to shortest paths (under popular conjectures). To illustrate these separations, consider the dynamic -shortest path problem and the dynamic approximate diameter problem. For -shortest path, planar graphs are much harder, they require update or query time by Theorem 2 (under OMv), while on small (polylog) treewidth graphs there is an algorithm achieving polylog updates and queries [6]. On the other hand, for approximate diameter, planar graphs are provably easier under the Strong Exponential Time Hypothesis (SETH). A naive algorithm that runs the known time static algorithm for approximate diameter on planar graphs after each update [62], shatters an SETH-based lower bound for a approximation for diameter on graphs with treewidth [3]111This lower bound follows from observing that the reduction from CNF-SAT to dynamic diameter [3] produces graphs with logarithmic treewidth. For more details on an analogous observation w.r.t. the lower bound for diameter in static graphs, see [4]..

We demonstrate the potential of our framework to yield further strong lower bounds for important problems in planar graphs by proving such a result for another well-studied problem in the graph theory literature, namely Maximum Weight Matching.

Maintaining a maximum matching in general dynamic graphs is a difficult task: the best known algorithm by Sankowski [59] has an amortized update time, and it is better than the simple algorithm (that looks for an augmenting path after every update) only in dense graphs. Recent results show barriers for much faster algorithms via conjectures like OMv and -SUM [3, 46, 38, 19]. To our knowledge, this update time is the best known for planar graphs and no lower bound is known. Meanwhile, there has been tremendous progress on approximation algorithms [53, 12, 52, 14, 16, 15, 37, 45, 55, 10], both on general and planar graphs, as well as for the natural Maximum Weight Matching (see the references in [26] for the history of this variant). Planar graphs have proven easier to work with in this context: the state of the art deterministic algorithm for maintaining a -maximum matching in general graphs has update time [35], while in planar graphs the bound is [55].

We show a strong polynomial lower bound for Max Weight Matching on planar graphs, that holds even for bipartite graphs with a fixed embedding into the plane and even in grid graphs. The lower bound is similar to Theorem 1 and shows a trade-off between query and update time.

Theorem 3.

No algorithm can solve the dynamic maximum weight matching problem in bipartite planar graphs on nodes with amortized update time and query time such that for any unless Conjecture 1 is false. Furthermore, if the algorithm cannot have . This holds even if the planar embedding of never changes.

Finally, we use our framework to show lower bounds for various other problems, like dynamic girth and diameter. We also argue that our bounds can be turned into worst-case bounds for incremental and decremental versions of the same problems.

1.2 Techniques and relations to distance labeling

To prove the results mentioned above we introduce a new framework for reductions to optimization problems on planar graphs. As mentioned we combine ideas from previous lower bound proofs for dynamic graph problems with an approach inspired by the framework of Marx for hardness of parameterized geometric problem (via the Grid Tiling problem) [50, 51] and a graph construction from the research on labelling schemes by Gavoille et al. [32].

Gavoille et al. [32] used a family of grid-like graphs to prove an (unconditional) lower bound of on the label size of distance labeling in weighted planar graphs along with a upper bound. (A full discussion of distance labeling schemes is outside the scope of this paper. For details on this we refer to [32, 9, 8]). In this paper we generalize their family of graphs to a family of grid graphs capable of representing general matrices with weights in via shortest paths distances. Using our construction with the framework of [32], we obtain a tight lower bound on the size of distance labeling in weighted planar graphs (and even grid graphs).

Our main approach works by reducing from the -Matrix-Multiplication problem which is known to be equivalent to APSP (see [64]): Given two matrices with entries in , compute a matrix such that . By concatenating grid graphs from the family described above we are able to represent one of the matrices in the product and we can then simulate the multiplication process via updates and shortest paths queries.

In a certain intuitive sense, our connection between dynamic algorithms and labeling schemes is the reverse direction of the one shown by Abraham et al. [7] to obtain their update time -approximation algorithm for dynamic APSP. Their algorithm utilizes a clever upper bound for the so-called forbidden set distance labeling problem, while our lower bound constructions have a clever lower bound for labeling schemes embedded in them.

2 A grid construction

In order to reduce to problems on planar graphs we will need a planar construction, which is able to capture the complications of problems like OMv and APSP. To do this we will employ a grid construction based on the one used in [32] to prove lower bounds on distance labeling for planar graphs. Our construction takes a matrix as input and produces a grid graph representing that matrix. We first present a boolean version similar to the one from [32] and then modify it to obtain a version taking matrices with integer entries as input. This modified matrix also immediately leads to a tight lower bound for distance labeling in planar graphs with weights in when combined with the framework of [32].

Definition 1.

Let be a boolean matrix. We will call the following construction the grid embedding of :

Let be a rectangular grid graph with rows and columns. Denote the node at intersection by ( is top-left and is bottom-right). Add nodes and edges above . Similarly add the nodes and edges to the right of . Now subdivide each vertical edge adding the node above , and subdivide each horizontal edge adding the node to the right of . Finally, for each entry of such that add the node and edges and to the graph.

The weights of are as follows: Each edge and has weight . Each edge and has weight . The edge has weight . All remaining edges have weight .

We will call the two-edge path a shortcut from to as it has length less than the path . Clearly, the grid embedding of a matrix has nodes. It is also easy to see that such a grid embedding is a subgraph of a rectangular grid. The construction of Definition 1 for a matrix can be seen in Figure 1.

Figure 1: Illustration of the construction of Definition 1. The shortest path from to is highlighted in red. Most edge weights are omitted for clarity.
Proposition 1.

Let be a boolean matrix and let be its grid embedding as defined in Definition 1. Then for any and the shortest path distance from to is exactly

if and

otherwise.

Proof.

Consider any shortest path from any to . Such a path must always go either “right” or “down” (if the path must always go right). Essentially for every step to the left we pay at least but can at most save : paying going left and going right, possibly saving with a shortcut, and saving for each vertical edge.

Now we will show the claim by induction on the sum . Clearly, for to the distance is exactly . Now consider and assume as the case of is trivial. There are three cases to consider:

  1. The path from goes through and then . By the induction hypothesis this path has length at least

  2. The path from goes through and then , , and . This path is only available if . If , this distance is exactly

    Otherwise, by the induction hypothesis, it is at least

    for

  3. The path from goes through and then . By the induction hypothesis, if , the length of this path is

    and otherwise it is

It is easy to verify that taking the path down and right as illustrated in Figure 1 gives exactly the distances in the proposition, finishing the proof. ∎

The following useful property of our grid construction follows.

Corollary 1.

Let and be as in Proposition 1. Then for any , the distance between and in is exactly determined by whether . In this case the distance is and it is otherwise.

The following generalization for matrices with integer weights will be useful when reducing from APSP.

Definition 2.

Let be a matrix with integer weights in . We will call the following construction the grid embedding of .

Let be the grid embedding from Definition 1 for the all ones matrix of size and multiply the weight of each edge by . Furthermore, for each edge increase its weight by .

Corollary 2.

Let be a matrix with integer weights in and let be its grid embedding. Then for any , the distance between and in is exactly

Corollary 2 follows from Corollary 1 by observing that any path from to not using the shortcut at intersection has distance at least and since this distance is longer than using the shortcut. We remark that it would have been sufficient to multiply the weights by instead of , but we do so to simplify a later argument.

3 Hardness of dynamic APSP in planar graphs

We will first show the following, simpler theorem and then generalize it to show trade-offs between query and update time.

Theorem 4.

No algorithm can solve the dynamic APSP problem in planar graphs on nodes with amortized update and query time for any unless Conjecture 1 is false. This holds even if only weight updates are allowed.

The main idea in proving Theorem 4 is to reduce from the APSP problem by first reducing to -Matrix-Mult and use the grid construction from Section 2 to represent the matrices to be multiplied. We then perform several shortest paths queries to simulate the multiplication process. Below, we first present a naïve and faulty approach explaining the main ideas of the reduction. We then show how to mend this approach giving the desired result.

Attempt 1.

Consider the following algorithm for solving an instance, of the -Matrix-Mult problem, where and are matrices. We may assume that and have integer weights in for some .

We let the initial graph of the problem be the grid embedding of according to Definition 2 along with a special vertex . Also add the edges for each . Now we wish to construct one row at a time. Such a row is a -product of a row in and the entire matrix . Thus, for each row, , of we have a phase as follows:

  1. For each update the weight of the edge to be .

  2. For each query the distance between and .

The idea of each phase is that the distance between and should correspond to the value of . Observe, that the distance from to using the edge is exactly

by Corollary 2. The dominant term in this expression increases with and thus no matter what and are (for ), the shortest path from to will simply pick minimizing the above expression. If we instead set the weight of each edge to we get the distance of using this edge to be

It follows that the shortest path from to is free to pick any while only affecting the term, which means that the shortest distance will be achieved by picking the minimizing this term, which would give us exactly . This approach therefore allows us to correctly calculate . However, the weight of the edge now depends on which we are querying implying that we have to update this weight for each leading to a total of updates. By using this approach we are thus not able to make any statement about the time required for updates. We may try to assign edges and weights differently, but such approaches run into similar issues.

Observe that the graph created has nodes. Thus, if we were able to perform only total queries and updates the result of Theorem 4 would follow.

In order to circumvent this dependence on when assigning weights to the edges we instead replace by another grid whose purpose is to “normalize” the distance for each . By doing this we can connect the grids with edges whose weight is independent of . This step deviates significantly from the construction of [32] and is inspired by the grid tiling framework of Marx [50, 51].

Proof of Theorem 4.

We follow the same approach as in Attempt 1, but with a few changes. Define the initial graph as follows: Let be as before and let be the grid embedding of mirrored along the vertical axis with all shortcuts removed. Now for each add the edge and define to be this graph.

Now we perform a phase for each row of as follows:

  1. For each set the weight of the edge to be .

  2. For each query the distance between and .

An example of this construction for can be seen in Figure 2.

Figure 2: Example of a phase in the graph in the reduction of Theorem 4. The highlighted path illustrates a shortest path between and as an example of a query. Most edge weights have been omitted for clarity.

From the query between nodes and above during phase we can determine the entry of the output matrix. To see this, consider the distance from to at the time of query. This path has to go via some edge . From Corollary 2 we know that this distance is exactly

The crucial property that our construction achieves is that the dominant term of this expression is independent of . Thus, the shortest path will choose to go through the edge that minimizes , implicitly giving us . Subtracting from the queried distance gives exactly the value of and the algorithm therefore correctly computes .

Following the analysis from Attempt 1 we have that any algorithm with an amortized running time of for both updates and queries contradicts Conjecture 1. ∎

3.1 Trade-offs

Theorem 4 above shows that no algorithm can perform both updates and queries in amortized time unless Conjecture 1 is false. We will now show how to generalize these ideas to show Theorem 1.

Proof of Theorem 1.

The proof follows the same structure as the proof for Theorem 4, but instead of reducing from -Matrix-Mult on matrices we reduce from an unbalanced version.

Let and be and matrices respectively for some . We define the initial graph from in the same manner as in Theorem 4. We then have a phase for each row of as follows:

  1. For each set the weight of the edge to be .

  2. For each query the distance between and .

The entry is exactly the distance from the th phase minus . The correctness of the above reduction follows directly from the proof of Theorem 4 as well as Corollary 2.

Now observe that the graph from the above reduction has nodes and we perform a total of queries and updates222We also perform updates to create the initial graph (depending on the model), however we will choose and such that this term is dominated. – that is, at most updates per row and queries per column. Any algorithm solving this problem must use total time time unless Conjecture 1 is false. It follows that either updates must take amortized time or queries must take amortized time.

Assume now that an algorithm exists such that queries take amortized time for any . We wish to show that this algorithm cannot perform updates in amortized time for any . Pick and set . We now use the above reduction to create a dynamic graph with nodes. Since queries do not take time it follows from the above discussion that updates must take time. Since this is polynomially greater than the claim follows. ∎

4 Hardness of dynamic maximum weight matching in bipartite planar graphs

In this section we will demonstrate the generality of our reduction framework by showing Theorem 3.

Proof of Theorem 3.

We start by showing how to reduce from -Matrix-Mult to minimum weight perfect matching, where the weight of such a matching corresponds to the shortest path distance between and similar to the proof of Theorem 1. We then describe how to use this reduction further to get a problem instance for maximum weight matching.

Let be an instance to the -Matrix-Mult problem of sizes and respectively. Consider the grid embedding of . We first replace each node of by two nodes connected by an edge of weight . For , , , and denote the corresponding nodes with superscript and (for “down” and “up”). For and denote the corresponding nodes with superscript and (for “left” and “right”). Now, for each original edge in we replace it as follows keeping its weight:

This construction is illustrated in Figure 3. We call this modified grid structure . Observe that there are no edges between “up” and “left” vertices or between “down” and “right”. It follows that the graph is bipartite and that these two sets of nodes make up the two partitions.

Figure 3: Grid construction for minimum weight perfect matching. Thick edges correspond to original edges and have the same weight as in . Thin edges have weight .

We now replace the grids and by and in the initial graph from the proof of Theorem 1. The edges are replaced by . We will use the following observation.

Proposition 2.

The graph resulting from joining two grids in the way of Figure 2 has a unique perfect matching.

Proof.

It is easy to see that simply matching all weight edges gives a perfect matching. Thus we need to show that this is the only perfect matching. We will show the claim by a simple “peeling” argument.

Observe that only has one incident edge, so the edge must be in any perfect matching and we may “peel” away these two nodes. It now follows that only has one adjacent edge, so has to be in any perfect matching and we may peel away these nodes. Now only has one adjacent edge and so on for , , etc. This peels away the entire first column. Now each has only one adjacent edge matching this leaves each with only one adjacent edge. Peeling these nodes away leaves us with a smaller grid and we may start the argument over with .

By doing this we see that the edge joining and cannot be in a perfect matching as has to be. Thus we can repeat the same argument on the second grid. ∎

We now add two additional nodes and to the initial graph and perform a phase for each row of as follows:

  1. For each set the weight of the edge to be .

  2. For each do the following three steps: 1) add the edges and , 2) query the minimum weight perfect matching, 3) delete the two edges.

Since the edges and have to be in any perfect matching this leaves and unmatched. Any perfect matching now has to “connect” these two nodes by a path of original (weight ) edges. The weight of a perfect matching in then corresponds to the length of a shortest path from to in the graph from the proof of Theorem 1. It follows that we get the same trade-offs for minimum weight perfect matching as for APSP with the exception that the trade-off only holds when since we perform updates for each query.

To show the same result for maximum weight matching we may simply perform the following two changes: 1) pick a sufficiently large integer and set the weight of each edge to minus its weight in the above reduction, and 2) when adding the edges and assign them weight such that any maximum weight matching has to include these two edges and will have weight

where denotes the corresponding graph in the proof of Theorem 1. ∎

5 Unweighted

The proofs of the previous sections rely heavily on the weighted grid from Section 2. We may generalize the ideas to the unweighted case by instead using the grid of Definition 1 and subdividing the edges giving us somewhat weaker bounds. This gives us Theorem 2.

The problem we reduce from is the online matrix-vector problem from [38]. We may define this problem as follows: Let be a matrix and let be boolean vectors arriving in an online fashion. The task is to pre-process such that we can output the product for each before seeing . It was conjectured in [38] that this problem takes time, while the best known upper bound is [48]. Known reductions from [64] show that this conjecture implies a bound for the following problem: Let be fixed constants and let be a boolean matrix (see [38] for the details). After preprocessing , boolean vector pairs arrive one at a time and the task is to compute before being presented with the th vector pair for every . We will use this problem called the OuMv problem to reduce to unit weight dynamic APSP in planar graphs below.

Proof of Theorem 2.

Consider the reduction from Theorem 1 using a grid. We will use a similar approach to solve the OuMv problem below.

Let be the matrix of the OuMv problem and create according to Definition 1 (note that this grid embedding is different from the one used in the proof of Theorem 1). We also add similarly to the proof of Theorem 1. We then subdivide each edge into a path of the same length. We also add to a path of length connecting and for each . We then disconnect and from this path.

We perform a phase as follows for each vector pair :

  1. For each such that connect and to their respective path.

  2. For each such that query the distance from to .

  3. Remove all the edges added in step 1.

If the answer to any of the queries during the th phase is the answer to the th product is and otherwise the answer is . This follows from Corollary 1 in the same way as Theorem 1.

By subdividing the edges we get a graph with nodes. We perform queries and updates. It follows from the OMv conjecture that the entire process must take time, thus either updates take time or queries take time.

We will assume that and note that the other case follows symmetrically. Assume that some algorithm can perform queries in for some . We wish to show that this algorithm cannot perform updates in time for any . To do this, pick and . Note that (corresponding to ). Thus the graph has nodes. It now follows by the above discussion that the algorithm cannot perform updates faster than which proves the claim.

Finally, observe that by using an matrix in the above reduction (i.e. ) we see that at least one of updates and queries have to take amortized time (similar to Theorem 4). ∎

To see that we may do the above reduction while keeping the dynamic graph as a grid graph, observe that we may multiply the weight of each edge before subdividing by a large enough constant and then “zig-zag” the subdivided edges in order to fit the grid structure. This is illustrated in Figure 4.

Figure 4: Illustration of the grid created in the proof of Theorem 2. Dashed edges correspond to possible shortcuts. Note that the lengths of the edges are not to scale!

6 Dynamic -shortest path and related problems

In Section 3 we showed a lower bound for the trade-off between query and update time for dynamic APSP in grid graphs conditioned on Conjecture 1. Here we will argue that the proof of Theorem 1 can be extended to show similar lower bounds for dynamic problems, where the algorithm only needs to maintain a single value such as -shortest path, girth, and diameter. We also note that the above techniques for proving bounds in unweighted graphs also apply to the theorem below.

Theorem 5.

No algorithm can solve the -shortest path, girth (directed), or diameter problems in planar graphs on nodes with amortized update time and query time such that for any unless Conjecture 1 is false. Furthermore, if the algorithm cannot have . This holds even if the planar embedding of never changes.

Proof.

We note that the proof follows the exact same structure as the proof of Theorem 1 and only mention the changes needed to be made.

For -shortest path and diameter we add two additional nodes to the initial graph and when performing a query of the distance between and we instead insert edges and of sufficiently high weight so that this is the longest distance in the graph and query the distance.

For girth we direct all horizontal edges of to the right, all vertical edges of the left grid down and all vertical edges of the right grid up. When doing a query we add the directed edge with weight , and the length of the shortest cycle then corresponds to the shortest path from to plus . ∎

In the above reductions, the condition comes from the fact that we perform updates for every query we make and the argument from Theorem 1 thus breaks down if we try to argue for slower updates than queries. This makes sense from an upper bound perspective: clearly, any algorithm with could simply perform a query for every update, store the answer, and then provide queries in time.

7 Weight updates

We mentioned in the previous sections that the results hold even if we only allow weight updates instead of edge insertions/deletions. In [6] they considered this model in which the algorithm is supplied with an initial graph and a promise that for any updated graph we have for all and some parameter . The only operations allowed are weight updates and queries. We note that all the above results for weighted graphs also hold in this model.

As a proof sketch, consider the result of Theorem 1: The only edges whose weight changes are the “in-between” edges whose weights are always between and . Similarly, for -shortest path and diameter: Assume that the edge has weight when added in the reduction of Theorem 5. We may instead initialize the graph with an edge of weight for each , increase each edge to have weight and then instead of adding the edge we decrease its weight back to . We do the same for and the nodes . By picking sufficiently large we may ensure that an edge of weight cannot be on the shortest path from to . Furthermore these changes can still be done while maintaining the graphs as grids.

8 Worst-case bounds for partially dynamic problems

Our reductions above work in the fully dynamic setting, where edge insertions and deletions (or weight increments and decrements) are allowed. We now show that, using standard techniques, we can turn these amortized bounds into worst-case bounds for the same problem in the incremental and decremental (only insertions/increments or deletions/decrements allowed). We will show the result for dynamic APSP and note that the method is the same for the other problems.

Corollary 3.

No algorithm can solve the incremental or decremental APSP problem for planar graphs on nodes with worst-case query time and update time such that for any unless Conjecture 1 is false.

Proof.

We present the argument for the problem when we are given an initial graph and are only allowed to increase weights on edges. The proof uses the same rollback technique employed before in several papers (see e.g. [3]).

First we create the same initial graph, , as in the proof of Theorem 1. We set the initial weight of the edges to be . During the phase of each row of we keep track of all memory changes made by the incremental data structure while increasing each edge to have weight . We then perform each distance query and instead of deleting the incremented edges, we “roll back” the data structure using the memory changes we kept track of, thus restoring to its initial state. By doing this we solve the -Matrix-Mult problem in the exact same way as in Theorem 1. However, we cannot ensure any requirement on the amortized running time, as the rollback operations may essentially “restore all credit” to the data structure in the sense of amortized analysis. Thus, the time bounds only apply to worst-case running times. ∎

Acknowledgements

The authors would like to acknowledge Shay Mozes, Oren Weimann and Virginia Vassilevska Williams for helpful comments and discussions.

References

  • [1] Amir Abboud, Fabrizio Grandoni, and Virginia Vassilevska Williams. Subcubic equivalences between graph centrality problems, APSP and diameter. In Proc. 26th ACM/SIAM Symposium on Discrete Algorithms (SODA), pages 1681–1697, 2015.
  • [2] Amir Abboud and Kevin Lewi. Exact weight subgraphs and the k-sum conjecture. In Proc. 40th International Colloquium on Automata, Languages and Programming (ICALP), pages 1–12, 2013.
  • [3] Amir Abboud and Virginia Vassilevska Williams. Popular conjectures imply strong lower bounds for dynamic problems. In Proc. 55th IEEE Symposium on Foundations of Computer Science (FOCS), pages 434–443, 2014.
  • [4] Amir Abboud, Virginia Vassilevska Williams, and Joshua R. Wang. Approximation and fixed parameter subquadratic algorithms for radius and diameter in sparse graphs. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 377–391, 2016.
  • [5] Amir Abboud, Virginia Vassilevska Williams, and Huacheng Yu. Matching triangles and basing hardness on an extremely popular conjecture. In Proc. 47th ACM Symposium on Theory of Computing (STOC), pages 41–50, 2015.
  • [6] 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 Proc. 27th ACM/SIAM Symposium on Discrete Algorithms (SODA), pages 740–753, 2016.
  • [7] Ittai Abraham, Shiri Chechik, and Cyril Gavoille. Fully dynamic approximate distance oracles for planar graphs via forbidden-set distance labels. In Proc. 44th ACM Symposium on Theory of Computing (STOC), pages 1199–1218, 2012.
  • [8] Stephen Alstrup, Søren Dahlgaard, Mathias Bæk Tejs Knudsen, and Ely Porat. Sublinear distance labeling for sparse graphs. CoRR, abs/1507.02618, 2015.
  • [9] Stephen Alstrup, Cyril Gavoille, Esben Bistrup Halvorsen, and Holger Petersen. Simpler, faster and shorter labels for distances in graphs. In Proc. 27th ACM/SIAM Symposium on Discrete Algorithms (SODA), pages 338–350, 2016.
  • [10] Abhash Anand, Surender Baswana, Manoj Gupta, and Sandeep Sen. Maintaining approximate maximum weighted matching in fully dynamic graphs. In Conference on the Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 257–266, 2012.
  • [11] Rinat Ben Avraham, Haim Kaplan, and Micha Sharir. A faster algorithm for the discrete fréchet distance under translation. arXiv preprint arXiv:1501.03724, 2015.
  • [12] Surender Baswana, Manoj Gupta, and Sandeep Sen. Fully dynamic maximal matching in o (log n) update time. In Foundations of Computer Science (FOCS), 2011 IEEE 52nd Annual Symposium on, pages 383–392. IEEE, 2011.
  • [13] Reinhard Bauer. Dynamic speed-up techniques for dijkstra?s algorithm. Master’s thesis, Institut für Theoretische Informatik-Universität Karlsruhe (TH), page 41, 2006.
  • [14] Aaron Bernstein and Cliff Stein. Fully dynamic matching in bipartite graphs. In Automata, Languages, and Programming, pages 167–179. Springer, 2015.
  • [15] Aaron Bernstein and Cliff Stein. Faster fully dynamic matchings with small approximation ratios. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, pages 692–711. SIAM, 2016.
  • [16] Sayan Bhattacharya, Monika Henzinger, and Giuseppe F Italiano. Deterministic fully dynamic data structures for vertex cover and matching. In Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 785–804. SIAM, 2015.
  • [17] Glencora Borradaile, Philip N. Klein, Shay Mozes, Yahav Nussbaum, and Christian Wulff-Nilsen. Multiple-source multiple-sink maximum flow in directed planar graphs in near-linear time. In Proc. 52nd IEEE Symposium on Foundations of Computer Science (FOCS), pages 170–179, 2011.
  • [18] Raphaël Clifford, Allan Grønlund, and Kasper Green Larsen. New unconditional hardness results for dynamic and online problems. In Proc. 56th IEEE Symposium on Foundations of Computer Science (FOCS), pages 1089–1107, 2015.
  • [19] Søren Dahlgaard. On the hardness of partially dynamic graph problems and connections to diameter. arXiv preprint arXiv:1602.06705, 2016. To appear at ICALP’16.
  • [20] Daniel Delling, Andrew V Goldberg, Thomas Pajor, and Renato F Werneck. Customizable route planning. In Experimental algorithms, pages 376–387. Springer, 2011.
  • [21] Daniel Delling, Peter Sanders, Dominik Schultes, and Dorothea Wagner. Engineering route planning algorithms. In Algorithmics of large and complex networks, pages 117–139. Springer, 2009.
  • [22] Daniel Delling and Dorothea Wagner. Landmark-based routing in dynamic graphs. In Experimental algorithms, pages 52–65. Springer, 2007.
  • [23] Krzysztof Diks and Piotr Sankowski. Dynamic plane transitive closure. In Algorithms–ESA 2007, pages 594–604. Springer, 2007.
  • [24] Hristo N Djidjev, Grammati E Pantziou, and Christos D Zaroliagis. Computing shortest paths and distances in planar graphs. In Automata, Languages and Programming, pages 327–338. Springer, 1991.
  • [25] Dorit Dor, Shay Halperin, and Uri Zwick. All-pairs almost shortest paths. SIAM Journal on Computing, 29(5):1740–1759, 2000.
  • [26] Ran Duan and Seth Pettie. Linear-time approximation for maximum weight matching. Journal of the ACM (JACM), 61(1):1, 2014.
  • [27] David Eppstein. Dynamic connectivity in digital images. Information Processing Letters, 62(3):121–126, 1997.
  • [28] Jittat Fakcharoenphol and Satish Rao. Planar graphs, negative weight edges, shortest paths, and near linear time. Journal of Computer and System Sciences, 72(5):868–889, 2006. See also FOCS’01.
  • [29] Greg N Frederickson. Data structures for on-line updating of minimum spanning trees, with applications. SIAM Journal on Computing, 14(4):781–798, 1985.
  • [30] Zvi Galil and Giuseppe F Italiano. Maintaining biconnected components of dynamic planar graphs. Springer, 1991.
  • [31] Zvi Galil, Giuseppe F Italiano, and Neil Sarnak. Fully dynamic planarity testing. In Proceedings of the twenty-fourth annual ACM symposium on Theory of computing, pages 495–506. ACM, 1992.
  • [32] Cyril Gavoille, David Peleg, Stéphane Pérennes, and Ran Raz. Distance labeling in graphs. Journal of Algorithms, 53(1):85–112, 2004. See also SODA’01.
  • [33] Pawel Gawrychowski and Adam Karczmarz. Improved bounds for shortest paths in dense distance graphs. CoRR, abs/1602.07013, 2016.
  • [34] Robert Geisberger, Peter Sanders, Dominik Schultes, and Christian Vetter. Exact routing in large road networks using contraction hierarchies. Transportation Science, 46(3):388–404, 2012.
  • [35] Madhu Gupta and Rongkun Peng. Fully dynamic (1+ e)-approximate matchings. In Foundations of Computer Science (FOCS), 2013 IEEE 54th Annual Symposium on, pages 548–557. IEEE, 2013.
  • [36] Rohit Gurjar, Arpita Korwar, Jochen Messner, Simon Straub, and Thomas Thierauf. Planarizing gadgets for perfect matching do not exist. In Mathematical Foundations of Computer Science 2012, pages 478–490. Springer, 2012.
  • [37] Meng He, Ganggui Tang, and Norbert Zeh. Orienting dynamic graphs, with applications to maximal matchings and adjacency queries. In Algorithms and Computation, pages 128–140. Springer, 2014.
  • [38] Monika Henzinger, Sebastian Krinninger, Danupon Nanongkai, and Thatchaphol Saranurak. Unifying and strengthening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In Proc. 47th ACM Symposium on Theory of Computing (STOC), pages 21–30, 2015.
  • [39] Monika R Henzinger, Philip Klein, Satish Rao, and Sairam Subramanian. Faster shortest-path algorithms for planar graphs. journal of computer and system sciences, 55(1):3–23, 1997.
  • [40] Giuseppe F Italiano, Yahav Nussbaum, Piotr Sankowski, and Christian Wulff-Nilsen. Improved algorithms for min cut and max flow in undirected planar graphs. In Proceedings of the forty-third annual ACM symposium on Theory of computing, pages 313–322. ACM, 2011.
  • [41] Haim Kaplan, Shay Mozes, Yahav Nussbaum, and Micha Sharir. Submatrix maximum queries in monge matrices and monge partial matrices, and their applications. In Proceedings of the twenty-third annual ACM-SIAM symposium on Discrete Algorithms, pages 338–355. SIAM, 2012.
  • [42] Philip Klein and Shay Mozes. Optimization algorithms for planar graphs, 2014. Book draft available at http://planarity.org.
  • [43] Philip N Klein. Multiple-source shortest paths in planar graphs. In SODA, volume 5, pages 146–155, 2005.
  • [44] Philip N Klein and Sairam Subramanian. A fully dynamic approximation scheme for shortest paths in planar graphs. Algorithmica, 22(3):235–249, 1998.
  • [45] Tsvi Kopelowitz, Robert Krauthgamer, Ely Porat, and Shay Solomon. Orienting fully dynamic graphs with worst-case time bounds. In Automata, Languages, and Programming, pages 532–543. Springer, 2014.
  • [46] Tsvi Kopelowitz, Seth Pettie, and Ely Porat. Higher lower bounds from the 3sum conjecture. In Proc. 27th ACM/SIAM Symposium on Discrete Algorithms (SODA), pages 1272–1287, 2016.
  • [47] Jakub Łącki, Yahav Nussbaum, Piotr Sankowski, and Christian Wulff-Nilsen. Single source–all sinks max flows in planar digraphs. In Foundations of Computer Science (focs), 2012 Ieee 53rd Annual Symposium on, pages 599–608. IEEE, 2012.
  • [48] Kasper Green Larsen and Ryan Williams. Faster online matrix-vector multiplication. arXiv preprint arXiv:1605.01695, 2016.
  • [49] François Le Gall. Powers of tensors and fast matrix multiplication. In Proceedings of the 39th international symposium on symbolic and algebraic computation, pages 296–303. ACM, 2014.
  • [50] Dániel Marx. On the optimality of planar and geometric approximation schemes. In Foundations of Computer Science, 2007. FOCS’07. 48th Annual IEEE Symposium on, pages 338–348. IEEE, 2007.
  • [51] Dániel Marx. The square root phenomenon in planar graphs. In ICALP (2), page 28, 2013.
  • [52] Ofer Neiman and Shay Solomon. Simple deterministic algorithms for fully dynamic maximal matching. ACM Transactions on Algorithms (TALG), 12(1):7, 2015. See also STOC’13.
  • [53] Krzysztof Onak and Ronitt Rubinfeld. Maintaining a large matching and a small vertex cover. In Proceedings of the forty-second ACM symposium on Theory of computing, pages 457–464. ACM, 2010.
  • [54] Mihai Patrascu. Towards polynomial lower bounds for dynamic problems. In Proc. 42nd ACM Symposium on Theory of Computing (STOC), pages 603–610, 2010.
  • [55] 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.
  • [56] Liam Roditty and Virginia Vassilevska Williams. Fast approximation algorithms for the diameter and radius of sparse graphs. In Proc. 45th ACM Symposium on Theory of Computing (STOC), pages 515–524, 2013.
  • [57] Liam Roditty and Uri Zwick. On dynamic shortest paths problems. Algorithmica, 61(2):389–401, 2011. See also ESA’04.
  • [58] Barna Saha. Language edit distance and maximum likelihood parsing of stochastic grammars: Faster algorithms and connection to fundamental graph problems. In Foundations of Computer Science (FOCS), 2015 IEEE 56th Annual Symposium on, pages 118–135. IEEE, 2015.
  • [59] Piotr Sankowski. Faster dynamic matchings and vertex connectivity. In Proc. 18th ACM/SIAM Symposium on Discrete Algorithms (SODA), pages 118–126, 2007.
  • [60] Dominik Schultes and Peter Sanders. Dynamic highway-node routing. In Experimental Algorithms, pages 66–79. Springer, 2007.
  • [61] Sairam Subramanian. A fully dynamic data structure for reachability in planar digraphs. In Algorithms-ESA’93, pages 372–383. Springer, 1993.
  • [62] Oren Weimann and Raphael Yuster. Approximating the diameter of planar graphs in near linear time. ACM Transactions on Algorithms, 12(1):12, 2016. See also ICALP’13.
  • [63] Virginia Vassilevska Williams. Multiplying matrices faster than coppersmith-winograd. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, pages 887–898. ACM, 2012.
  • [64] Virginia Vassilevska Williams and Ryan Williams. Subcubic equivalences between path, matrix and triangle problems. In Foundations of Computer Science (FOCS), 2010 51st Annual IEEE Symposium on, pages 645–654. IEEE, 2010.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
21008
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description