---
res:
  bibo_abstract:
  - 'Over the last two decades, a significant line of work in theoretical algorithms
    has made progress in solving linear systems of the form Lx=b, where L is the Laplacian
    matrix of a weighted graph with weights w(i,j)>0 on the edges. The solution x
    of the linear system can be interpreted as the potentials of an electrical flow
    in which the resistance on edge (i, j) is 1/w(i, j). Kelner et al. (in: Proceedings
    of the 45th Annual ACM Symposium on the Theory of Computing, pp 911–920, 2013.
    https://doi.org/10.1145/2488608.2488724) give a combinatorial, near-linear time
    algorithm that maintains the Kirchoff Current Law, and gradually enforces the
    Kirchoff Potential Law by updating flows around cycles (cycle toggling). In this
    paper, we consider a dual version of the algorithm that maintains the Kirchoff
    Potential Law, and gradually enforces the Kirchoff Current Law by cut toggling:
    each iteration updates all potentials on one side of a fundamental cut of a spanning
    tree by the same amount. We prove that this dual algorithm also runs in a near-linear
    number of iterations. We show, however, that if we abstract cut toggling as a
    natural data structure problem, this problem can be reduced to the online vector–matrix-vector
    problem, which has been conjectured to be difficult for dynamic algorithms (Henzinger
    et al., in: Proceedings of the 47th Annual ACM Symposium on the Theory of Computing,
    pp 21–30, 2015. https://doi.org/10.1145/2746539.2746609). The conjecture implies
    that the data structure does not have an O(n1−ϵ) time algorithm for any ϵ>0, and
    thus a straightforward implementation of the cut-toggling algorithm requires essentially
    linear time per iteration. To circumvent the lower bound, we batch update steps,
    and perform them simultaneously instead of sequentially. An appropriate choice
    of batching leads to an O˜(m1.5) time cut-toggling algorithm for solving Laplacian
    systems. Furthermore, we show that if we sparsify the graph and call our algorithm
    recursively on the Laplacian system implied by batching and sparsifying, we can
    reduce the running time to O(m1+ϵ) for any ϵ>0. Thus, the dual cut-toggling algorithm
    can achieve (almost) the same running time as its primal cycle-toggling counterpart.@eng'
  bibo_authorlist:
  - foaf_Person:
      foaf_givenName: Monika H
      foaf_name: Henzinger, Monika H
      foaf_surname: Henzinger
      foaf_workInfoHomepage: http://www.librecat.org/personId=540c9bbd-f2de-11ec-812d-d04a5be85630
    orcid: 0000-0002-5008-6530
  - foaf_Person:
      foaf_givenName: Billy
      foaf_name: Jin, Billy
      foaf_surname: Jin
  - foaf_Person:
      foaf_givenName: Richard
      foaf_name: Peng, Richard
      foaf_surname: Peng
  - foaf_Person:
      foaf_givenName: David P.
      foaf_name: Williamson, David P.
      foaf_surname: Williamson
  bibo_doi: 10.1007/s00453-023-01154-8
  bibo_volume: 85
  dct_date: 2023^xs_gYear
  dct_identifier:
  - UT:001041254900002
  dct_isPartOf:
  - http://id.crossref.org/issn/0178-4617
  - http://id.crossref.org/issn/1432-0541
  dct_language: eng
  dct_publisher: Springer Nature@
  dct_title: A combinatorial cut-toggling algorithm for solving Laplacian linear systems@
...