Persistent (Co)Homology in Matrix Multiplication Time

Dmitriy Morozov; Primoz Skraba

REVIEW 3 major objections 3 minor 1 cited by

Persistent (Co)Homology in Matrix Multiplication Time

T0 review · 3 major / 3 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Persistent homology representatives can be computed in matrix multiplication time, matching the cost of the persistence diagram itself.

desk verdict Solid exhaustive-reduction algorithm, but the lazy-reduction row algorithm looks broken as written and is not adequately proven. read the letter →

arxiv 2412.02591 v2 pith:AJT6AC3V submitted 2024-12-03 math.AT cs.CC

Dmitriy Morozov , Primoz Skraba This is my paper · ORCID

classification math.ATcs.CC MSC 55N3155-0868W40

keywords persistenthomologycohomologycyclerepresentativesR=DVdecompositionlazyreductionexhaustivematrixmultiplicationtime

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper's central claim is that the full $R=DV$ decomposition of a persistent (co)homology boundary matrix—including the cycle and cocycle representatives it encodes—can be computed in matrix multiplication time, matching the asymptotic cost of computing the persistence diagram alone. Concretely, it gives two algorithms: a column algorithm for the exhaustive reduction and a row algorithm for the lazy reduction, each running in $O(n^\omega)$ over a fixed field, or $O(n^2\log n)$ when the matrix multiplication exponent $\omega$ equals 2. This matters because applications routinely use the specific representatives produced by these reductions for attribution, point-cloud triangulation, and topological optimization, and previously only the diagram, not the representatives, was known to admit this bound. The paper also observes that applying the same algorithms to the anti-transpose of the boundary matrix gives persistent cohomology, and that the fast zigzag construction makes this another route to zigzag persistence in matrix multiplication time.

What carries the argument

The load-bearing identity is $R=DV$, where $D$ is the filtration-ordered boundary matrix, $V$ is a full-rank upper-triangular matrix of column operations, and $R$ is column-reduced; the columns of $V$ and $R$ provide the cycle and cocycle representatives. The second mechanism is the Schur complement: when a submatrix of pivot rows is lower triangular (hence invertible), the update $R[\bar{L},C] \leftarrow R[\bar{L},C] - R[\bar{L},B]\cdot R[L,B]^{-1}\cdot R[L,C]$ applies all column reductions from block $B$ to block $C$ in one matrix product. The row algorithm replaces inversion with column permutations that keep every column with a lower pivot to the left of the current pivot, allowing one batched row-zeroing update per pivot. These batch operations are what bring the complexity down from cubic time to matrix multiplication time.

What would settle it

Implement Algorithm 5 over a fixed field and compare its output against Algorithm 4 (the incremental lazy reduction) on all simplicial complexes with up to six vertices and every total-order extension of their face posets; any filtration where the pivot positions (the low values) of the two algorithms differ, or where the recovered cycle representatives differ, would refute Theorem 5.3. A smaller targeted check is to construct a boundary matrix where the row algorithm's column permutation places a column with a lower pivot to the right of the current pivot and verify that the batched row zeroing in Line 5 still matches the lazy reduction.

Watch

Extended reading notes

Core claim

On its own terms, the paper establishes that there is no asymptotic price for the standard representatives in ordinary persistent (co)homology. For the exhaustive reduction, Algorithm 3 uses batched Schur-complement updates that reduce blocks of columns at once after permuting pivot rows to the bottom, yielding $R=DV$ with the same column-reduced form as a full look-ahead reduction. For the lazy reduction, Algorithm 5 works bottom-up on rows, using column permutations to align leftmost eligible pivots and then zeroing whole rows in one batch; Lemma 5.1 and Theorem 5.3 assert this reproduces exactly the standard lazy reduction's $R$, $V$, and hence its representatives. Because $V$ is upper triangular and $U = 2I - \Lambda$ in the lazy case, representatives, pairings, and the persistence diagram all come out of the same $O(n^\omega)$ computation.

Load-bearing premise

The fast row algorithm's correctness rests on the invariant that after every column permutation, every column whose lowest nonzero entry lies below the current row has been moved to the left of the current pivot position; if that invariant ever failed, zeroing the whole row to the right would silently skip reductions that the lazy algorithm would still perform.

