Persistent (Co)Homology in Matrix Multiplication Time

TL;DR

This paper provides the same matrix multiplication bound for computing representatives for the two choices common in applications in the case of ordinary persistent (co)homology.

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 (5)

• Figure 1: An example of the column permutation in the exhaustive algorithm. (a) Initially, we append an identity matrix to the boundary matrix. (b) Assume we have processed the first $k$ columns. The blue entries represent non-zero entries, and the dark blue boxes represent the pivots. To apply these pivots to next $k$ columns (shown in gray), the first $k$ columns must contain $k$ pivots. (c-d) If there is a a zero column (shown in orange), we transpose it with the first non-zero entry in the appended identity matrix, ensuring the processed $k$ columns all have pivots.
• Figure 2: An example of the row permutations. (a) A submatrix consisting of 8 columns where the 4 columns on the left have been reduced, and we need to apply the pivots to the following 4 columns (in gray). (b-c) Each row which has a pivot gets permuted to the bottom of the matrix in the same order as the columns -- resulting in a lower triangular matrix. (d) Applying the Schur complement zeros out the gray entries on the bottom right and we update the entries in the upper right (dark gray). (e) With the pivot rows zeroed out on the right, we reverse the permutation.
• Figure 3: The standard binary recursion tree in how we split the matrix by column. Observe that $|B| = |C|=|L|$ in \ref{['alg:col-tree-no-inversion']} and that $\mathbf{R}[L,B] = (\mathbf{P}_L \cdot \mathbf{R})[\{n-|B|+1,\ldots, n\},B]$, the bottom $|B|$ rows in the permuted matrix.
• Figure 4: The permutation of the columns so that the pivots in the bottom $k$ rows are on the right. An important observation is that despite this reshuffling of columns, because of the definition of $\mathbf{lft} (\cdot)$, we never "accidentally" reduce columns which occur earlier in the filtration order.
• Figure 5: The updating steps in \ref{['alg:row-tree']}. On the right we have the recursion tree for the rows, as opposed to the columns which is the same as in \ref{['fig:recursion']} --- as rows proceed bottom-up and columns proceed left to right. When we return from the recursion on $B$ (or $B_r$), we have zeroed out all the entries to the right of columns $B$ in rows $B_r$. We then first need to apply these to the rows in $C_r$ (line 11 in \ref{['alg:row-tree']}), shown in orange. We can then identify the correct pivot columns for rows $C_r$ (after recursing), and complete the step by applying the operations from columns $B$ to $C$ above. This is shown in green --- and corresponding to the right of $A_r=B_r\cup C_r$ in the recursion tree (the rows above $A_r$ -- denoted $\bar{A}_r$) to the right of the dashed line. This makes columns $B\cup C$ and rows $A_r$ completely processed/reduced.

Theorems & Definitions (26)

• Remark 2.1
• Lemma 2.2
• proof
• Remark 2.3
• Lemma 3.1
• proof
• Lemma 3.2
• proof
• Theorem 4.2
• proof