From: NeurIPS.cc/2022/Conference/Program_Chairs
title: Paper Decision
decision: Accept

From: NeurIPS.cc/2022/Conference/Paper5964/Area_Chair_T6Wi
metareview: This paper proposes a method of reducing the size of graphs that are commonly used as inputs for persistent homology algorithms. This addresses a fundamental scalability problem in the case of graphs, and is likely to enable further work in the area.

On the negative side, the paper is similar to the prior work on strong collapses. Also, the experimental results do not make a strong case that the proposed algorithms are actually effective in reducing the running time for computing persistent homology at dimensions more than 0. There is only one plot on time reduction improvement (Fig 4b), which provides results for only two datasets in homology dimension 0, which is not satisfactory given that 0-dimensional case is already known to be very efficient.

Given the above, my recommendation is a weak accept, and I urge the authors to address these issues in their final version: better clarify the connection with the prior work, and provide experimental evidence that the algorithm improves the efficiency of persistent homology computation at dimensions more than 0. 
recommendation: Accept
confidence: Less certain
award: No

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Thank you
comment: Thank you very much again for your valuable time and feedback. If you have further questions, we’d be happy to answer.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Thank you
comment: Thank you very much again for your valuable time and feedback. If you have further questions, we’d be happy to answer.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Experiments for PrunIT vs. Strong Collapse
comment: Thank you very much for your suggestion. We run the experiments (see table below) you requested and add a python notebook as the supplementary material where you can run the code. We added a remark (Remark 13 below) comparing PrunIt and Strong Collapse in graph setting, and giving experiment results. We want to underline that Strong Collapse is a very successful method works for general type of data. PrunIt is specifically designed for graph setting. In this respect, one of them should not be considered as alternate for each other, but complementary methods. Please let us know if you have further questions.

For filtration step size 4, 

Computational times: Prunit - 1412 sec | Strong Collapse - 7014 sec

Simplex count: PrunIT - 270.2 million | Strong Collapse - 465.2 million

==================================

For filtration step size 12, 

Computational times: Prunit - 513 sec | Strong Collapse - 2520 sec

Simplex count: PrunIT - 90.7 million | Strong Collapse - 155.8 million

=====================================

$\textbf{Remark\ 13.}$ In [BP 2019, BP 2020, BPP 2021] , the authors introduced Strong Collapse method to effectively reduce the computational costs for the persistence diagrams. In this context, Strong Collapse method is defined for any simplicial complex sequence, whereas PrunIT ise specifically defined for the graph setting. The main difference between Strong Collapse and PrunIt is that PrunIT captures the dominated vertices in the graph at once, before filtration while Strong Collapse needs to be applied in each filtration step. In particular, for a given graph $\mathcal{G}$ and the filtering function $f$, PrunIT detects the dominated vertices in the graph, and by removing them, gives a smaller graph $\mathcal{G}'$ with the same persistence diagrams $PD(\mathcal{G},f)=PD(\mathcal{G}'f)$. Since the detection of dominated vertices is done in the graph itself, the PrunIt algorithm works very fast. On the other hand, Strong Collapse method is designed to work with flag complexes. Therefore, if one wants to apply Strong Collapse method to compute $PD(\mathcal{G},f)$, one needs to go to the filtration sequence (flag complexes) $\widehat{\mathcal{G}}_1\subset \widehat{\mathcal{G}}_2\subset \dots \subset\widehat{\mathcal{G}}_N$, and apply the Strong Collapse method for each flag complex $\widehat{\mathcal{G}}_n$ for $1\leq n\leq N$ in the the filtration sequence. This means one needs to detect dominated vertices for each $\widehat{\mathcal{G}}_n$ and remove them. Therefore, especially if the filtration sequence is long ($N$ is large), PrunIT would be a more efficient method in graph setting.

We run experiments on the on Email-Enron dataset with 36K nodes and 183K edges (see Table 1) for PrunIt and Strong Collapse methods with degree filtering function. We provide the results in the supplementary material. In particular, we tried two different threshold step sizes $\delta_1=4$ and $\delta_2=12$ which give filtration sequence of lengths $N_1=346$ and $N_2=116$ respectively. In Table below, we give the computation times in seconds for PrunIT and Strong Collapse algorithm to eliminate dominated vertices before PH computations. For PH computation step, recall that PH computation is cubic in terms of count of simplices [OPTGH 2017]. In Table below, we also give these simplex counts for each method. The details can be found in the supplementary material.
Since Openreview does not accept table format, we give the results as text. The table format is appearing in the paper.

[BP 2019] Boissonnat, J.D. and Pritam, S., 2019. Computing Persistent Homology of Flag Complexes via Strong Collapses. In 35th International Symposium on Computational Geometry (SoCG 2019). 

[BP 2020] Boissonnat, J.D. and Pritam, S., 2020, June. Edge collapse and persistence of flag complexes. In SoCG 2020-36th International Symposium on Computational Geometry.

[BPP 2021] Boissonnat, J.D., Pritam, S. and Pareek, D., 2021. Strong collapse and persistent homology. Journal of Topology and Analysis, pp.1-29.