Editorial extensions

If this is right

Persistence diagrams and the cycle representatives produced by either the lazy or exhaustive reduction become simultaneously available in $O(n^\omega)$ time, so applications that currently run a second, slower reduction to obtain representatives pay no asymptotic extra cost.
All the algorithms transfer to persistent cohomology by applying the same reduction to the anti-transpose of the boundary matrix, giving cocycle representatives with the same time bound.
Combined with the fast zigzag construction for reducing zigzag persistence to ordinary persistence, these algorithms provide another matrix-multiplication-time route to zigzag persistence, extending the reach of the $R=DV$ formulation beyond ordinary filtrations.
Because the row algorithm returns the same representatives as the standard lazy persistence algorithm, it can serve as a drop-in replacement for standard pipelines that need the usual basis, not just the barcode.
The exhaustive reduction's representatives are the lexicographically optimal cycles used in point-cloud triangulation, so those optimal representatives now come with the same asymptotic guarantee as the barcode.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

With both target reductions at the matrix-multiplication bound, the practical bottleneck shifts from asymptotic complexity to constant factors and the cost of field operations; implementations could plausibly switch between block matrix products and standard column reduction depending on block size, a trade-off the paper does not explore.
The invariant behind the row algorithm suggests a general recipe: batched reductions are safe exactly when the permutation removes all later columns with lower pivots to the left. Adapting that recipe to other reduction orders, such as output-sensitive or parallel schemes, could yield additional algorithms with the same complexity bound, though the paper makes no such claim.
If the paper's stated open question about transforming exhaustive representatives into lazy ones (and vice versa) without rerunning the reduction is resolved, a single matrix-multiplication-time reduction would serve every application that needs either basis.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The column algorithm (Algorithm 3) is the real contribution. The Schur-complement batching is clean, the proof of Lemmas 4.3–4.4 and Theorem 4.5 holds up, and the running time O(n^ω) is sound. This gives cycle representatives for exhaustive reduction in matrix multiplication time, which is genuinely new and useful. I also like the observation U = 2I − Λ in Theorem 5.4, and the Dey–Hou connection is a nice extra.

The trouble is Algorithm 5, the fast lazy-reduction row algorithm. The proof of Theorem 5.3 is a sketch that leans on an invariant in Remark 5.2 and a citation to [3, Theorem 3.1]. The concrete F2 counterexample in the stress-test note looks real to me: line 11 multiplies by the full row of P·Λ·P, including the identity/diagonal entries, so the pivot column’s entries get added to columns that should not be touched. In the n=4 example, column 7 (I3) is corrupted and the final R does not match lazy reduction. Even if the notational ambiguity about P·Λ·P might rescue the algorithm in some modified form, the proof does not explain why those identity entries should be excluded from the batch update, and the pseudocode as written includes them. That is a load-bearing gap, not a minor typo.

There are also formatting issues in Section 5.1 (the initialization of R and Λ is nearly unreadable), which make it even harder to verify the algorithm.

Who gets value from this: computational topologists who care about asymptotic bounds for persistence with representatives. The exhaustive half is worth citing and building on. The lazy half, as written, should not be trusted until it is either fixed or given a much more careful proof that explicitly handles the diagonal of Λ. I would send this to a serious referee—the column algorithm alone justifies referee time—but the referee should be instructed to focus on Algorithm 5 and the stress-test-style counterexample, and to demand a corrected version or a fully formal proof.

Referee Report

3 major / 3 minor

Summary. The paper presents two algorithms for computing the R = DV decomposition in persistent (co)homology in matrix multiplication time, with the goal of recovering cycle representatives in the same asymptotic time as computing the persistence diagram. Algorithm 3 is a fast "exhaustive" reduction based on Schur complements, and Algorithm 5 is a fast "lazy" reduction based on bottom-up batched row updates. The authors claim that the latter reproduces exactly the lazy reduction of the standard persistence algorithm, including its cycle representatives, in O(n^ω) time (O(n^2 log n) when ω = 2).

