---
abstract: |
    Persistent homology is typically computed through persistent cohomology. While this generally improves the running time significantly, it does not facilitate extraction of homology representatives. The mentioned representatives are geometric manifestations of the corresponding holes and often carry desirable information.

    We propose a new method of extraction of persistent homology representatives using cohomology. In a nutshell, we first compute persistent cohomology and use the obtained information to significantly improve the running time of the direct persistent homology computations. This algorithm applied to Rips filtrations generally computes persistent homology representatives much faster than the standard methods.
address: University of Ljubljana
author:
- Matija Čufar
- Žiga Virk
bibliography:
- 'article.bib'
title: Fast computation of persistent homology representatives with involuted persistent homology
---

Introduction
============

Persistent homology @EdelsHarer is a widely applicable stable descriptor of metric spaces. It is usually computed by treating coboundary matrices, in effect computing the isomorphic persistent cohomology. The reason is that the structure of cohomology is more amenable to certain speedups and in most cases results in faster computation @bauer2019ripser [@de2011circular; @de2011dualities].

While persistent homology contains information about the lifespans of homology elements interpreted as holes, the actual cycles representing these holes can be extracted from the reduced boundary matrix. When computations are carried out by reducing the coboundary matrix though, we can only obtain representative cocycles. These are favorable in some specific settings @de2011circular, but in general cycles are the much preferred method of visualization and expression of persistent homology elements. The difference between them is demonstrated in Figure \[fig:cycles-cocycles\].

**Contributions**. In this paper, we present an algorithm that allows us to leverage the speed of persistent cohomology computation and to recover representative cycles. The essential part of the algorithm has two distinct phases:

1.  Reduce the coboundary matrix and extract simplices contributing to the computation of representative cycles.

2.  Reduce the boundary matrix restricted to the columns determined by the previous part.

In effect we use the reduced coboundary matrix to determine the death simplices of persistence pairs and then "ignore" all other columns in the reduction of the boundary matrix. We call this approach involuted homology computation. The efficiency of our algorithm as compared to the standard approach depends on the disparity of the reduction times for persistent homology and cohomology. While the algorithm works for any filtration, we restrict our comparison to Rips complexes, as the speedup there is the most significant. A comparative analysis suggests our approach is the fastest way to obtain the representatives in almost all settings.

**Related work**. In this paper we describe how to compute homology representatives arising from the reduction process of persistent homology in any dimension. Further modifications and optimizations of these cycles have been treated in @Tamal1 [@Tamal2; @Chao; @Optimal1; @Optimal2]. In a different setting a nominally similar but essentially different problem has been considered in @Kozlov. Amongst the existing software Eirene @henselman2016matroid seems to handle the representative computations efficiently and has thus been used for comparative purposes.

![Comparison of persistence cocycles and persistence cycles on a data set consisting of 20 points sampled randomly from a circle, 12 points sampled uniformly from a circle, and 40 points sampled randomly from an annulus.<span data-label="fig:cycles-cocycles"></span>](cycle-cocycle-comparison){width=".8\textwidth"}

Theoretical background
======================

In this section we review theoretical background on persistent homology and cohomology. For further details on see @EdelsHarer and @de2011dualities.

Persistent homology
-------------------

Throughout the paper we fix a field of coefficients $\FF$ for all homology and cohomology groups. Let $K$ be a finite simplicial complex. A **filtration** of $K$ is a nested collection of subcomplexes: $$K_1 \leq K_2 \leq \ldots, K_m=K.$$ A **filtration function** associated to a filtration is a function $\f$ assigning to each simplex $\sigma \in K$ the index $\f(\sigma)=\operatorname{argmin}_i \{\sigma \in K_i\}$. Throughout the paper we assume that $\f$ is injective, i.e., each $K_i$ is obtained from $K_{i-1}$ by an addition of a single simplex $\sigma_i$.

Let $p\in\{0,1,\ldots\}$. **Persistent homology** in dimension $p$ is the collection of ranks of inclusion induced maps of a filtration on homology. In particular, it consists of **Betti numbers** $$\beta^p_{i,j} = \operatorname{rank}H_p (K_i \hookrightarrow K_{j}), \quad \forall 1 \leq i \leq j \leq m.$$ Persistent homology is typically visualized and described by a persistence diagram. For each $i$, the addition of and $n$-dimensional simplex $\sigma_i$ to $K_{i-1}$ either:

1.  creates an $n$-dimensional homology class, or