[OPTGH 2017] Otter, N., Porter, M.A., Tillmann, U., Grindrod, P. and Harrington, H.A., 2017. A roadmap for the computation of persistent homology. EPJ Data Science, 6, pp.1-38.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Thank you
comment: Thank you very much for appreciating the novelty of our approach and for the valuable feedback and suggestions. We completely agree that this is a very crucial question, and it can greatly expand the impact of TDA in the subject.  Indeed, our follow-up project is to use higher order topological signatures in graph learning tasks. One obstacle in this problem is one needs to understand for which datasets, the higher order topological features can be useful before using them in these tasks. We already have some good ideas to detect these large networks with ample higher order topological features. Our Clustering Coefficient experiments (Section B.2) are indeed along these lines, and we noticed some other important factors in large networks indicating the abundance of higher topological features in them. Strongly regular graphs are a great suggestion which we did not check before. Thank you very much again for sharing this idea.

From: NeurIPS.cc/2022/Conference/Paper5964/Reviewer_nLvc
title: Thanks — no further questions
comment: Thanks a lot for the detailed answers to my questions! I see that the paper is already in the process of being substantially improved.

I am happy to raise my rating accordingly; at the same time, I encourage the authors to think about finding an example as outlined in my review: are there datasets where having access to higher-order information is critical? I would, for instance, think that strongly-regular graphs might benefit from having access to higher-order topological information.

From: NeurIPS.cc/2022/Conference/Paper5964/Reviewer_Xjqk
title: Response to authors
comment: Thank you for answering my comments. I understand the goal and the achievements of the paper better now.

I am still thinking that better comparisons are needed though (so I will stand by my score for now). To be more precise, I would really like to see what are running time improvements over general strong collapses. I understand that there is a theoretical difference since you don't need to do any checks on the complexes in the sequence, but I would really like to see how this translates experimentally. Similarly, it would be great to also showcase experiments in higher homology dimensions, and examples of data science tasks where such higher order features are useful.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: RESPONSES to REVIEWER nLvc - part 3
comment: 
${\bf Limitations:}$ There are no specific negative societal impacts arising from this work; in general, network analysis can lead to problematic results when the applied to networks that influence social behavior. The proposed methods are of a generic nature, though, and other methods for scalable network analysis exist, so the risk is mitigated.

That being said, the algorithmic limitations of the proposed pruning schemes could be discussed better. I am in particular interested in understanding whether the size of the graph becomes prohibitive for the method at some point. Moreover, are there any specific limitations on the filtration function (also asked above)?

${\bf Response:}$ Thank you very much for sharing this concern. Our reduction algorithms are based on core computation and on the datasets we run, our algorithms run times are negligible compared to PH computation. If our reduction algorithm cannot run on a graph in reasonable time, there is no hope that PH computation can be done on that graph anyway. 

We believe that the main limitation of our algorithms is the applicability to certain datasets. As TWITTER and FACEBOOK results show, the pruning algorithms may not be effective in reducing the overall run time for graphs with high cores.

Thank you very much again for your suggestions and remarks to improve our paper. Please do not hesitate to post further comments or questions.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: RESPONSES to REVIEWER nLvc - part 2
comment: ${\bf Q3:}$ Would it be possible to couple this approach with filtration learning approaches, such as introduced in Hofer et al., 'Graph Filtration Learning'?

${\bf Response:}$ This is an excellent question, further linking our reduction algorithms with ML tasks. Yes, in general, our reduction techniques can be combined with the methodology of Hofer et al., 'Graph Filtration Learning'.  In the reference you mentioned, the authors studied a fundamental question, which is to find the “best filtering function” for the given classification problem. Indeed, the “right” filtering function is often the key behind the classification performance. Under the assumption that dominated vertex value is greater than its dominating vertex value, we can invoke our PrunIt result and run the “Graph Filtration Learning” algorithm of Hofer et al. on the pruned graph which will lead to computational and (possibly) performance  gains. For node classification tasks, it would be also wise to check the relation between the class differences between dominated and their dominating vertices. With similar reasoning, our CoralTDA method can also be combined with the “Graph Filtration Learning” algorithm and other methods in.We added the respective discussion to our paper as Remark 12.


${\bf Q4:}$ How long does the pruning process itself take? I realise that this depends on a specific machine but maybe some comparison numbers could be shown (such as the reduction time as a function of the graph size).

${\bf Response:}$ Below we provide run time of our algorithms. The results indicate that in most cases, run time of our algorithms are negligible. Please note that in Table 1 we in fact give the reductions as a function of graph size and order.

CoralTDA: As we describe in Section 4 lines 147-152, the core decomp algorithm has a complexity of O(m+n). In practice, core decomposition is blazing fast. For example, on the large graphs, we have the following time costs for all the steps of coralTDA (i.e., core decom of the orig graph+finding the induced k-core graph for a betti k+1):

Brightkite	0.09secs

CA-CondMat	0.04secs

oregon		0secs

web-Stanford	0.7secs

soc-Epinions1	0.11secs

p2pGnutella31 0.07secs