Significance. If both algorithms were correct, the paper would close a notable gap: persistence diagrams were already known to be computable in matrix multiplication time, but extracting the specific cycle representatives used in applications was not known to have the same bound. The column algorithm in Section 4 is an elegant and apparently correct specialization of the zigzag algorithm of Milosavljevic et al., and the running-time analysis for it is convincing. However, the row algorithm in Section 5 is the load-bearing contribution for the lazy reduction, and it has a concrete correctness problem that is not addressed by the proof of Theorem 5.3. Since the central claim of the paper depends on this algorithm, the manuscript needs substantial revision before the claimed result can be accepted.

major comments (3)

[§5.1, Algorithm 5, line 11] The batched row update in line 11 applies the full row (P·Λ·P)[B,·], including the diagonal identity entries that Λ inherits from its initialization as I_{m+n}. These identity entries are self/pivot coefficients, not reduction coefficients, and using them adds the pivot columns themselves to the rows in Cr. This corrupts the lazy reduction. Concretely, over F_2 with n = 4 and D having columns c1 = c2 = c4 = 0 and c3 = (1,1,0,0), augmented with I_4, running Algorithm 5 literally makes column 7 (the third identity column) equal to (1,0,1,0) after the row-2 update, whereas Algorithm 4 and standard lazy reduction leave R[1,7] = 0. Thus Algorithm 5, as written, does not compute the lazy reduction.
[Theorem 5.3 and Remark 5.2] The proof of Theorem 5.3 asserts that the batched operations reproduce Algorithm 4, but it never explains why the identity entries on the diagonal of P·Λ·P should not be applied during the row updates. Remark 5.2 only guarantees that columns whose pivots lie below the current row have been moved to the left of the current pivot; it does not guarantee that those columns are not modified. In the example above, the corrupted column lies to the left of the row-1 pivot and is therefore never zeroed by the base-case row clearing, so the invariant cannot catch the error. A correct proof must either exclude the diagonal entries from the row update or show they cancel through some additional mechanism.
[Theorem 5.4 and §2.2] Because Theorem 5.4 and the claimed recovery of lazy cycle representatives from U and V depend on Algorithm 5 actually performing the lazy reduction, the failure described above invalidates the advertised representative-recovery result for the lazy reduction. The paper's central claim in the introduction that Algorithm 5 computes the lazy reduction is therefore not established by the current manuscript.

minor comments (3)

[Theorem 5.4 proof] The proof contains a duplicated sentence about a column that 'has not been used to reduce any other column'; the repetition should be removed.
[Section 6] The sentence about using the column algorithm to compute the lazy basis and the row algorithm for the exhaustive basis is easy to misread as reversing the roles of the two algorithms; consider rephrasing for clarity.
[Lemma 5.1] The proof of Lemma 5.1 is a bare citation to [3, Theorem 3.1]. Since the terminology 'lazy reduction' may not match the cited theorem's conventions, a short explanation of the correspondence would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the algorithms are explicit reductions, and author-overlapping citations are independent published theorems.

full rationale

The paper's derivation chain is algorithmic rather than definitional: it constructs R and V through explicit batched column/row reductions, and the matrix-multiplication bounds follow from standard lemmas (Schur complement, triangular inversion, Lemma 3.1, Theorem 4.2). The central reduction steps do not presuppose the target decomposition. The only load-bearing citations to prior work with overlapping authors are [1] and [3, Theorem 3.1]. These are published, parameter-free mathematical results with stated assumptions that do not include the fast batched algorithms proved here; under the independence rule, such citations are genuine evidence and do not raise the circularity score. Algorithm 5's equivalence to the lazy reduction is argued by matching the recorded coefficients and recursion order in Theorem 5.3, and the underlying row-algorithm/lazy equivalence is an external theorem, not a renaming. There are no fitted parameters, no predictions of closely related quantities, and no empirical pattern renamed as organization. Any implementation-level concern about the batched row update's treatment of identity entries (which has been raised externally) would be a correctness or bug issue, not a circularity of definition, and is therefore not scored here.

Assumptions & free parameters 0 free parameters · 5 assumptions · 0 invented entities

The central claim rests only on standard algebraic results (fast matrix multiplication, fast triangular inversion), a standard filtration assumption, the classical Pairing Uniqueness Lemma, and a cited prior equivalence theorem. No free parameters or invented entities enter. The only non-elementary dependency is [3, Theorem 3.1], which is cited rather than re-proved.

assumptions (5)

