skip to main content
US FlagAn official website of the United States government
dot gov icon
Official websites use .gov
A .gov website belongs to an official government organization in the United States.
https lock icon
Secure .gov websites use HTTPS
A lock ( lock ) or https:// means you've safely connected to the .gov website. Share sensitive information only on official, secure websites.


Title: Eulerian Graph Sparsification by Effective Resistance Decomposition
The authors present an algorithm that, given an n-vertex m-edge Eulerian graph with polynomially bounded weights, computes an 𝑂 ~ ( 𝑛 log ⁑ 2 𝑛 β‹… πœ€ βˆ’ 2 ) O ~ (nlog 2 nβ‹…Ξ΅ βˆ’2 )-edge πœ€ Ξ΅-approximate Eulerian sparsifier with high probability in 𝑂 ~ ( π‘š log ⁑ 3 𝑛 ) O ~ (mlog 3 n) time (where 𝑂 ~ ( β‹… ) O ~ (β‹…) hides polyloglog(n) factors). By a reduction from Peng-Song (STOC ’22), this yields an 𝑂 ~ ( π‘š log ⁑ 3 𝑛 + 𝑛 log ⁑ 6 𝑛 ) O ~ (mlog 3 n+nlog 6 n)-time algorithm for solving n-vertex m-edge Eulerian Laplacian systems with polynomially bounded weights with high probability, improving on the previous state-of-the-art runtime of Ξ© ( π‘š log ⁑ 8 𝑛 + 𝑛 log ⁑ 23 𝑛 ) Ξ©(mlog 8 n+nlog 23 n). They also provide a polynomial-time algorithm that computes sparsifiers with 𝑂 ( min ⁑ ( 𝑛 log ⁑ 𝑛 β‹… πœ€ βˆ’ 2 + 𝑛 log ⁑ 5 / 3 𝑛 β‹… πœ€ βˆ’ 4 / 3 , 𝑛 log ⁑ 3 / 2 𝑛 β‹… πœ€ βˆ’ 2 ) ) O(min(nlognβ‹…Ξ΅ βˆ’2 +nlog 5/3 nβ‹…Ξ΅ βˆ’4/3 ,nlog 3/2 nβ‹…Ξ΅ βˆ’2 )) edges, improving the previous best bounds. Furthermore, they extend their techniques to yield the first 𝑂 ( π‘š β‹… polylog ( 𝑛 ) ) O(mβ‹…polylog(n))-time algorithm for computing 𝑂 ( 𝑛 πœ€ βˆ’ 1 β‹… polylog ( 𝑛 ) ) O(nΞ΅ βˆ’1 β‹…polylog(n))-edge graphical spectral sketches, along with a natural Eulerian generalization. Unlike prior approaches using short cycle or expander decompositions, their algorithms leverage a new effective resistance decomposition scheme, combined with natural sampling and electrical routing for degree balance. The analysis applies asymmetric variance bounds specialized to Eulerian Laplacians and tools from discrepancy theory.  more » « less
Award ID(s):
2505865
PAR ID:
10631909
Author(s) / Creator(s):
; ; ; ;
Publisher / Repository:
https://doi.org/10.48550/arXiv.2408.10172
Date Published:
Format(s):
Medium: X
Sponsoring Org:
National Science Foundation
More Like this
  1. Chan, Timothy; Fischer, Johannes; Iacono, John; Herman, Grzegorz (Ed.)
    We describe a simple deterministic near-linear time approximation scheme for uncapacitated minimum cost flow in undirected graphs with positive real edge weights, a problem also known as transshipment. Specifically, our algorithm takes as input a (connected) undirected graph G = (V, E), vertex demands b ∈ R^V such that βˆ‘_{v ∈ V} b(v) = 0, positive edge costs c ∈ R_{β‰₯ 0}^E, and a parameter Ξ΅ > 0. In O(Ξ΅^{-2} m log^{O(1)} n) time, it returns a flow f such that the net flow out of each vertex is equal to the vertex’s demand and the cost of the flow is within a (1 Β± Ξ΅) factor of optimal. Our algorithm is combinatorial and has no running time dependency on the demands or edge costs. With the exception of a recent result presented at STOC 2022 for polynomially bounded edge weights, all almost- and near-linear time approximation schemes for transshipment relied on randomization to embed the problem instance into low-dimensional space. Our algorithm instead deterministically approximates the cost of routing decisions that would be made if the input were subject to a random tree embedding. To avoid computing the Ξ©(nΒ²) vertex-vertex distances that an approximation of this kind suggests, we also take advantage of the clustering method used in the well-known Thorup-Zwick distance oracle. 
    more » « less
  2. Given a set P of n weighted points and a set S of m disks in the plane, the hitting set problem is to compute a subset 𝑃′ of points of P such that each disk contains at least one point of 𝑃′ and the total weight of all points of 𝑃′ is minimized. The problem is known to be NP-hard. In this paper, we consider a line-constrained version of the problem in which all disks are centered on a line β„“. We present an 𝑂((π‘š+𝑛)log(π‘š+𝑛)+πœ…logπ‘š) time algorithm for the problem, where πœ… is the number of pairs of disks that intersect. For the unit-disk case where all disks have the same radius, the running time can be reduced to 𝑂((𝑛+π‘š)log(π‘š+𝑛)). In addition, we solve the problem in 𝑂((π‘š+𝑛)log(π‘š+𝑛)) time in the 𝐿∞ and 𝐿1 metrics, in which a disk is a square and a diamond, respectively. 
    more » « less
  3. We consider the problem of space-efficiently estimating the number of simplices in a hypergraph stream. This is the most natural hypergraph generalization of the highly-studied problem of estimating the number of triangles in a graph stream. Our input is a k-uniform hypergraph H with n vertices and m hyperedges, each hyperedge being a k-sized subset of vertices. A k-simplex in H is a subhypergraph on k+1 vertices X such that all k+1 possible hyperedges among X exist in H. The goal is to process the hyperedges of H, which arrive in an arbitrary order as a data stream, and compute a good estimate of T_k(H), the number of k-simplices in H. We design a suite of algorithms for this problem. As with triangle-counting in graphs (which is the special case k = 2), sublinear space is achievable but only under a promise of the form T_k(H) β‰₯ T. Under such a promise, our algorithms use at most four passes and together imply a space bound of O(Ξ΅^{-2} log Ξ΄^{-1} polylog n β‹… min{(m^{1+1/k})/T, m/(T^{2/(k+1)})}) for each fixed k β‰₯ 3, in order to guarantee an estimate within (1Β±Ξ΅)T_k(H) with probability β‰₯ 1-Ξ΄. We also give a simpler 1-pass algorithm that achieves O(Ξ΅^{-2} log Ξ΄^{-1} log nβ‹… (m/T) (Ξ”_E + Ξ”_V^{1-1/k})) space, where Ξ”_E (respectively, Ξ”_V) denotes the maximum number of k-simplices that share a hyperedge (respectively, a vertex), which generalizes a previous result for the k = 2 case. We complement these algorithmic results with space lower bounds of the form Ξ©(Ξ΅^{-2}), Ξ©(m^{1+1/k}/T), Ξ©(m/T^{1-1/k}) and Ξ©(mΞ”_V^{1/k}/T) for multi-pass algorithms and Ξ©(mΞ”_E/T) for 1-pass algorithms, which show that some of the dependencies on parameters in our upper bounds are nearly tight. Our techniques extend and generalize several different ideas previously developed for triangle counting in graphs, using appropriate innovations to handle the more complicated combinatorics of hypergraphs. 
    more » « less
  4. The authors provide the first tight sample complexity bounds for shadow tomography and classical shadows in the regime where the target error is below some sufficiently small inverse polynomial in the dimension of the Hilbert space. Specifically, they present a protocol that, given any π‘š ∈ 𝑁 m∈N and πœ– ≀ 𝑂 ( 𝑑 βˆ’ 1 / 2 ) ϡ≀O(d βˆ’1/2 ), measures 𝑂 ( log ⁑ ( π‘š ) / πœ– 2 ) O(log(m)/Ο΅ 2 ) copies of an unknown mixed state 𝜌 ∈ 𝐢 𝑑 Γ— 𝑑 ρ∈C dΓ—d and outputs a classical description of 𝜌 ρ. This description can then be used to estimate any collection of π‘š m observables to within additive accuracy πœ– Ο΅. Previously, even for the simpler case of shadow tomography where observables are known in advance, the best known rates either scaled benignly but suboptimally in all of π‘š , 𝑑 , πœ– m,d,Ο΅, or scaled optimally in πœ– , π‘š Ο΅,m but included additional polynomial factors in 𝑑 d. Interestingly, the authors also show via dimensionality reduction that one can rescale πœ– Ο΅ and 𝑑 d to reduce to the regime where πœ– ≀ 𝑂 ( 𝑑 βˆ’ 1 / 2 ) ϡ≀O(d βˆ’1/2 ). Their algorithm draws on representation-theoretic tools developed in the context of full state tomography. 
    more » « less
  5. Mulzer, Wolfgang; Phillips, Jeff M (Ed.)
    Given in the plane a set of points and a set of halfplanes, we consider the problem of computing a smallest subset of halfplanes whose union covers all points. In this paper, we present an O(n^{4/3}log^{5/3}nlog^{O(1)}log n)-time algorithm for the problem, where n is the total number of all points and halfplanes. This improves the previously best algorithm of n^{10/3}2^{O(log^*n)} time by roughly a quadratic factor. For the special case where all halfplanes are lower ones, our algorithm runs in O(nlog n) time, which improves the previously best algorithm of n^{4/3}2^{O(log^*n)} time and matches an Ξ©(nlog n) lower bound. Further, our techniques can be extended to solve a star-shaped polygon coverage problem in O(nlog n) time, which in turn leads to an O(nlog n)-time algorithm for computing an instance-optimal Ξ΅-kernel of a set of n points in the plane. Agarwal and Har-Peled presented an O(nklog n)-time algorithm for this problem in SoCG 2023, where k is the size of the Ξ΅-kernel; they also raised an open question whether the problem can be solved in O(nlog n) time. Our result thus answers the open question affirmatively. 
    more » « less