Email-Enron	0.08secs

com-youtube	1.36secs

com-dblp	0.5secs

com-amazon	0.63secs

emailEuAll	0.13secs

PrunIT: As we describe in Section 5 lines 279-281, the dominating set alg has a complexity of O(|V| x d).  Our current research code (45 lines of Java code) has not been optimized for speed yet (with parallel execution or lower level function implementations in C or C++). However our results below show that  the PrunIT algorithm takes less than 10 seconds on the Brightkite dataset, which has 58K vertices. 

Brightkite	9.915secs

CA-CondMat	2.349secs

Oregon	2.688secs

web-Stanford	3157.871 secs

soc-Epinions1	57.602secs

p2pGnutella31 1.725secs

Email-Enron	19.217secs

com-youtube	918.951secs

com-dblp	18.354secs

com-amazon	11.328secs

emailEuAll	127.364s

${\bf Q5:}$ Are there any restrictions on the filtration function or does the proposed method support arbitrary filtrations? It is my understanding that the latter is the case, so potentially Vietoris--Rips complexes or 'weighted Rips' filtrations might also benefit form the method. Please clarify.

${\bf Response:}$ There is no restriction for our filtering functions for both CoralTDA and Prunit Methods. CoralTDA is independent of the filtering function by construction. For PrunIT method, as long as the key condition $f(v)\geq f(w)$  (or $f(v)\leq f(w)$) is satisfied for sublevel (or superlevel) filtration where $v$ is dominated, and $w$ is the dominating vertex. In other words, as long as we make sure that dominated vertex is activated (enter the filtration) at the same time or later than the dominating vertex, one can remove dominated vertex from the graph before computing the persistence diagrams. There is no restriction on the filtering function.

As you correctly noted, this method also works well with Vietoris-Rips complexes. With the right modifications, the method can be generalized to weighted VR filtrations for edge-weight filtration, too. However, if one wants to use weighted VR complexes where edge weights induces lengths of the edges, then filtration induced by the pairwise distance of the nodes (like power filtration) would be a completely different setting, and our methods do not apply to this case.

Because of 5000 character limit, we continue our responses in the following comment.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: RESPONSES to REVIEWER nLvc - part 1
comment: ${\bf RESPONSES\ to\ REVIEWER\ nLvc:}$

We thank the reviewer for the detailed and constructive feedback and for appreciating the novelty of the proposed methodology to reduce the size of graphs as inputs for persistent homology algorithms. Reflecting reviewers’ valuable comments, we revised our paper and clarified some of the arguments. We further generalized our PrunIt algorithm to power filtrations (Theorem 10). Revised parts are written in “blue” in the updated version of the paper. We believe that our paper was significantly improved, and hope that our responses would be sufficiently informative for you to reconsider assessing a higher rating for the revised paper.  

Detailed responses are summarized below:

${\bf Weakness:}$ Missing a real life example where the higher order persistent homology is providing better insight for the data.

${\bf Response:}$ Thank you very much for raising this concern. Yes, we completely agree on this point, but as you mentioned, because of the computational costs, almost no method goes beyond dimension-1 to apply persistent  homology in graph learning tasks. Since we mostly focused on benchmark datasets on these tasks, we focused on how much reduction we can provide, and how feasible it will become to go for higher dimensions. 

On the other hand, in Remark 3, we indirectly address your concern by showing that there are various benchmark datasets with abundant non-trivial higher topological features. In the appendix, Fig 9 and 10 show most graphs in Facebook and Twitter datasets have hundreds of higher dimensional topological features (even for dimension 4 and 5). In particular, each dot in these datasets represents a graph, where x-coordinate represent its clustering coefficient while y-coordinate represents the number of topological feature in the corresponding dimension. Unfortunately, we did not run these features for graph classification task because of the time limitation. However, existence and abundance of these features in such benchmark datasets certainly indicates the significant potential use of higher dimensional topological features in graph learning tasks in wider settings.


${\bf Corrections\ and \ Minor Edits:}$

${\bf Response:}$ Thank you very much for your suggestions. We made all the corrections and revisions in the paper as suggested. 

${\bf Edit 1:}$ Section 4.2 requires a better introduction; it should be made clear that the filtration function does not change here; potentially, the section could also be rewritten to explain more clearly what CoralTDA actually entails.

${\bf Response:}$ Thank you very much for this suggestion to improve clarity of the paper. We revised Section 4.2 and underlined how to use the filtering function with our coral result before the statement of the theorem.

${\bf Edit 2:}$ The SYN data set, unless I am mistaken, is broken in that it only consists of n copies of the same graph. The SYNTHETICNEW data set has been created as the 'fixed' version of this data set.

${\bf Response:} Thank you very much for your remark. In our experiments (e.g., figure 3), we provide results with Syntheticnew data set (e.g., SYNNew in figure 3) as well. We removed the SYN dataset results in the revision.

${\bf Q1:}$ Could you briefly expand on the proof of Lemma 5? I do not understand how this homotopy equivalence is obtained.