standard math Matrix multiplication of n x n matrices over a fixed field F can be done in O(n^omega) time for some omega >= 2.
Running-time analyses in Sections 4 and 5 use the standard algebraic complexity model; Lemma 3.1 and Theorem 4.2 build on it.
standard math Inverting a non-singular triangular matrix can be done in matrix multiplication time.
Theorem 4.2, proven in Appendix A, is used to compute Lambda = R[L,B]^{-1} R[L,C] in Algorithm 3.
domain assumption The filtration can be assumed to be a total order with one simplex added at a time.
Section 2 states this and notes that partial orders can be extended to total orders; standard in persistent homology.
standard math The Pairing Uniqueness Lemma of Cohen-Steiner et al. holds, so pivot pairs are independent of the reduction algorithm.
Invoked in Theorem 4.5 to justify that the computed pairings are correct.
standard math Algorithm 4 (the incremental row algorithm) produces the same decomposition as the standard lazy reduction.
Lemma 5.1 cites [3, Theorem 3.1] for this equivalence; it underlies the claim that Algorithm 5 returns the standard representatives.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Persistent (Co)Homology in Matrix Multiplication Time." pith.science (2026). https://pith.science/paper/AJT6AC3V

@misc{pith2026241202591,
  author       = {Pith},
  title        = {Pith review of: Persistent (Co)Homology in Matrix Multiplication Time},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/AJT6AC3V}},
  note         = {Machine review of arXiv:2412.02591}
}

read the original abstract

Most algorithms for computing persistent homology do so by tracking cycles that represent homology classes. There are many choices of such cycles, and specific choices have found different uses in applications. Although it is known that persistence diagrams can be computed in matrix multiplication time [8] for the more general case of zigzag persistent homology, it is not clear how to extract cycle representatives, especially if specific representatives are desired. In this paper, we provide the same matrix multiplication bound for computing representatives for the two choices common in applications in the case of ordinary persistent (co)homology. We first provide a fast version of the reduction algorithm, which is simpler than the algorithm in [8], but returns a different set of representatives than the standard algorithm [6] We then give a fast version of a different variant called the row algorithm [4], which returns the same representatives as the standard algorithm.

Figures

Figures reproduced from arXiv: 2412.02591 by the authors.

