Expander Decomposition and Pruning: Faster, Stronger, and Simpler

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 which we refer to as {\em 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, 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 $\phi$, our algorithm finds a partition of the vertices into clusters such that each cluster induces a subgraph of conductance at least $\phi$ (i.e. a $\phi$ expander), and only a $\widetilde{O}(\phi)$ fraction of the edges in $G$ have endpoints across different clusters. Our algorithm runs in $\widetilde{O}(m/\phi)$ time, and is the first nearly linear time algorithm when $\phi$ is at least $1/\log^{O(1)} m$, which is the case in most practical settings and theoretical applications. Previous results either take $\Omega(m^{1+o(1)})$ time, or attain nearly linear time but with a weaker expansion guarantee where each output cluster is guaranteed to be contained inside some unknown $\phi$ expander. 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 \emph{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]  Alexander Jung,et al.  Local Graph Clustering With Network Lasso , 2020, IEEE Signal Processing Letters.

[2]  Seth Pettie,et al.  Distributed Triangle Detection via Expander Decomposition , 2018, SODA.

[3]  Richard Peng,et al.  Graph Sparsification, Spectral Sketches, and Faster Resistance Computation, via Short Cycle Decompositions , 2018, 2018 IEEE 59th Annual Symposium on Foundations of Computer Science (FOCS).

[4]  Sebastian Krinninger,et al.  Dynamic low-stretch trees via dynamic low-diameter decompositions , 2018, STOC.

[5]  Aaron Sidford,et al.  Efficient Õ(n/∊) Spectral Sketches for the Laplacian and its Pseudoinverse , 2018, SODA.

[6]  Christian Wulff-Nilsen,et al.  Dynamic Minimum Spanning Forest with Subpolynomial Worst-Case Update Time , 2017, 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS).

[7]  Di Wang,et al.  Capacity Releasing Diffusion for Speed and Locality , 2017, ICML.

[8]  Thatchaphol Saranurak,et al.  Dynamic spanning forest with worst-case update time: adaptive, Las Vegas, and O(n1/2 - ε)-time , 2017, STOC.

[9]  Di Wang,et al.  Local Flow Partitioning for Faster Edge Connectivity , 2017, SODA.

[10]  Christian Wulff-Nilsen,et al.  Fully-dynamic minimum spanning forest with improved worst-case update time , 2016, STOC.

[11]  Richard Peng,et al.  Almost-linear-time algorithms for Markov chains and new spectral primitives for directed graphs , 2016, STOC.

[12]  Aleksander Madry,et al.  Computing Maximum Flow with Augmenting Electrical Flows , 2016, 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS).

[13]  David F. Gleich,et al.  A Simple and Strongly-Local Flow-Based Method for Cut Improvement , 2016, ICML.

[14]  David P. Woodruff,et al.  On Sketching Quadratic Forms , 2015, ITCS.

[15]  Richard Peng,et al.  Approximate Undirected Maximum Flows in O(mpolylog(n)) Time , 2014, SODA.

[16]  Monika Henzinger,et al.  Decremental Single-Source Shortest Paths on Undirected Graphs in Near-Linear Total Update Time , 2014, 2014 IEEE 55th Annual Symposium on Foundations of Computer Science.

[17]  Yin Tat Lee,et al.  Path Finding Methods for Linear Programming: Solving Linear Programs in Õ(vrank) Iterations and Faster Algorithms for Maximum Flow , 2014, 2014 IEEE 55th Annual Symposium on Foundations of Computer Science.

[18]  Monika Henzinger,et al.  Sublinear-time decremental algorithms for single-source reachability and shortest paths on directed graphs , 2014, STOC.

[19]  Chintan Shah,et al.  Computing Cut-Based Hierarchical Decompositions in Almost Linear Time , 2014, SODA.

[20]  Zeyuan Allen Zhu,et al.  Flow-Based Algorithms for Local Graph Clustering , 2013, SODA.

[21]  Yin Tat Lee,et al.  An Almost-Linear-Time Algorithm for Approximate Max Flow in Undirected Graphs, and its Multicommodity Generalizations , 2013, SODA.

[22]  Jonah Sherman,et al.  Nearly Maximum Flows in Nearly Linear Time , 2013, 2013 IEEE 54th Annual Symposium on Foundations of Computer Science.

[23]  Bruce M. Kapron,et al.  Dynamic graph connectivity in polylogarithmic worst case time , 2013, SODA.

[24]  Soumojit Sarkar,et al.  Fully dynamic randomized algorithms for graph spanners , 2012, TALG.