${\bf Response:}$ Thank you for this question. We added more details of the deformation retraction in the proof of Lemma 5. To sum up, we describe a deformation retraction (a special homotopy type) from the bigger clique complex to its subcomplex. When pushing the edge between dominated vertex and dominating vertex, we define a continuous operation in the ambient complex. We tried to give a visual explanation of the concept on Figure 2. Again, we did not write the whole technical details, as they are already given in the references mentioned. If needed, we can further expand all technical details.

${\bf Q2:}$ How is the complexity in Remark 9 calculated? I do not understand this entirely; the remark seems to require operations that do not work in constant time but have a worst-case complexity of O(n), with n being the number of vertices, thus resulting in an overall complexity that is at least quadratic.

${\bf Response:}$ Thank you very much for this question. We added more details in Remark 9. In particular, for each vertex $v$, we only need to check its adjacent vertices to determine if $v$ is dominated by its neighbor or not.  These checks require iterating over each vertex, searching vertex neighbors in the graph and getting the neighbors of each neighbor. The computational complexity is therefore $\mathcal{O}(|\mathcal{V}|\times d^2)$ where $d$ is the average degree in the graph. As d is a function of $|\mathcal{E}|/|\mathcal{V}|$, the complexity can reach qubic complexity. However, in the large networks it is always the case that $d<<|\mathcal{V}|$. We hope this clarifies your question. 

Ctd next resp

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Responses to Reviewer BSUr
comment: ${\bf RESPONSES\ to\ REVIEWER\ BSUr:}$

We thank the reviewer for the detailed and constructive feedback. Reflecting reviewers’ valuable comments, we revised our paper and clarified some of the arguments. We further generalized our PrunIt algorithm to power filtrations (Theorem 10). Revised parts are written in “blue” in the updated version of the paper. We believe that our paper was significantly improved and hope that our responses would be sufficiently informative for you to reconsider assessing a higher rating for the revised paper.  

Detailed responses are summarized below:

${\bf Weakness:}$ The weaknesses are that the full computational complexity is not explored--it is not clear to me how costly these algorithms are in the preprocessing step.

${\bf Response:}$ PrunIt and CoralTDA are quite simple (few lines of code) and cheap algorithms to execute. There are no hidden costs nor costly preprocessing steps in these algorithms. 

CoralTDA: As we describe in Section 4 lines 147-152, the core decomp algorithm has a complexity of O(m+n). In practice, core decomposition is blazing fast. For example, on the large graphs, we have the following time costs for all the steps of coralTDA (i.e., core decom of the orig graph+finding the induced k-core graph for a betti k+1):

Brightkite	0.09secs

CA-CondMat	0.04secs

oregon		0secs

web-Stanford	0.7secs

soc-Epinions1	0.11secs

p2pGnutella31 0.07secs

Email-Enron	0.08secs

com-youtube	1.36secs

com-dblp	0.5secs

com-amazon	0.63secs

emailEuAll	0.13secs

PrunIT: As we describe in Section 5 lines 279-281, the dominating set alg has a complexity of O(|V| x d).  Our current research code (45 lines of Java code) has not been optimized for speed yet (with parallel execution or lower level function implementations in C or C++). However our results below show that  the PrunIT algorithm takes less than 10 seconds on the Brightkite dataset, which has 58K vertices. 

Brightkite	9.915secs

CA-CondMat	2.349secs

Oregon	2.688secs

web-Stanford	3157.871 secs

soc-Epinions1	57.602secs

p2pGnutella31 1.725secs

Email-Enron	19.217secs

com-youtube	918.951secs

com-dblp	18.354secs

com-amazon	11.328secs

emailEuAll	127.364secs

${\bf Q1:}$ How feasible/costly is the application of these algorithms in terms of computation time? It is unclear to me at this point.

${\bf Response:}$ The algorithms are computationally quite cheap. Consider the Facebook graphs. All steps of CoralTDA take a total of 0.92 seconds on all 10 graph instances, whereas Prunit has a median time cost of 0.126secs for each graph. PH computations (without reduction) of betti 0 to betti 5 take a total time of 26.45secs on Facebook. 

The biggest benefit of reductions is to avoid running PH computations on graphs which do not have the searched betti features, because reducing the graph to an empty set obviates PH computations. In such cases, our cheap pruning algs remove all time costs of PH. THis is quite useful, because on large graphs even computing the k+1 simplices of the graph, which is a necessary first step of PH computations, can take a huge amount of time and memory. 

${\bf Q2:}$ Figure 7 is unclear to me. Time reduction in what? Computation of PH?

${\bf Response:}$ We compare the total run time  in computing the PH (e.g., betti numbers) before and after running our CoralTDA algorithm and report the reduction in total computation time. In other words, time reduction  is computed as:

$T$= Run time of PH on the given graph

$T_{prun}$= Total run time computing PH on the pruned graph.

Figure 7 report the results of $\dfrac{T-T_{prun}}{T\cdot 100}$. 

We would like to stress that the run time of our reduction algorithms (especially CoralTDA) is negligible compared to PH computation.

${\bf Q3:}$ Some datasets are reduced from around 1M vertices to about 0.5M vertices. While impressive, this still seems out of the range of feasibility for a PH calculation.