**Figure 2.** An example of the row permutations. (a) A submatrix consisting of 8 columns where the 4 [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

**Figure 3.** The standard binary recursion tree in how we split the matrix by column. Observe that [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: The permutation of the columns so that the pivots in the bottom [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]

**Figure 5.** Figure 5: The updating steps in Algorithm 5. On the right we have the recursion tree for the rows, as [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Subsampling, aligning, and averaging to find circular coordinates in recurrent time series
stat.ML 2024-12 conditional novelty 6.0 of 10

A subsample-and-average pipeline with rejection sampling and Procrustes alignment yields density-robust circular coordinates from persistent cohomology, validated on synthetic and C. elegans data.

Reference graph

Works this paper leans on

28 extracted references · 22 canonical work pages · cited by 1 Pith paper

[1]

Zigzag persistent homology in matrix mul- tiplication time

Nikola Milosavljevi´ c, Dmitriy Morozov, and Primoz Skraba. Zigzag persistent homology in matrix mul- tiplication time. In Proceedings of the twenty-seventh Annual Symposium on Computational Geometry , pages 216–225, 2011

work page 2011
[2]

Edelsbrunner, D

H. Edelsbrunner, D. Letscher, and A. Zomorodian. Topological persistence and simplification. Discrete & computational geometry , 28:511–533, 2002

work page 2002
[3]

Dualities in persistent (co) homology

Vin De Silva, Dmitriy Morozov, and Mikael Vejdemo-Johansson. Dualities in persistent (co) homology. Inverse Problems, 27(12):124003, 2011

work page 2011
[4]

An output-sensitive algorithm for persistent homology

Chao Chen and Michael Kerber. An output-sensitive algorithm for persistent homology. In Proceedings of the twenty-seventh annual symposium on Computational geometry , pages 207–216, 2011. 14

work page 2011
[5]

Annotating simplices with a homology basis and its applications

Oleksiy Busaryev, Sergio Cabello, Chao Chen, Tamal K Dey, and Yusu Wang. Annotating simplices with a homology basis and its applications. In Scandinavian workshop on algorithm theory , pages 189–200. Springer, 2012

work page 2012
[6]

Persistent homology and nested dissection

Michael Kerber, Donald R Sheehy, and Primoz Skraba. Persistent homology and nested dissection. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms , pages 1234–1245. SIAM, 2016

work page 2016
[7]

Clear and compress: Computing persistent ho- mology in chunks

Ulrich Bauer, Michael Kerber, and Jan Reininghaus. Clear and compress: Computing persistent ho- mology in chunks. In Topological Methods in Data Analysis and Visualization III: Theory, Algorithms, and Applications, pages 103–117. Springer, 2014

work page 2014
[8]

Phat–persistent homology algo- rithms toolbox

Ulrich Bauer, Michael Kerber, Jan Reininghaus, and Hubert Wagner. Phat–persistent homology algo- rithms toolbox. Journal of symbolic computation , 78:76–90, 2017

work page 2017

Show all 28 references

[9]

Ripser: efficient computation of vietoris–rips persistence barcodes

Ulrich Bauer. Ripser: efficient computation of vietoris–rips persistence barcodes. Journal of Applied and Computational Topology, 5(3):391–423, 2021

2021
[10]

Performance enhancement of a computational persistent homology package

Alan Hylton, Greg Henselman-Petrusek, Janche Sang, and Robert Short. Performance enhancement of a computational persistent homology package. In 2017 IEEE 36th international performance computing and communications conference (IPCCC), pages 1–8. IEEE, 2017

2017
[11]

Henselman and R

G. Henselman and R. Ghrist. Matroid Filtrations and Computational Persistent Homology. ArXiv e-prints, June 2016. arXiv:1606.00199

2016 arXiv
[12]

Efficient computation of persistent homology for cubical data

Hubert Wagner, Chao Chen, and Erald Vu¸ cini. Efficient computation of persistent homology for cubical data. In Topological methods in data analysis and visualization II: theory, algorithms, and applications , pages 91–106. Springer, 2011

2011
[13]

Computing persistent homology

Afra Zomorodian and Gunnar Carlsson. Computing persistent homology. In Proceedings of the twentieth annual symposium on Computational geometry , pages 347–356, 2004

2004
[14]

Zigzag persistence

Gunnar Carlsson and Vin de Silva. Zigzag persistence. Foundations of computational mathematics , 10(4):367–405, August 2010. doi:10.1007/s10208-010-9066-0

2010 doi
[15]

Zigzag persistent homology and real-valued functions

Gunnar Carlsson, Vin de Silva, and Dmitriy Morozov. Zigzag persistent homology and real-valued functions. In Proceedings of the Twenty-fifth Annual Symposium on Computational Geometry, SCG ’09, pages 247–256, New York, NY, USA, 2009. ACM. doi:10.1145/1542362.1542408

2009
[16]

Vines and vineyards by updating persistence in linear time

David Cohen-Steiner, Herbert Edelsbrunner, and Dmitriy Morozov. Vines and vineyards by updating persistence in linear time. In Proceedings of the twenty-second annual symposium on Computational geometry, pages 119–126, 2006

2006
[17]

Persistent cohomology and cir- cular coordinates

Vin de Silva, Dmitriy Morozov, and Mikael Vejdemo-Johansson. Persistent cohomology and cir- cular coordinates. Discrete & computational geometry , 45(4):737–759, June 2011. doi:10.1007/ s00454-011-9344-x

2011
[18]

Lexicographic optimal homologous chains and applications to point cloud triangulations

David Cohen-Steiner, Andr´ e Lieutier, and Julien Vuillamy. Lexicographic optimal homologous chains and applications to point cloud triangulations. Discrete & computational geometry , 68(4):1155–1174, December 2022. doi:10.1007/s00454-022-00432-6

2022 doi
[19]

Topological optimization with big steps

Arnur Nigmetov and Dmitriy Morozov. Topological optimization with big steps. Discrete & computa- tional geometry, 72(1):310–344, July 2024. doi:10.1007/s00454-023-00613-x

2024 doi
[20]

Fast computation of zigzag persistence

Tamal K Dey and Tao Hou. Fast computation of zigzag persistence. In30th Annual European Symposium on Algorithms (ESA 2022) . Schloss Dagstuhl-Leibniz-Zentrum f¨ ur Informatik, 2022. 15

2022
[21]

Computational topology: an introduction

Herbert Edelsbrunner and John L Harer. Computational topology: an introduction . American Mathe- matical Society, 2022

2022
[22]

Persistence algorithm takes cubic time in worst case

Dmitriy Morozov. Persistence algorithm takes cubic time in worst case. BioGeometry News, Dept. Comput. Sci., Duke Univ , 2, 2005

2005
[23]

Enumeration of q-acyclic simplicial complexes

Gil Kalai. Enumeration of q-acyclic simplicial complexes. Israel Journal of Mathematics , 45:337–351, 1983

1983
[24]

Randomly weighted d-complexes: Minimal span- ning acycles and persistence diagrams

Primoz Skraba, Gugan Thoppe, and D Yogeshwaran. Randomly weighted d-complexes: Minimal span- ning acycles and persistence diagrams. The Electronic Journal of Combinatorics , pages P2–11, 2020

2020
[25]

Updating barcodes and representatives for zigzag persistence

Tamal K Dey and Tao Hou. Updating barcodes and representatives for zigzag persistence. arXiv preprint arXiv:2112.02352, 2021

2021 arXiv
[26]

A fast algorithm for computing zigzag representatives

Tamal K Dey, Tao Hou, and Dmitriy Morozov. A fast algorithm for computing zigzag representatives. arXiv preprint arXiv:2410.20565 , 2024

2024 arXiv
[27]

Gaussian elimination is not optimal

Volker Strassen. Gaussian elimination is not optimal. Numerische mathematik , 13(4):354–356, 1969

1969
[28]

Triangular factorization and inversion by fast matrix multipli- cation

James R Bunch and John E Hopcroft. Triangular factorization and inversion by fast matrix multipli- cation. Mathematics of Computation , 28(125):231–236, 1974. A Matrix Inversion in Matrix Multiplication Time We present a simplified proof for the special case of triangular matr...

1974

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.

[1] [1]

Zigzag persistent homology in matrix mul- tiplication time

Nikola Milosavljevi´ c, Dmitriy Morozov, and Primoz Skraba. Zigzag persistent homology in matrix mul- tiplication time. In Proceedings of the twenty-seventh Annual Symposium on Computational Geometry , pages 216–225, 2011

work page 2011

[2] [2]

Edelsbrunner, D

H. Edelsbrunner, D. Letscher, and A. Zomorodian. Topological persistence and simplification. Discrete & computational geometry , 28:511–533, 2002

work page 2002

[3] [3]

Dualities in persistent (co) homology

Vin De Silva, Dmitriy Morozov, and Mikael Vejdemo-Johansson. Dualities in persistent (co) homology. Inverse Problems, 27(12):124003, 2011

work page 2011

[4] [4]

An output-sensitive algorithm for persistent homology

Chao Chen and Michael Kerber. An output-sensitive algorithm for persistent homology. In Proceedings of the twenty-seventh annual symposium on Computational geometry , pages 207–216, 2011. 14

work page 2011

[5] [5]

Annotating simplices with a homology basis and its applications

Oleksiy Busaryev, Sergio Cabello, Chao Chen, Tamal K Dey, and Yusu Wang. Annotating simplices with a homology basis and its applications. In Scandinavian workshop on algorithm theory , pages 189–200. Springer, 2012

work page 2012

[6] [6]

Persistent homology and nested dissection

Michael Kerber, Donald R Sheehy, and Primoz Skraba. Persistent homology and nested dissection. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms , pages 1234–1245. SIAM, 2016

work page 2016

[7] [7]

Clear and compress: Computing persistent ho- mology in chunks

Ulrich Bauer, Michael Kerber, and Jan Reininghaus. Clear and compress: Computing persistent ho- mology in chunks. In Topological Methods in Data Analysis and Visualization III: Theory, Algorithms, and Applications, pages 103–117. Springer, 2014

work page 2014

[8] [8]

Phat–persistent homology algo- rithms toolbox

Ulrich Bauer, Michael Kerber, Jan Reininghaus, and Hubert Wagner. Phat–persistent homology algo- rithms toolbox. Journal of symbolic computation , 78:76–90, 2017

work page 2017