Consider the following Online Boolean Matrix-Vector Multiplication problem: We are given an n × n matrix M and will receive n column-vectors of size n, denoted by v 1 , . . . , v n , one by one. After seeing each vector v i , we have to output the product M v i before we can see the next vector. A naive algorithm can solve this problem using O(n 3 ) time in total, and its running time can be slightly improved to O(n 3 / log 2 n) [Williams SODA'07]. We show that a conjecture that there is no truly subcubic (O(n 3− )) time algorithm for this problem can be used to exhibit the underlying polynomial time hardness shared by many dynamic problems. For a number of problems, such as subgraph connectivity, Pagh's problem, dfailure connectivity, decremental single-source shortest paths, and decremental transitive closure, this conjecture implies tight hardness results. Thus, proving or disproving this conjecture will be very interesting as it will either imply several tight unconditional lower bounds or break through a common barrier that blocks progress with these problems. This conjecture might also be considered as strong evidence against any further improvement for these problems since refuting it will imply a major breakthrough for combinatorial Boolean matrix multiplication and other long-standing problems if the term "combinatorial algorithms" is interpreted as "Strassenlike algorithms" [Ballard et al. SPAA'11].The conjecture also leads to hardness results for problems that were previously based on diverse problems and conjectures -such as 3SUM, combinatorial Boolean matrix multiplication, triangle detection, and multiphase -thus providing a uniform way to prove polynomial hardness results for dynamic algorithms; some of the new proofs are also simpler or even become trivial. The conjecture also leads to stronger and new, non-trivial, hardness results, e.g., for the fullydynamic densest subgraph and diameter problems.

We study the problem of graph clustering where the goal is to partition a graph into clusters, i.e. disjoint subsets of vertices, such that each cluster is well connected internally while sparsely connected to the rest of the graph. In particular, we use a natural bicriteria notion motivated by Kannan, Vempala, and Vetta [KVV00] which we refer to as expander decomposition. Expander decomposition has become one of the building blocks in the design of fast graph algorithms, most notably in the nearly linear time Laplacian solver by Spielman and Teng [ST04], and it also has wide applications in practice.We design algorithm for the parametrized version of expander decomposition, where given a graph G of m edges and a parameter φ, our algorithm finds a partition of the vertices into clusters such that each cluster induces a subgraph of conductance at least φ (i.e. a φ expander), and only a O(φ) fraction of the edges in G have endpoints across different clusters. Our algorithm runs in O(m/φ) time, and is the first nearly linear time algorithm when φ is at least 1/ log O(1) m, which is the case in most practical settings and theoretical applications. Previous results either take Ω(m 1+o(1) ) time (e.g. [NS17, Wul17]), or attain nearly linear time but with a weaker expansion guarantee where each output cluster is guaranteed to be contained inside some unknown φ expander (e.g. [ST13, ACL06]). Our result achieve both nearly linear running time and the strong expander guarantee for clusters. Moreover, a main technique we develop for our result can be applied to obtain a much better expander pruning algorithm, which is the key tool for maintaining an expander decomposition on dynamic graphs. Finally, we note that our algorithm is developed from first principles based on relatively simple and basic techniques, thus making it very likely to be practical.1 Each self-loop contributes 1 to the degree of a node.

We present two algorithms for dynamically maintaining a spanning forest of a graph undergoing edge insertions and deletions. Our algorithms guarantee worst-case update time and work against an adaptive adversary, meaning that an edge update can depend on previous outputs of the algorithms. We provide the first polynomial improvement over the long-standing O( √ n)bound of [Frederickson STOC'83, Eppstein, Galil, Italiano and Nissenzweig FOCS'92] for such type of algorithms. The previously best improvement was O( n(log log n) 2 / log n) [Kejlberg-Rasmussen, Kopelowitz, Pettie and Thorup ESA'16]. We note however that these bounds were obtained by deterministic algorithms while our algorithms are randomized. Our first algorithm is Monte Carlo and guarantees an O(n 0.4+o(1) ) worst-case update time, where the o(1) term hides the O( log log n/ log n) factor. Our second algorithm is Las Vegas and guarantees an O(n 0.49306 ) worst-case update time with high probability. Algorithms with better update time either needed to assume that the adversary is oblivious (e.g. [Kapron, King and Mountjoy SODA'13]) or can only guarantee an amortized update time. Our second result answers an open problem by Kapron et al. To the best of our knowledge, our algorithms are among a few non-trivial randomized dynamic algorithms that work against adaptive adversaries.The key to our results is a decomposition of graphs into subgraphs that either have high expansion or sparse. This decomposition serves as an interface between recent developments on (static) flow computation and many old ideas in dynamic graph algorithms: On the one hand, we can combine previous dynamic graph techniques to get faster dynamic spanning forest algorithms if such decomposition is given. On the other hand, we can adapt flow-related techniques (e.g. those from [Khandekar, Rao and Vazirani STOC'06], [Peng SODA'16], and [Orecchia and Zhu SODA'14]) to maintain such decomposition. To the best of our knowledge, this is the first time these flow techniques are used in fully dynamic graph algorithms.

We study computing all-pairs shortest paths (APSP) on distributed networks (the CONGEST model). The goal is for every node in the (weighted) network to know the distance from every other node using communication. The problem admits (1 + o(1))-approximationÕ(n)-time algorithms [LP15, Nan14], which are matched withΩ(n)-time lower bounds [Nan14, LPS13, FHW12] 1 . No ω(n) lower bound or o(m) upper bound were known for exact computation.In this paper, we present anÕ(n 5/4 )-time randomized (Las Vegas) algorithm for exact weighted APSP; this provides the first improvement over the naive O(m)-time algorithm when the network is not so sparse. Our result also holds for the case where edge weights are asymmetric (a.k.a. the directed case where communication is bidirectional). Our techniques also yield anÕ(n 3/4 k 1/2 + n)-time algorithm for the k-source shortest paths problem where we want every node to know distances from k sources; this improves Elkin's recent bound [Elk17b] when k =ω(n 1/4 ).We achieve the above results by developing distributed algorithms on top of the classic scaling technique, which we believe is used for the first time for distributed shortest paths computation. One new algorithm which might be of an independent interest is for the reversed r-sink shortest paths problem, where we want every of r sinks to know its distances from all other nodes, given that every node already knows its distance to every sink. We show anÕ(n √ r)-time algorithm for this problem. Another new algorithm is called short range extension, where we show that inÕ(n √ h) time the knowledge about distances can be "extended" for additional h hops. For this, we use weight rounding to introduce small additive errors which can be later fixed.Remark: Independently from our result, Elkin recently observed in [Elk17b] that the same techniques from an earlier version of the same paper (https://arxiv.org/abs/ 1703.01939v1) led to an O(n 5/3 log 2/3 n)-time algorithm. 1Θ,Õ andΩ hide polylogarithmic factors. Note that the lower bounds also hold even in the unweighted case and in the weighted case with polynomial approximation ratios.2 See also [PRS17, Elk17a] for recent results. 3 For the maximum flow algorithm, there is an extra n o(1) term in the time complexity.

We present a Las Vegas algorithm for dynamically maintaining a minimum spanning forest of an n-node graph undergoing edge insertions and deletions. Our algorithm guarantees an O(n o(1) ) worst-case update time with high probability. This significantly improves the two recent Las Vegas algorithms by Wulff-Nilsen [37] with update time O(n 0.5−ǫ ) for some constant ǫ > 0 and, independently, by Nanongkai and Saranurak [24] with update time O(n 0.494 ) (the latter works only for maintaining a spanning forest).Our result is obtained by identifying the common framework that both two previous algorithms rely on, and then improve and combine the ideas from both works. There are two main algorithmic components of the framework that are newly improved and critical for obtaining our result. First, we improve the update time from O(n 0.5−ǫ ) in [37] to O(n o(1) ) for decrementally removing all low-conductance cuts in an expander undergoing edge deletions. Second, by revisiting the "contraction technique" by Henzinger and King [15] and Holm et al. [19], we show a new approach for maintaining a minimum spanning forest in connected graphs with very few (at most (1 + o(1))n) edges. This significantly improves the previous approach in [37,24] which is based on Frederickson's 2-dimensional topology tree [11] and illustrates a new application to this old technique.