2.  destroys an $(n-1)$-dimensional class.

Simplices of type (1) are called **birth simplices**. A simplex $\sigma_i$ is a birth simplex iff its boundary is a linear (with coefficients in $\FF$) combination of boundaries in $K_{i-1}$.

Simplices of type (2) are called **death simplices**. A simplex $\sigma_i$ is a birth simplex iff its boundary is not a linear (with coefficients in $\FF$) combination of boundaries in $K_{i-1}$.

Each death $n$-simplex $\sigma_i$ is paired to a unique birth $(n-1)$-simplex $\sigma_j$ with $j < i$ to form a **persistence** (homology) **pair**. The addition of $\sigma_j$ creates a homology class destroyed by $\sigma_i$. Birth simplices not contained in any persistence pair are called **essential** simplices.

A **persistence diagram** is a collection of points $$\{(i,j) \mid (\sigma_i, \sigma_j) \textit{ a persistence pair } \} \ \cup$$ $$\cup \ \{(i, \infty) \mid \sigma_i \textit{ an essential simplex } \}$$

Reduction algorithm
-------------------

The original reduction algorithm of @ELZ returns persistence pairs and essential simplices. Let $\di$ be the full boundary matrix of $K$ with the columns and rows indexed by $\{1,2,\ldots, m\}$. Index $i$ represents simplex $\sigma_i$. Given a matrix $A$ whose rows and columns are indexed by $i\in \{1,2,\ldots, m\}$ define:

-   $\operatorname{Col}_A(i)$ as the $i$th column of $A$ as a vector.

-   $\operatorname{Row}_A(i)$ as the $i$th row of $A$ as a vector.

-   $\operatorname{Low}_A(i)$ as the index of the lowest non-trivial entry in $\operatorname{Col}_A(i)$ or $0$ if the column is trivial.

The reduction algorithm is essentially a column reduction process.

\[H\] \[Alg1\]\