[25]  Luca Trevisan,et al.  Approximating the Expansion Profile and Almost Optimal Local Graph Clustering , 2012, 2012 IEEE 53rd Annual Symposium on Foundations of Computer Science.

[26]  Nisheeth K. Vishnoi,et al.  Approximating the exponential, the lanczos method and an Õ(m)-time spectral algorithm for balanced separator , 2011, STOC '12.

[27]  Sandeep Sen,et al.  Fully Dynamic Maximal Matching in O (log n) Update Time , 2011, 2011 IEEE 52nd Annual Symposium on Foundations of Computer Science.

[28]  Nisheeth K. Vishnoi,et al.  Towards an SDP-based approach to spectral methods: a nearly-linear-time algorithm for graph partitioning and decomposition , 2010, SODA '11.

[29]  Jonah Sherman,et al.  Breaking the Multicommodity Flow Barrier for O(vlog n)-Approximations to Sparsest Cut , 2009, 2009 50th Annual IEEE Symposium on Foundations of Computer Science.

[30]  Santo Fortunato,et al.  Community detection in graphs , 2009, ArXiv.

[31]  Sanjeev Arora,et al.  Expander flows, geometric embeddings and graph partitioning , 2009, JACM.

[32]  Yuval Peres,et al.  Finding sparse cuts locally using evolving sets , 2008, STOC '09.

[33]  Shang-Hua Teng,et al.  A Local Clustering Algorithm for Massive Graphs and Its Application to Nearly Linear Time Graph Partitioning , 2008, SIAM J. Comput..

[34]  Shang-Hua Teng,et al.  Spectral Sparsification of Graphs , 2008, SIAM J. Comput..

[35]  Nisheeth K. Vishnoi,et al.  On partitioning graphs via single commodity flows , 2008, STOC.

[36]  Kevin J. Lang,et al.  An algorithm for improving graph partitions , 2008, SODA '08.

[37]  Mikkel Thorup,et al.  Planning for Fast Connectivity Updates , 2007, 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS'07).

[38]  Kevin J. Lang,et al.  Local Graph Partitioning using PageRank Vectors , 2006, 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS'06).

[39]  Satish Rao,et al.  Graph partitioning using single commodity flows , 2006, STOC '06.

[40]  Luca Trevisan,et al.  Approximation algorithms for unique games , 2005, 46th Annual IEEE Symposium on Foundations of Computer Science (FOCS'05).

[41]  Satish Rao,et al.  A Flow-Based Method for Improving the Expansion or Conductance of Graph Cuts , 2004, IPCO.

[42]  Shang-Hua Teng,et al.  Nearly-linear time algorithms for graph partitioning, graph sparsification, and solving linear systems , 2003, STOC '04.

[43]  Santosh S. Vempala,et al.  On clusterings-good, bad and spectral , 2000, Proceedings 41st Annual Symposium on Foundations of Computer Science.

[44]  M. Henzinger,et al.  Randomized fully dynamic graph algorithms with polylogarithmic time per operation , 1999, JACM.

[45]  M. Thorup,et al.  Poly-logarithmic deterministic fully-dynamic algorithms for connectivity, minimum spanning tree, 2-edge, and biconnectivity , 1998, STOC '98.

[46]  Jitendra Malik,et al.  Normalized cuts and image segmentation , 1997, Proceedings of IEEE Computer Society Conference on Computer Vision and Pattern Recognition.

[47]  David Eppstein,et al.  Sparsification-a technique for speeding up dynamic graph algorithms , 1992, Proceedings., 33rd Annual Symposium on Foundations of Computer Science.

[48]  A. Goldberg,et al.  A new approach to the maximum-flow problem , 1988, JACM.

[49]  Greg N. Frederickson,et al.  Data Structures for On-Line Updating of Minimum Spanning Trees, with Applications , 1985, SIAM J. Comput..

[50]  Robert E. Tarjan,et al.  A data structure for dynamic trees , 1981, STOC '81.

[51]  Lap Chi Lau,et al.  Graph Clustering using Effective Resistance , 2018, ITCS.

[52]  Satish Rao,et al.  Graph partitioning using single commodity flows , 2009, JACM.

[53]  Andrew V. Goldberg,et al.  Finding a Maximum Density Subgraph , 1984 .

[54]  Shimon Even,et al.  An On-Line Edge-Deletion Problem , 1981, JACM.

[55]  J. Cheeger A lower bound for the smallest eigenvalue of the Laplacian , 1969 .