${\bf Response:}$ We agree that the reduction in some datasets could still limit the application of existing PH  computations to those datasets. For those datasets, our algorithms may need to be supplemented with other approaches (e.g., pruning techniques that provide approximate results instead of the algorithms presented in this paper that provide exact PH computations). 

Still our algorithms show that in many datasets (e.g., those that do not have high cores) reductions could be significant and make the direct application of the existing PH computation techniques feasible. 

Thank you very much again for your suggestions and remarks to improve our paper. Please do not hesitate to post further comments or questions.
 
-------------------------------------------------------------------------------------------------------------------------------

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Response to Reviewer Xjqk - part 3
comment: 
${\bf Limitations:}$ It would be good to discuss the fact that the proposed method is limited to flag complexes built from graphs. Can CoralTDA be extended to more general types of graph filtrations?

${\bf Response: }$ Thank you for this thought provoking question. Because of computational reasons and flexibility of choice of filtering functions, we focused on sublevel/superlevel filtration of graphs with flag complexes which are currently the most common method in practice for graph learning tasks. While it is not common, our method might be generalized to Čech filtrations with similar methods. 
Another popular method is power filtration, but because of its high computational cost, this method is mostly used for datasets with small graphs. Our PrunIt algorithm successfully extends to power filtrations. We add the following theorem (Theorem 10) to the paper as extension of PrunIt to power filtrations:

Theorem 10: Let $\mathcal{G}=(\mathcal{V},\mathcal{E})$ be an unweighted connected graph. Let $\widehat{PD}_k(\mathcal{G})$ represent $k^{th}$ persistence diagram of $\mathcal{G}$ with power filtration. Let the vertex $u\in\mathcal{V}$ be dominated by $v\in \mathcal{V}$. Then, for any $k\geq 1$, $\widehat{PD}_k(\mathcal{G})=\widehat{PD}_k(\mathcal{G}-\{u\}).$

Unfortunately, for Coral TDA, our method does not extend to power filtration as powers of $\mathcal{G}$ and powers of $k$-core of $\mathcal{G}$ can be topologically very different. We gave the following remark and counterexample for this extension as Remark 11.
Remark 11: Of course, after the previous result, the natural follow-up question is \textit{"Does CoralTDA also extends to power filtrations?"}. Unfortunately, the answer to this question is "No". The reason is by the nature of power filtration, one keeps adding edges to the existing vertices, and the degrees of the vertices increase in each step. This means $k$-cores significantly changes during this process. A simple counterexample can be found in [Adamazsek 2013, Corollary 6.7], where the author completely classifies the topological types of clique complexes of the powers of cyclic graphs $\{C_n\}$, i.e., A graph which forms a circle. e.g., $C_5$ is a connected graph with 5 vertex and 5 edges. By definition, any $3$-core of a cyclic graph is empty. However, Adamazsek's result show that for any dimension $k$, there exists topological features $\widehat{PD}_k(C_n)$ is nontrivial for $n\geq 2k+3$. If coralTDA could be extended to power filtrations, then $\widehat{PD}_k(C_n)$ would be trivial for any $k\geq 3$.

[Adamazsek 2013] Adamaszek, M., 2013. Clique complexes and graph powers. Israel Journal of Mathematics, 196(1), pp.295-319.

Thank you very much again for your suggestions and remarks to improve our paper. Please do not hesitate to post further comments or questions.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: Response to Reviewer Xjqk - part 2
comment: 
${\bf Q2:}$ What software was used for the (exact or reduced) persistence diagram computations?

${\bf Response:}$ We used TDA: Statistical Tools for Topological Data Analysis R package. 
https://cran.r-project.org/web/packages/TDA/index.html