Let $\di'$ denote the reduced boundary matrix as reduced by Algorithm \[Alg1\]. If $\operatorname{Col}_{\di'}(i)$ is not trivial then $(\sigma_{\operatorname{Low}_{\di'}(i)}, \sigma_i)$ is a persistence pair. Simplices unpaired in this manner are essential simplices.

Representatives
---------------

The standard representative of a persistence pair $(\sigma_{\operatorname{Low}_{\di'}(i)}, \sigma_i)$ is the vector represented by $\operatorname{Col}_{\di'}(i)$. A representative is a chain whose homology class spans the homology that appeared at $\operatorname{Low}_{\di'}(i)$ and died at $i$.

Given an essential simplex $\sigma_i$ Algorithm \[Alg1\] reduces $\operatorname{Col}_\di(i)$ to the trivial column, i.e., there exist $\lambda_j\in \FF$ such that $\operatorname{Col}_\di(i) - \sum_{j=1}^{i-1} \lambda_j \operatorname{Col}_\di(j)$. The standard representative corresponding to the essential simplex $\sigma_i$ is $\sigma_i - \sum_{j=1}^{i-1} \lambda_j \sigma_j$. This representative is a chain whose homology class appears at $\operatorname{Low}_{\di'}(i)$ and never dies.

Persistent cohomology
---------------------

While the definition of homology $H_p(K)$ is based on chains ($\FF$-combinations of simplices), the definition of cohomology $H^p(K)$ (see @Hatcher for an introduction) is based on cochains ($\FF$-linear maps from the space of chains into $\FF$). It turns out that both invariants are isomorphic but that cohomology is contravariant in the sense that it reverses the direction of induced maps. The following result is a well known consequence of the universal coefficients theorem and contravariant functoriality of cohomology. In our setting it has first appeared in  @de2011dualities.

\[ThmMain\] Let $K \hookrightarrow L$ be an inclusion of simplicial complexes. Then for each dimension $p$ there exists a commutative diagram $$\xymatrix
{H_p(K) \ar[d] \ar[r] & H_p(L) \ar[d] \\
H^p(K) & H^p(L) \ar[l]}$$ with the vertical maps being isomorphisms.

Persistent cohomology is constructed from a filtration (we still assume the filtration function is injective) in the same way as persistent cohomology. We refrain from repeating the construction and instead point out the fundamental differences of the computational aspect:

1.  The standard coboundary matrix is the transpose of the boundary matrix. This results in a lower-triangular matrix and would require us to use the mentioned column reduction in the opposite direction to compute cohomology. For this reason we rather define our coboundary matrix $d$ to be the **anti-transpose** of $\di$ as in @de2011dualities. In particular, $d$ is obtained from $\di^T$ by reversing the order of simplices labeling columns and rows.

2.  Persistent cohomology is computed using the mentioned column reduction on $d$.

3.  $(\sigma_i,\sigma_j)$ is a persistence homology pair iff $(\sigma_j,\sigma_i)$ is a persistence cohomology pair. Essential simplices coincide in both cases.

4.  A cohomology representative of a persistence cohomology pair is a cochain, i.e., a linear map from the space of chains into $\FF$.

For each $p\in \{0,1,\ldots\}$ we define $\di_p$ and $d_p$ be the p-dimensional (co)boundary matrices. In particular, the columns of $\di_p$ are labeled by $p$-simplices, the rows are labeled by $(p-1)$-simplices. Matrix $d_p$ is the anti-transpose of $\di_{p-1}$. These matrices form the block structure of $\di$ and $d$ respectively.

Rips complexes
--------------

Given a finite metric space $(X,d)$ and $r>0$ the **Rips complex** is defined as $\operatorname{Rips}(X,r)=\{\sigma \subseteq X \mid \operatorname{diam}(\sigma)\leq r\}$. The Rips filtration of $X$ is the collection of all Rips complexes of $X$ for all positive $r$. In order to obtain a filtration with an injective filtration function we order the simplices of a Rips filtration as $\sigma_1, \sigma_2, \ldots$ so that:

-   If $\operatorname{diam}(\sigma_i) < \operatorname{diam}(\sigma_j)$ then $i<j$, i.e., we first order simplices by diameter.

-   If $\operatorname{diam}(\sigma_i) = \operatorname{diam}(\sigma_j)$ and $\dim(\sigma_i) < \dim(\sigma_j)$ then $i<j$, i.e., we then order simplices by dimension.

-   Simplices of the same diameter and dimension are ordered amongst themselves in an arbitrary order.

If we use the same such an ordering in the construction of $\di$ and $d$ (i.e., if $d$ is the anti-transpose of $\di$) then the resulting persistence $(\sigma_i, \sigma_j)$ pairs are the same by Theorem \[ThmMain\]. Choosing a different order above may change some of the persistence pairs. However, the persistence diagram of the Rips filtration, defined as the multiset of points $$\{(\operatorname{diam}(\sigma_i), \operatorname{diam}(\sigma_j)) \mid (\sigma_i, \sigma_j) \textrm{ a persistence pair} \} \ \cup$$ $$\cup \ \{(\operatorname{diam}(\sigma_i), \infty) \mid \sigma_i \textrm{ an essential simplex} \},$$ remains unchanged. If $\operatorname{diam}(\sigma_i)= \operatorname{diam}(\sigma_j)$ for a persistence pair $ (\sigma_i, \sigma_j) $ we say the corresponding interval is trivial.

For practical reasons the scales of $r$ are often bounded from above. When that is not the case the Rips complex for large scales takes the form of the full simplex on all points, resulting in a single essential simplex (the first vertex in our chosen order).

Algorithm
=========

In this section we present our algorithm to compute persistent homology representatives. Our algorithm will make use of the discrepancy between the running times for persistent homology and cohomology computations. We restrict our treatment to Rips complexes although the same algorithm can be used for other constructions of simplices as well. Recall that $\di$ denotes a boundary matrix while $d$ denotes a coboundary matrix.

The algorithm
-------------

**Input**: Start with a finite metric space $X$.

**Preprocessing**: Construct a fixed injective filtration function associated to the Rips filtration of $X$. We generate coboundary matrices $d_k$.

**The main part**:

1.  Reduce each $d_k$. By Theorem \[ThmMain\] we may extract homological death simplices (i.e., cohomological birth simplices) and essential simplices.

2.  For each $k$ let $D_k$ be the minor of the homology boundary matrix $\di_k$ consisting of columns corresponding to homological death simplices and essential simplices. We keep the indices of simplices to label the columns.

3.  Compute persistent homology representatives by reducing $D_k$.

**Output**: Return homology representatives from the reduced forms of matrices $D_k$.

The algorithm is stated so that it encompasses all dimensions. However, we can choose a fixed dimension $q$ and perform the algorithm only for the corresponding dimension. In particular, representatives of $q$-dimensional persistent homology classes are $q$-chains. We obtain them by first reducing the coboundary matrix $d_{q-1}$, and then generate and reduce the corresponding $D_{q}$.

Explanation of the algorithm
----------------------------

Input, preprocessing and output parts have been explained in the previous section. Detailed comments are provided for the main part:

Part (1)

:   In the first step, we can employ a variety of computational tricks that were developed to make persistent cohomology efficient, such as clearing @chen2011persistent, skipping emergent pairs, and using an implicit coboundary matrix representation @bauer2019ripser. These tricks naturally favor the structure of cohomology and result in a reduction of a cohomology matrix in a much shorter time than the corresponding boundary matrix.

Part (2)

:   From the reduced matrices $d_k$ we deduce which columns of the boundary matrices $\di_k$ are required for extraction of homology representatives (formally, reduced $d_{k}$ determines the columns of $D_{k+1}$). These are the columns corresponding to essential simplices and homological death simplices (the latter correspond to cohomological birth simplices). Matrices $D_k$ are theoretically obtained by restricting $\di_k$ to the corresponding columns. In practice we refrain from treating $\di_k$ by constructing $D_k$ directly from the mentioned simplices.

    The omitted columns correspond to the paired birth simplices: these would have been reduced to trivial columns in the reduction of the boundary matrices and wouldn't contribute to the extraction of representatives.

    Even though we know which rows of $\di_k$ will contain a pivot, matrices $D_k$ keep all rows from $\di_k$ as any of them might appear in an expression of homology representatives. In a similar fashion we keep even the death simplices corresponding to trivial intervals of the persistence diagram (except for the ones mentioned in the next paragraph) of the Rips filtration as they may be needed in later reductions.

    Another thing we can take into account is that we know when the last non-trivial interval will die. This allows us to further truncate $D_k$ to only include death simplices up to the death time of the last non-trivial interval as representatives of trivial intervals are typically not of interest.

Part (3)

:   When the scale $r$ in the Rips filtration is unrestricted, all but one simplex is paired and we have thus removed one less than half of the columns from $\di$. Furthermore, the reduction of columns to trivial columns typically takes longer than a partial reduction. As a result the omissions of part (2) significantly speed up the column reduction performed in this part.

    In practice the computation is usually restricted to low dimensions, i.e., $k << n=|X|$. In this case the improvement is even more pronounced. The number of columns of $d_k$ equals the number of $k$-simplices, which is ${{n}\choose{k+1}}=\O(n^{k+1})$. However, each death $k$-simplex is paired to a $(k-1)$-simplex. As the number of $(k-1)$-simplices is ${{n}\choose{k}}=\O(n^{k})$, there are at most ${{n}\choose{k}}=\O(n^{k})$ many death $k$-simplices. These label the columns of $D_k$ and thus number of columns of $D_k$ is at most ${{n}\choose{k}}=\O(n^{k})$. In a nutshell, our algorithm reduces the number of columns from ${{n}\choose{k
    +1}}=\O(n^{k+1})$ to less than ${{n}\choose{k}}=\O(n^{k})$. See Proposition \[PropQuant\] for precise quantities.

The obtained persistence homology representatives are the same as the ones obtained by the direct reduction of $\di_k$ as the removed columns have no effect on the reduction of other columns.

\[PropQuant\] Let $X$ be a metric space consisting of $n$ points. Then the persistent homology of the full simplex on $X$ via any filtration function (for example, Rips filtration) has only one essential simplex, namely the first vertex in our chosen order. Furthermore, for each $k\leq 0$ the number of death simplices in dimension $k$ equals $${n \choose k}-  {n \choose k-1}+ {n \choose k-2}- \ldots \pm  {n \choose 0}.$$

The first part is trivial as the full simplex on $X$ is contractible. The formula of the second part follows by induction. The number of non-essential birth vertices equals $n-1$ and coincides with the number of death edges. Consequently, the number of birth edges equals ${n \choose 2} - (n-1)$ and coincides with the number of death triangles. We proceed by induction.

Experiments
===========

We implemented the algorithm presented in this paper in our Julia @bezanson2017julia package Ripserer.jl @vcufar2020ripserer.

Tables \[tab:reduction-time\], \[tab:matrix-size\], and \[tab:eirene\] contain the benchmarking results. The benchmarks were performed on a computer with an IntelXeonCPU E5-2680 v4 @ 2.40GHz with 32GB RAM running Julia v1.6.0 and Ripserer v0.16.6. Each benchmark was performed ten times. Only the minimum time is shown in the tables.

Full descriptions of the data sets can be found in @otter2017roadmap and @bauer2019ripser. In addition to the mentioned data sets, we have added the following:

-   gcycle: a distance matrix of the shortest paths on a cycle graph with 100 vertices.

-   2-sphere: 100 points sampled uniformly from a 2-sphere.

The full benchmarking code can be found at <https://github.com/mtsch/involuted-persistent-homology-benchmarks>.

<span>c|c c c c c c</span> name & $N$ & $\dim$ & $r$ & $t_d$ & $t_\partial$ & $t_{D}$\

gcycle & 100 & 1 & & 10.065 ms & 1.463 s & 1.283 ms\
gcycle & 100 & 3 & 40 & 1.074 s & 545.981 s & 887.074 ms\
random16 & 50 & 3 & & 26.002 ms & 2.252 s & 16.950 ms\
random16 & 50 & 7 & & 2.258 s & & 1.485 s\
2-sphere & 100 & 2 & & 79.959 ms & 27.665 s & 32.405 ms\
hiv & 1088 & 1 & & 1.218 s & 925.300 s & 81.260 ms\
dragon & 1000 & 1 & & 318.310 ms & 1544.247 s & 11.962 ms\
celegans & 297 & 2 & & 2.203 s & 566.889 s & 612.145 ms\
o3 & 1024 & 3 & 1.8 & 1.967 s & & 881.897 ms\
o3 & 4096 & 3 & 1.4 & 80.887 s & & 18.785 s\

<span>c|c c c c c c</span> name & $N$ & $\dim$ & $r$ & $m_d$ & $m_\partial$ & $m_{D}$\

gcycle & 100 & 1 & & 4,851 & 161,700 & 3,301\
gcycle & 100 & 3 & 40 & 106,021 & 10,602,020 & 106,021\
random16 & 50 & 3 & & 54,026 & 284,157 & 22,394\
random16 & 50 & 7 & & 3,049,075 & & 0\
2-sphere & 100 & 2 & & 140,785 & 3,171,361 & 52,323\
hiv & 1088 & 1 & & 517,622 & 155,009,693 & 165,623\
dragon & 1000 & 1 & & 317,442 & 56,110,140 & 21,275\
celegans & 297 & 2 & & 3,735,740 & 256,663,737 & 918,390\
o3 & 1024 & 3 & 1.8 & 1,768,568 & & 987,703\
o3 & 4096 & 3 & 1.4 & 39,738,338 & & 18,012,908\

**Timing comparisons for coboundary, boundary and involuted boundary matrix reductions** are listed in Table \[tab:reduction-time\]. Their sizes are listed in Table \[tab:matrix-size\]. The time it takes to collect the list of the matrix columns from the distance matrix is not taken into account, however sorting the columns is included. Including the collection time would force us to include the full cohomology computation in the involuted case. The cohomology matrices were built with the twist algorithm @chen2011persistent. All reduction algorithms use a similar on-the-fly matrix construction described in detail in @bauer2019ripser. The coboundary matrix uses and implicit reduced column representation, while the the boundary matrices use an explicit one. The columns in these tables are as follows:

-   name: the name of the data set.

-   $N$: the number of points in the data set.

-   $\dim$: the dimension of the matrix.

-   $r$: the threshold used. If this field is empty, the radius of the data set is computed and used as a threshold.

-   $m_d$, $m_\partial$, $m_{D}$: the numbers of columns in the coboundary, boundary and involuted boundary matrix, respectively.

-   $t_d$, $t_\partial$, $t_{D}$: the time it took to reduce the coboundary, boundary and involuted boundary matrix, respectively.

In some benchmarks, the fields for $m_\partial$ and $t_\partial$ are empty. In those cases, we were unable to run the boundary matrix reduction benchmark on our computer.

     name     $N$    $\dim$   $r$     $t_c$        $t_i$        $t_e$      $t_i$/$t_e$
  ---------- ------ -------- ----- ------------ ------------ ------------ -------------
    gcycle    100      1            10.800 ms    12.242 ms    63.445 ms       0.19
    gcycle    100      3      40     1.261 s      1.887 s      5.535 s        0.34
   random16    50      3            44.720 ms    61.864 ms    66.740 ms       0.93
   random16    50      7             7.969 s      8.597 s      7.795 s        1.10
   2-sphere   100      2            89.669 ms    116.984 ms   347.444 ms      0.34
     hiv      1088     1             1.313 s      1.412 s      6.155 s        0.23
    dragon    1000     1            380.130 ms   407.252 ms    6.411 s        0.06
   celegans   297      2             2.673 s      3.320 s      3.808 s        0.87
      o3      1024     3      1.8    3.336 s      4.222 s      6.170 s        0.68
      o3      4096     3      1.4   119.804 s    136.775 s    207.473 s       0.66

  : \[tab:eirene\]Comparison of computation times between cohomology, involuted homology, and Eirene.

**Timing comparisons between our implementations of persistent cohomology and involuted involuted persistent homology with Eirene** @henselman2016matroid are listed in Table \[tab:eirene\]. We have chosen to compare the timings with Eirene because it is the fastest library we are aware of at producing representative cycles. We used Eirene v1.3.5. The columns in this table are as follows:

-   name: the name of the data set.

-   $N$: the number of points in the data set.

-   $\dim$: the dimension of persistent homology computed.

-   $r$: the threshold used. If this field is empty, the radius of the data set is computed and used as a threshold.

-   $t_c$, $t_i$, $t_e$: the timings for persistent cohomology, involuted persistent homology, and Eirene, respectively.

-   $t_i$/$t_e$: ratio of timings between involuted persistent homology and Eirene.

![\[fig:dim-scaling1\]Timings of our code and Eirene with increasing maximum homology dimension on a data set of 50 random points in $\mathbb{R}^{16}$.](random16.pdf){width=".8\textwidth"}

![\[fig:dim-scaling2\]Timings of computing one-dimensional persistent homology with our code and Eirene on increasing number of vertices on a cycle graph.](gcycle.pdf){width=".8\textwidth"}

![\[fig:dim-scaling3\]Timings of computing one-dimensional persistent homology with our code and Eirene on subsets of the dragon dataset of increasing size.](dragon.pdf){width=".8\textwidth"}

![\[fig:dim-scaling4\]Timings of computing persistent homology with our code and Eirene on subsets of the hiv dataset of increasing size.](hiv.pdf){width=".8\textwidth"}

Analysis
========

While the benchmarking results are explicitly stated in Tables \[tab:reduction-time\], \[tab:matrix-size\], and \[tab:eirene\], additional information is provided by Figures \[fig:dim-scaling1\] through \[fig:dim-scaling4\].

Comparisons for coboundary, boundary and involuted boundary matrix reductions.
------------------------------------------------------------------------------

The time and matrix size of coboundary reductions (Tables \[tab:reduction-time\] and \[tab:matrix-size\]) are, as expected, lower than those of the homology reductions by orders of magnitude. On the other hand, they are larger than those of the reduction of $D$, sometimes by an order of magnitude. Thus, the **involuted computation of homology of representatives is orders of magnitude faster than the direct reduction though homology matrix.** While the involuted part of the algorithm (the reduction of $D$) naturally adds running time in addition to the cohomology reduction (the reduction of $d$ only), the total addition is mostly small (Figures \[fig:dim-scaling1\] through \[fig:dim-scaling4\]) when compared to the cohomology reduction alone. As a result it appears that whenever cohomological reduction is feasible, so is the involuted homology reduction.

Comparison of computation times between cohomology, involuted homology, and Eirene.
-----------------------------------------------------------------------------------

Our results suggests that involuted homology computation compares favorably (Figures \[fig:dim-scaling1\] through \[fig:dim-scaling4\]). The only case when Eirene performed slightly better (Table \[tab:eirene\]) was the case of random points in $\mathbb{R}^{16}$. Further comparisons (Figures \[fig:dim-scaling1\]) suggests that Eirene might perform slightly better with higher-dimensional homology on random points. On other datasets our approach performed much better, with the reduction time reduced by up to $94\%$ of the Eirene's running time on our examples.

Conclusions
===========

We have demonstrated the feasibility of the involuted persistent homology computations to obtain the persistent homology representatives. The running time of our algorithm is comparable to that of cohomology reduction (which does not yield homology representatives), and is orders of magnitude smaller than the standard homology reduction (the standard method to obtain the homology representatives). When compared to Eirene, our algorithm generally computes representatives faster (except for high-dimensional representatives of random points) with the improvement sometimes being of the orders of magnitude.

In a nutshell, when computing persistent cohomology, it does not take much to compute the representative homology cycles as well. Furthermore, it appears that our approach is, in most cases, the most efficient way to obtain homology representatives.

{'source': 'arXiv_out/2105'}