${\bf Q3:}$ Why do the authors not compare against the strong collapse method (in https://arxiv.org/abs/1809.10945)? This would make the use of CoralTDA more convincing.

${\bf Response:}$ Thanks again for this question. As we mentioned in our previous response, with our PrunIT algorithm, we indeed use strong collapse (AKA folding) in our setting. Strong collapse is a well-known operation in algebraic topology and a simple application of a very fundamental method, called deformation retract, in the simplicial complex setting [Hatcher 2002, Adamazsek 2013]. Their method needs checking induced simplicial complexes in the filtration which would slow down the process, but would not improve the result as they would be the same. Our use of strong collapse is much more practical than the cited paper, and gives a very fast way to reduce graph sizes by skipping the induced clique complexes. This is because we consider strong collapse in our specific graph setting with common PH method sublevel/superlevel filtration, and give a simple condition which can be checked at graph level which guarantees the domination condition in the induced clique complexes. We hope this answers your question. If needed, we can make the experiments requested.

[Hatcher 2002] Hatcher, A., 2002. Algebraic topology, Cambridge Univ. Press, Cambridge.

[Adamazsek 2013] Adamaszek, M. Clique complexes and graph powers. Israel Journal of Mathematics, 196(1):295–319, 2013.

${\bf Q4:}$ Why do the authors only benchmark on persistence in dimension 0? PH in dimension 0 is known to be much easier to compute (almost linear complexity) so it would make more sense to also measure the improvements for persistence in higher dimensions.

${\bf Response:}$ Yes, you are right, in higher dimensions, our algorithm would give much higher reductions. The main reason we did not give time reductions for PrunIt algorithm in higher dimensions is that these benchmark datasets are very large graphs (Table 2) and it was computationally very expensive to compute persistence diagrams in higher dimensions. We hoped that the significant performance of our method even in dimension 0 would be convincing enough. If needed, we can add these experiments in the revision. Note that for our Coral TDA algorithm, we benchmarked all our time reduction experiments in all dimensions up to 5 as it can be seen Figure 3, 6,7,8.

${\bf Q5:}$ Supplementary, l.625: "none of the vertices of S are removed from G^i": more details should be added because this statement is exactly what one wants to prove, and it is not very clear at first sight.

${\bf Response:}$ The proof is inductive on the core index $i$. None of the vertices in $S$ can be removed in any core $i\leq k+1$ since all the vertices in $S$ have degree $\geq k+1$ as any vertex in $S$ is connected to at least $k+1$ vertex in $S$. So none of the vertices in $S$ can reduce degree if all the vertices in $S$ stays in $S$ during coral reduction. In other words, since the vertices of $S$ have degree $\geq k+1$ because of the other vertices in $S$ (not because of outsider vertices), no vertices of $S$ can be removed during coral reduction for $i\leq k+1$. To visualize the deformation retract, in Figure 2, one can push vertex $1$ in the clique complex $\widehat{\mathcal{G}}$ towards vertex $3$ along the edge between them. After the push, the $2$-simplices [1,2,3] and [1,3,4] are pushed to the edges [2,3] and [3,4] respectively. We hope this clarifies the question. Thanks again for pointing out this. We added these details to the proof in the revision. Please let us know if more details are needed.

Because of 5000 character limit, we continue in the next comment.

From: NeurIPS.cc/2022/Conference/Paper5964/Authors
title: RESPONSES to REVIEWER Xjqk:
comment: ${\bf RESPONSES \ to\ REVIEWER \ Xjqk:}$

We thank the reviewer for the detailed and constructive suggestions. Reflecting your and other reviewers’ valuable comments, we revised our paper and clarified some of the arguments. In particular, thanks to your insightful remark, we further generalized our PrunIt algorithm to power filtrations (Theorem 10). Revised parts are written in “blue” in the updated version of the paper. We believe that our paper was significantly improved, and hope that our responses would be sufficiently informative for you to reconsider assessing a higher rating for the revised paper. 

Detailed responses are summarized below:

${\bf Weakness 1:}$ First, some more efforts have to be put in the positioning. Although CoralTDA seems relevant and original, it is quite difficult to understand what are the differences between PrunIT and the method of strong collapses for computing the persistence of flag complexes (https://arxiv.org/abs/1809.10945). It really looks like that PrunIT is a mere application of an existing method to graph data.

${\bf Response:}$ Thank you very much for sharing this point. PrunIt may look similar to strong collapse, but we give a very practical condition ($f(v)\leq f(w)$) which does not require checking the sequence of simplicial complex one by one but checking the values of the filtering function for dominating and dominated nodes $\textit{in\ the\ graph.}$ We do not need to check the clique complexes as the reference does, and directly eliminate the dominated node from the graph if its value is greater than or equal to the dominating vertex in the sublevel filtration. Considering the sublevel/superlevel filtration is the most common method in the application of persistent homology in graph and node classification tasks, our PrunIt approach gives a very practical way to use this important method of algebraic topology.

${\bf Weakness 2:}$ Second, I think the experiments are nice, but are not that convincing since all of them show the reduction in the number of vertices and edges, but only a few actually display the running time improvements, which is the main motivation of this work. I think a more extensive comparison of running times is necessary.

${\bf Response:}$  Due to space limitations, we provide additional computation time results  in  appendix (see figure 7 in addition to figure 4). Our results show that in some cases and for higher betti numbers, our algorithms (e.g. CoralTDA) may have a 100% reduction in run time for computing the PH. At the same time, our results indicate that for datasets that have high cores (e.g., TWITTER and FACEBOOK) most vertices cannot be peeled away in core reduction and do not result in time reduction. At the same time, the run time of our algorithms is negligible compared to PH computations. Please see the response to reviewer 2 for specific run time comparisons.

${\bf Q1.}$ If PrunIT is really just an application of strong collapses (as I said above), I think the experiment section should focus on CoralTDA. It would also make this section more clear and consistent if the authors used the same plots and methods for every data set, instead of showing vertex reduction in different forms (e.g., histograms, curves, box plots...), using different techniques (sometimes it is CoralTDA, sometimes PrunIT, sometimes both...), and showing running times for only two data sets.

${\bf Response:}$ Thank you very much for this question. As we underlined in Remark 6, strong collapse or folding is a well-known method (AKA deformation retract) in algebraic topology which reduces the size of the simplicial complex by keeping the homotopy type same. For your question, yes, this is exactly an application of strong collapses in this setting. In the reference you mentioned, the authors use strong collapses to simplify the simplicial complexes in the filtration sequence one by one. In our version, we give a very practical condition ($f(v)\leq f(w)$) which does not require checking the sequence one by one but checking the values of the filtering function for dominating and dominated nodes in the graph. We do not need to check the clique complexes as the reference does, and directly eliminate the dominated node from the graph if its value is greater than or equal to the dominating vertex in the sublevel filtration. Considering the sublevel/superlevel filtration is the most common method in the application of persistent homology in graph and node classification tasks, our PrunIt approach gives a very practical way to use this important method of algebraic topology.

Because of 5000 ch. limit, we continue in next comment.

From: NeurIPS.cc/2022/Conference/Paper5964/Reviewer_Xjqk
rating: 4: Borderline reject: Technically solid paper where reasons to reject, e.g., limited evaluation, outweigh reasons to accept, e.g., good evaluation. Please use sparingly.
confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work.
summary: In this work, the authors propose to combine two speedup techniques for significantly speeding up the computation of persistence diagrams on large graphs. The proposed approach first reduces the graph by strong collapsing every dominated vertex, and then further reduces the graph by computing its (k+1)-core (when dealing with k-dimensional homology). The authors prove that such operations preserve the persistence diagram, and then provide significant improvements over running times for various graph data sets.  
strengths_and_weaknesses: I think the paper tackles an important question (since persistent homology is known to be hard to compute) and that its writing is very good and clear. The mathematical arguments are simple and easy to follow, making the paper mathematically sound (at least to me).

However, the paper suffers from two weaknesses.

First, some more efforts have to be put in the positioning. Although CoralTDA seems relevant and original, it is quite difficult to understand what are the differences between PrunIT and the method of strong collapses for computing the persistence of flag complexes (https://arxiv.org/abs/1809.10945). It really looks like that PrunIT is a mere application of an existing method to graph data.

Second, I think the experiments are nice, but are not that convincing since all of them show the reduction in the number of vertices and edges, but only a few actually display the running time improvements, which is the main motivation of this work. I think a more extensive comparison of running times is necessary. 
questions: ---If PrunIT is really just an application of strong collapses (as I said above), I think the experiment section should focus on CoralTDA. It would also make this section more clear and consistent if the authors used the same plots and methods for every data set, instead of showing vertex reduction in different forms (e.g., histograms, curves, box plots...), using different techniques (sometimes it is CoralTDA, sometimes PrunIT, sometimes both...), and showing running times for only two data sets.

---Concerning running time comparisons: 

***What software was used for the (exact or reduced) persistence diagram computations? 

***Why do the authors not compare against the strong collapse method (in https://arxiv.org/abs/1809.10945)? This would make the use of CoralTDA more convincing.

***Why do the authors only benchmark on persistence in dimension 0? PH in dimension 0 is known to be much easier to compute (almost linear complexity) so it would make more sense to also measure the improvements for persistence in higher dimensions.

---Supplementary, l.625: "none of the vertices of S are removed from G^i": more details should be added because this statement is exactly what one wants to prove, and it is not very clear at first sight.

limitations: It would be good to discuss the fact that the proposed method is limited to flag complexes built from graphs. Can CoralTDA be extended to more general types of graph filtrations? 
ethics_flag: No
soundness: 2 fair
presentation: 3 good
contribution: 2 fair

From: NeurIPS.cc/2022/Conference/Paper5964/Reviewer_BSUr
rating: 5: Borderline accept: Technically solid paper where reasons to accept outweigh reasons to reject, e.g., limited evaluation. Please use sparingly.
confidence: 5: You are absolutely certain about your assessment. You are very familiar with the related work and checked the math/other details carefully.
summary: The authors give two methods for data reduction that do not alter the calculations needed for persistent homology. 
strengths_and_weaknesses: The strengths of the paper are that the algorithms are straightforward and very general. The weaknesses are that the full computational complexity is not explored--it is not clear me how costly these algorithms are in the preprocessing step.
questions: - How feasible/costly is the application of these algorithms in terms of computation time? It is unclear to me at this point.
- Figure 7 is unclear to me. Time reduction in what? Computation of PH?
- Some datasets are reduced from around 1M vertices to about 0.5M vertices. While impressive, this still seems out of the range of feasibility for a PH calculation. 
limitations: Yes, the authors have addressed limitations.
ethics_flag: No
soundness: 4 excellent
presentation: 3 good
contribution: 2 fair

From: NeurIPS.cc/2022/Conference/Paper5964/Reviewer_nLvc
rating: 8: Strong Accept: Technically strong paper, with novel ideas, excellent impact on at least one area, or high-to-excellent impact on multiple areas, with excellent evaluation, resources, and reproducibility, and no unaddressed ethical considerations.
confidence: 5: You are absolutely certain about your assessment. You are very familiar with the related work and checked the math/other details carefully.
summary: This paper presents a new method for calculating persistence diagrams,
i.e. topological descriptors, of *large graphs* in an efficient manner.
This is accomplished by two fundamental insights, the first one being
that only specific types of nodes can contribute to high-dimensional
topological descriptors, the second one being that some nodes are
essentially redundant for the calculation. More precisely, the first
insights necessitates simplifying the graph to its $k$-core, i.e. the
subgraph induces by all vertices whose degree is *at least* $k$. This
graph is shown to be sufficient for calculating topological descriptors
up to dimension $k-1$. The second insight necessitates removing specific
vertices (thus reducing the size of the graph) that are *dominated* by
other vertices in terms of a filtration, i.e. an ordering of the nodes
in the graph. Experiments demonstrate that the proposed method can often
reduce the size of graphs from real-world and benchmark data sets to
a substantial extent.

strengths_and_weaknesses: The main strength of the paper is that it derives a new, principled way
of reducing the size of graphs that are commonly used as inputs for
persistent homology algorithms. By demonstrating that certain
substructures of the graph can be ignored for higher-order persistent
homology calculations, the paper potentially opens the door towards
a more widespread adoption of these methods in practice. The fact that
the two tuning techniques proposed in the paper are easily to implement,
thus being readily deployable, is another strength of the paper. In
addition, I find the write-up easy to follow (with some minor issues in
terms of clarity, but more about that later).

The main weakness of the paper is that it does not make use of the
potential insights afforded by persistent homology when applied to the
reduced and pruned graphs. While I appreciate that large reduction or
compression ratios can be achieved for the graph data sets, it would
strengthen the paper if the methods were also used in a directed
application. For instance, suppose (for the sake of the argument) that
existing graph learning techniques reach a certain accuracy on one data
set, and it requires knowledge about higher-order topological features
to provide a better classification. If the paper could find a case in
which previous work did *not* rely on such higher-order features (as
most TDA works are wont to do because of computational concerns), but
higher-order features turn out to be crucial for good predictive
performance, a strong case for the proposed reduction schemes would be
made. I believe that even a single such example, which would be easy to
generate even within the review cycle, would add an enormous amount of
scientific value/utility to this paper.

In summary, I believe that with a few additional modifications, this
paper could be a very good contribution to the conference.

## Detailed Comments

- Consider citing Hofer et al., Deep Learning with Topological
  Signatures, as one of the earliest examples of how to combine
  topological concepts with machine learning concepts.

- In the introduction, a brief explanation of terminology such as
  'filtration' would be helpful to make the paper more accessible to
  non-expert readers.

- Please use the spelling 'Čech complex,' not 'Cech complex'

- For consistency reasons, the term 'filtration function' should be
  preferred instead of 'filtering function.'

- Section 4.2 requires a better introduction; it should be made clear
  that the filtration function does not change here; potentially, the
  section could also be rewritten to explain more clearly what CoralTDA
  actually entails.

- The `SYN` data set, unless I am mistaken, is broken in that it only
  consists of $n$ copies of the *same* graph. The `SYNTHETICNEW` data
  set has been created as the 'fixed' version of this data set.

- In Figure 5, change the scale to '%' for consistency (all other
  figures use '%' in their scales)

## Typos and minor comments

The paper is well written and clear (with some mild caveats concerning
the accessibility for non-experts). The authors are to be commended
here!

- '[...] it is higher Betti numbers are prevalent' --> 'higher Betti numbers are prevalent'

- '(See Figure 3 [...])' --> '(see Figure 3 [...])'

- 'in simplicial complex setting' --> 'in a simplicial complex setting'

- 'take $k$-core' --> 'take the $k$-core'

- The closing parenthesis ')' is somtetimes cut off in figures (such as
  Figure 6)
questions: 1. Could you briefly expand on the proof of Lemma 5? I do not understand
   how this homotopy equivalence is obtained.

2. How is the complexity in Remark 9 calculated? I do not understand
   this entirely; the remark seems to require operations that do not
   work in constant time but have a worst-case complexity of $O(n)$,
   with $n$ being the number of vertices, thus resulting in an overall
   complexity that is *at least* quadratic.

3. Would it be possible to couple this approach with filtration learning
   approaches, such as introduced in Hofer et al., 'Graph Filtration
   Learning'?

4. How long does the pruning process itself take? I realise that this
   depends on a specific machine but maybe some comparison numbers could
   be shown (such as the reduction time as a function of the graph size).

5. Are there any restrictions on the filtration function or does the
   proposed method support arbitrary filtrations? It is my understanding
   that the latter is the case, so potentially Vietoris--Rips complexes
   or 'weighted Rips' filtrations might also benefit form the method.
   Please clarify.
limitations: There are no specific negative societal impacts arising from this work;
in general, network analysis can lead to problematic results when the
applied to networks that influence social behaviour. The proposed
methods are of a generic nature, though, and other methods for scalable
network analysis exist, so the risk is mitigated.

That being said, the *algorithmic limitations* of the proposed pruning
schemes could be discussed better. I am in particular interested in
understanding whether the size of the graph becomes prohibitive for the
method at some point. Moreover, are there any specific limitations on
the filtration function (also asked above)?
ethics_flag: No
soundness: 4 excellent
presentation: 3 good
contribution: 3 good