A Scalable Approach for Mapper via Efficient Spatial Search
Authors: Luca Simi
Venue: Accepted by TMLR ()

Abstract: Topological Data Analysis (TDA) is a branch of applied mathematics that studies the shape of high dimensional datasets using ideas from algebraic topology. The Mapper algorithm is a widely used tool in Topological Data Analysis, used for uncovering hidden structures in complex data. However, existing implementations often rely on naive and inefficient methods for constructing the open covers that Mapper is based on, leading to performance issues, especially with large, high-dimensional datasets. In this study, we introduce a novel, more scalable method for constructing open covers for Mapper, leveraging techniques from computational geometry. Our approach significantly enhances efficiency, improving Mapper's performance for large high-dimensional data. We will present theoretical insights into our method and demonstrate its effectiveness through experimental evaluations on well-known datasets, showcasing substantial improvements in visualization quality and computational performance. We implemented our method in a new Python library called \emph{tda-mapper}, which is freely available at \url{https://github.com/lucasimi/tda-mapper-python}, providing a powerful tool for TDA practitioners and researchers.

Published in Transactions on Machine Learning Research (01/2025)
A Scalable Approach for Mapper via Efficient Spatial Search
Luca Simi
bucasinni900@mmaillccm com
Reviewed on OpenReview: https: opwn://veeeevveeeeeeemm net/ formn? id= LTX4bYREAZ
Abstract
Topological Data Analysis (TDA) is branch of applied mathematics that studies the shape of high dimensional datasets using ideas from algebraic topology. The Mapper algorithm is a widely used tool in Topological Data Analysis, used for uncovering hidden structures in complex data. However, existing implementations often rely on naive and inefficient meth- ods for constructing the open covers that Mapper is based on, leading to performance issues, especially with large, high-dimensional datasets. In this study, we introduce a novel, more scalable method for constructing open covers for Mapper, leveraging techniques from com- putational geometry. Our approach significantly enhances efficiency, improving Mapper's performance for large high-dimensional data. We will present thcorctical insights into our method and demonstrate ils effectiveness through experimental evaluations on well-known datasets, showcasing substantial improvements in visualization quality and computational performance. We implemented our method in a new Python library called tda-mapper, which is freely available at https:///ithub. cttol/oommmccceeaa www.//ooooocooooeeee wappttdddaaaapappaaeee -pythnn provid- ing powerful tool for TDA practitioners and researchers.
1 Introduction
In recent years, Topological Data Analysis (TDA) has gained significant traction in the field of data science due its ability extract valuable insights from complex datasets. TDA uses topological methods that are resilient noise and dimensionality, making it robust mathematical framework for data analysis. A well-known technique in TDA is the Mapper algorithm. Mapper provides visual representation of data in the form of graph, called Mapper gruph, enabling easy exploration and interpretation. Unlike conventional algorithms, such as clustering algorithmms or Principal Component Analysis (PCA), Mapper excels at visualizing data by preserving their connected components, making it very effective for shape analysis and pattern discovery. The effectiveness of Mapper was initially demonstrated in the analysis of medical data, as showcased the pioneering work by Singh et al. (2007) and later works by [Callsson] (2009 2014). Since then, Mapper has proven to be a versatile and powerful tool for data exploration, capable of uncovering hidden patterns even in high-dimensional datascts.
Data exploration is an ilerative and interactive process that requires continuous fine-tuning and adjust to extract meaningful insights. Consequently, software for Mapper must prioritize low running times and minimal memory usage to encourage adoption and be practically useful. The original description of Mapper (Singh et al. 2007) includes what has now become a standard approach, involving the construction of an open cover made of overlapping hyperrectangles, also known as standard cubical cover. Currently, rescarchers and developers have access several established open-source libraries for Mapper. However, these libraries work well with low dimensional lenses, but their approach is often inefficient in higher dimensions. On one hand the standard cubical cover is often assembled from open covers obtained in lower dimensional projections, and this makes the number of steps grow exponentially with the dimension, which is computationally unfeasible. On the other hand, points in dimension & can fall in the intersection of up to 2 hypercubes, resulting in complex Mapper graphs that are hard to explore, and often have more connected components than points are in the datasot. These crucial points has been consistently overlooked and neglocted, reinforcing the misconception that Mapper is inefficient with nigh-dimensional data. Motivated by these limitations, recent advancements in the field have led to the development of wide family of Mapper-type algorithms, each proposing distinct

---

Published in Transactions on Machine Learning Research (01/2025)
adaptation of the original concept. For instance, Ball Mapper (Dlokko 2019] and Mapper Boll Mapper (Pawel Dlotko & Sazdanovic 2024) construct the open cover by creating an e-net (Gonzalez 1985). adopting open balls centered in the points of the dataset instead of evenly-spaced hyperrectangles. Additionally, specialized variations like NeuMapper (Geniesse et al.) 2022), designed specifically for neuroscience data, adopt a more complex approach. This method, partially inspired by Ball Mapper, employs an intrinsic metric derived from reciprocal kNN. These adaptations all shift towards changing the way open covers are built, improving computational performance, but giving away the control on the overlap of the open sets. While this is often acceptable, there are cases where using cubical cover with uniform overlap is beneficial, especially given its foundational role in many Mapper-related results. For instance, it's possible to estimate optimal parameters for the standard cubical cover (Carrière et al.) 2018), minimizing the need for time- consuming manual fine-tuning.
In this work, we introduce a novel and more efficient approach to computing Mapper-type algorithms, lever- aging concepts from computational geometry, aimod at solving the probloms of currently available implemen- fations. Our method uses greedy adaptation of e-nel. (Gonzalez, 1985; Diotko 2019), called prozimily-nel, to construct subcover of the standard cubical cover, preserving the evenly overlapping open sets of the standard cubical cover, as defined in the original Mapper implementation. Morcover, we show how we can improve the overall efficiency of Mapper by adopting specialized data structures for spatial search like metric trees Clarkson 2006 Brin 1995 Yianilos 1993 [hhmann 1991p. We also provide a theoretical analysis on the complexity of building cubical covers, obtaining an upper bound that explicitly incorporates the doubling dimension of the dataset (Krauthgamer & Lee 2004). We present theoretical insights into our method, supported by experimental evaluations on well-known datasets, highlighting significant improve- ments in rumning time compared to the standard approach. Additionally, introduce our open-source library, ida-mapper (Simil 2024), available at best of our knowledge, it is the only library implementing this approach. Finally, we compare our method with existing software libraries for Mapper, including Kepler Mapper (van Veen et al.] 2019) and giotto-tda (Tauzin et al., 2021]. Performance tests demonstrate the advantages of our method in terms of scalability and efficiency, underscoring its potential for large-scale applications.
To the
2 Preliminaries
This section introduces the fundamental definitions and notations necessary for the remainder of this work. While many of these concepts are foundational in topology and computational geometry, and are widely available, they are included here for completeness. The concept of e-net, introduced in Gonzalez (1985), is widely used in computational geometry (see also Clarkson (2006)) ), and is central for the contributions of this work. This notion has been previously used by Diotko 2019) in the context of TDA as the foundation for a variant of Mapper called Ball Mapper. The notion of c-net is also closely related to the doubling dimension of a metric space, that was rnduede for the first lime in Assouad (1983) and later Gupla et al. (2003). Compared to other definitions in literature, the doubling dimension offers practical measure of intrinsic dimensionality that remains valuable for discrete finite sets. As we will see later, we will leverage the doubling dimension to estimate the complexity of our proposed approach, in the form of Theorem 3
Definition 1. Let X be lopological space. A pseudo-metric on X is map d: X X + RR satislying:
d(z, v) 2 0 for all x, y E X, with d(I,I)= = 0;
Symmetry: d(z1,22) d(z2,21) for all 21, E X;
Triangle inequalily: d3)), d(2), + 23) for all 02, E X.
If d(x. 0 implics z y, then d is metric. An open ball of center p X and radius <> 0 is defined as Ba(p,e) = (x X d(p,x) < e).
Definition 2. Let f: X + Y be map and d pseudo-metric on Y. The pullback of d under f is the pseudo-metric f'd on X, defined by:
())
for all u, v E X.
2

---

Published in Transactions on Machine Learning Research (01/2025)
Definition 3. Let (X, d) be pseudo-metric space. An e-net of X is subset N S X such that:
d(a, v) 2 for all 2, E N, + y;
For every X, there exists E N with d(z, y) <.
It's possible to construct an e-nct using a greedy procedure, as reported in Algorithm T we start with an emply set N and al each step we add a point to N that it's further than e from N itself. At last, when no point is left pick, end up with N which is an e-net by construction.
Algorithm Greedy construction of an c-nct
Require: A pseudo-metric space (X, d) and > 0 Ensure: An e-net N - X
N+0 0
while C(N)N,
> do Take p X N maximizing d(p, N)
N N (p) {p}
end while return N
Definition 4. Let (X,d) be pseudo-metric space. The doubling measure of X is the smallest À >> 0 such that every ball in X can be covered by À balls of half the radius. The doubling dimension of X is defined as dim(X)= = log2 A.
Proposition 1. The doubling dimension satisfies the following two properties:
Let X and Y be pseudo-metric spaces. If X CY, then dim(X) S ddim(Y).
For any p 2 the vector spaces R& with the Lp-metric satisfy dim(R*) O(k).
Proposition 2. Let (X,d) be pseudo-metric space and N c-net for X. Then for any ball B(p, R) in X,
N B(p, R3] o ( ((R/c)
The time complexity of Algorithm is proportional to the cardinality of the c-net. Therefore, as a conse- quence of Proposition 2 is ((R/e)dim(X))
2.1
Mapper algorithm
In this subsection, we provide a concise overview of Mapper, based on its original formulation (Singh et al. 2007) (see Figure for an example). Mapper operates on a dataset X and its output is determined by the following steps:
1. Let. f be lens, defined any continuous map f: X + Y, where Y parameter space. Common choices for the lens include statistics of any order, projections, entropy, density, eccentricity, and more.
2. Next, proceed by constructing open cover for f(X). In other words, create collection {Ua}a of open sets such that their union covers the entire image f(X), i.c., f(X) = U Ua. It is important to note that the sets in this open cover may intersect with one another, and they inherit their topology from the space Y.
3. For each element Un in the selected cover, we define V,, as the preimage of Un under the function f. is clear that the collection [Va)a forms an open cover of X. Next, we proceed by applying a user-specified clustering algorithm, order to partition cach open set V, into a disjoint union of clusters, denoted as Va IIsCa,g. The resulting family {Ca,pla,s is referred cover for X.
a refined open
3

---

Published in Transactions on Machine Learning Research (01/2025)
4. We construct the Mapper graph as the undirected graph G (V. defined by the following rule: the set V contains vertex va,3 for every local cluster Ca.s, while the set E contains the edge
e = (Vas,B1 Vo) only if their corresponding local clusters intersect, i.., when Cor O noa.99 $ D.
X
Y
Y
-
Figure 1: The four steps of Mapper an X-shaped dataset where the lens is the projection the Y-axis. Clusters from the same open set share the same color.
The Nerve Theorem. The theoretical foundation of Mapper is rooted in the Nerve Theorem (Borsuk, 1948 Weil 1952), a fundamental result in algebraic topology that establishes a connection between a topo- logical space and a combinatorial representation of its open covers. Specifically, it states that an open cover U of a topological space forms good cover, i.c. every finite intersection of sets in U is either empty or contractible, then the nerve ((4)), simplicial complex encoding the intersections of sets in U, is homotopy equivalent to X. The nerve ((4) is constructed by associating (k- 1)-dimensional simplex to each non-emply intersection of k sets in U.
Theorem 1. Let X be topological space and U = JUa)o be open cover of X. If every finile intersection Ug n... U....U,, U is either empty or contractible, then (U) is homotopy equivalent to X.
The Nerve Theorem is central to tools like Mapper because it enables the simplification of topological spaces into combinatorial structurcs, making them amenable to computational analysis. In the context of Mapper, the refined open cover U of X (produced through clustering on the pullback cover) gives rise to the Mapper graph, which can be seen as the 1-dimensional truncation of N Here, O-dimensional simplices correspond nodes, and I-dimensional simplices correspond to edges. When U/ is good cover, the Mapper graph retains topologically relevant information about X. In particular:
The connected components of the Mapper graph (0-cycles) accurately reflect the connected compo- nents of X.
Loops in the Mapper graph (1-cycles) correspond to 1-cycles in N()), but not all such loops are topologically meaningful. Only 1-cycles that are not boundaries (i.e., elements of the 1-dimensional homology group (X)) represent genuine fcatures of X.
However, the Mapper graph cannot distinguish between true topological holes and I-cycles that are bound- aries (1-boundarie)) in the full nerve N(U), because information about higher-dimensional simplices (c.g., 2-simplices arising from triple intersections) is lost during truncation. Moreover, the clustering step may produce artifacts that violate the good cover condition, for example, by merging disconnected regions or disrupting simple-conneclednes. In such cases, the correspondence between X and the Mapper graph can break down. Nevertheless, when the good cover condition holds, the Mapper graph faithfully encodes the connected components and provides useful insights into the 1-dimensional topology of X.
The good cover condition explains why Mapper includes clustering in its steps. Clustering is used to split the open sets the pullback, as a rough approximation of taking connected components. For example if the lens f is projecting X to lower dimensional space, which typical in the context of the classical Mapper, the clustering step becomes very important, since a projection can have multiple folds: if B, small ball at (p) the number of connected components of (Bp) jump when crossing critical values.
4

---

Published in Transactions on Machine Learning Research (01/2025)
2.2 Standard Cubical Cover
In the original definition of Mapper (Singh et. al. 2007 the authors use open cover defined by two parameters: the length w of the intervals and the overlap p E (0, 1/2], which is the fraction of w that corresponds to the length of the intersection of any two adjacent intervals in the cover. This type of cover is sometimes referred to as a cubical cover or implicitly as a standard cover in the literature. In the rest of this work we will refer to such cover as standard cubical cover, and to any of its subcovers as cubical cover. We denote by f(X) I2* the space on which the cover constructed.
Definition 5. Let < a E and p E (0,1/2) Let Y C IR compact. Let m = min(Y), M = max(Y),
W
(1 p) 8 pw and define
aj m + j(w 6) 6/2, by (j (w 6
The standard cubical cover of Y with intervals and overlap is the collection of open sets
CCyy {lag. b,) Yilj 0, ..... 1}.
B
by
22 b
a3
bg
M
6 pw
Figure visual representation of standard cubical cover in the onc-dimensional case with n
The value w M-m
m(1-p) correspond the length of every interval, while å pw corresponds the length of the overlap of any two adjacent intervals (see Figure 2
Definition 6. Let 0 < n E N and (0, 1/2]- Let Y C R* compact and let Y, be the projection of Y on the i-axis. The standard cubical cover of Y with n intervals and p overlap is the collection of open sets
CCT -
ARYY+UR
ROY # 10R R
II cCy. 1=1
Remark 1. We report here some facts that easily follow from the definition in the case of one-dimensional standard cubical cover for some Y C [m, M].
b; a; w for every 0, .....
4n = m 8/2 and bn-1 = M + 8/2;
a = 8 for every i 0, o....,
[m, by 5/2)..... (a, + 8/2, by - (22),...[[n_111 + 6/2, is a partition of [m, M).
notion of standard cubical cover that simplifies it's worth to point out that this definition may slightly diverge in literature. For example, some authors and software libraries define the standard cubical cover of [n, .M] in a way such that dg and b M. However, it's also important to remark that this definition is compatible with the results presented in Carrière ct al. 2018).
Remark: 2. In this work we
computations, but
Naive Algorithm. From Definition we can readily devise an algorithm that initially computes the standard cubical cover for cach projection independently. Subsequently, we assemble these individual open covers into an open cover for the topological space Y. We will refer this approach as naive construction of standard cubical cover and is reported in Algorithml 2 This approach becomes computationally expensive for

---

Published in Transactions on Machine Learning Research (01/2025)
high-dimeensional datasets. This is also true in the case of Mapper, when construct the standard cubical cover on high dimensional lenses. Even when many products are emply, their number can grow rapidly and introduce additional computational overhead to the entire Mapper process. To illustrate this issue, which is well known in literature, consider the following example: Y C R lies along the diagonal, an appropriate cover for Y could be achieved using a small number of rectangles, proportional to the number of intervals n. However, Algorithm 2 would construct an open cover for each projection initially and then iterate through all possible rectangles, resulting in total of n steps. As we will demonstrate later in Section 3 the primary contribution of this work is the resolution of this issue through the adoption of more efficient algorithm. Instead of relying on projections, this algorithm iterates over significantly smaller number of open sets, comparable to n ddm(((X)) < n².
Algorithm 2 Naive construction of the standard cubical cover
Require: Y finite point cloud, 0 < n E N, E 1/2].
Ensure: CCRP.
for i= L....,k do
+ the projection of Y on i-th axis; CC 5 (4.0....... 11 the standard cubical cover Y;;
end for
CC + {R= II. 0.
return CC
2.3 Ball Cover
When Y S RR rectangles centered in & can form an open cover, as in the cubical covers. However, this approach is unsuitable for arbitrary metric spaces, where rectangles may not be well-defined. Instcad, open balls centered at points in Y offer natural allernative.
In the context of Mapper, this idea has been explored in Diotko 20119) Pawel Dlotko & Sazdanovie (024)) where the author introduces Ball Mapper, variation of the original algorithm. In this approach, a greedy procedure is used to cover Y with balls of fixed radius until full coverage is achieved. This method is sometimes referred to as an e-net, although the term also describes a related concept in computational geometry (Gonzalez) (985) (see Definition 3). Notably, the centers derived in Ball Mapper satisfy the definition of an e-net according Definition making it straightforward to distinguish between these notions based context.
Definition Given a dataset Y and a metric on Y, a ball cover of radius r > on Y is any open cover where every set is an open ball of radius r.
Unlike cubical covers, ball covers center their balls on points in Y, not evenly spaced points in R While balls distancec may appear cubical, the two constructions are fundamentally different.
Cardinality of Ball Cover. The cardinality the ball cover determines the number of nodes the Ball Mapper graph, directly influencing its complexity. While bounded above by [Y], this bound impractical for large datasets. Instead, e-nets provides more useful estimate: the number of balls required proportional to (R/e)dim(() where dYm(Y) is the doubling dimension of Y (see Proposition 2
2.4 Vantage Point Trees
Given a query point and query radius range query is a function that returns the set of points within distance e from q, i.e. the points in the ball B(g, e). There are many ways to perform range queries elficiently, using different algorithms and data structures. A well-known example is the kd-tree (Friedman et al. 1977 Skrodzki 2019), which partitions the space in a hicrarchical tree-like structure that allows reduce the number of distance computations employing the triangle inequality. The use of kd-trees in Mapper-type algorithms has been explored in Do (2019), where the author notes that their effectiveness for Ball Mapper

---

Published in Transactions on Machine Learning Research (01/2025)
may be limited, particularly in high-dimensional spaces where Ball Mapper typically operates. However, believe that the approach presented in Mapper Ball Mapper from Pawel Dlotko & Sazdanovic (2024)
could benefit from incorporating specialized data structure for range queries. In this case, the open cover is constructed on the space f(X), which often lower-dimensions than the original space X. Using a data structure optimized for range queries could thus offer significant, performance boost. In our study, we aim to address diverse scenarios by using any lens function f: X - Y with no restriction on the space Y. Importantly, Y need not be strictly Euclidean or coordinate- based; it can encompass any domain where a meaningful notion of distance is defined. For all these reasons decided to chose ep-trees instead of kd-trees Yiianioss 1993 Brin 1995
Remark 3. It is important to note that vp-trees were our first choice due their flexibility, as they can be used in any metric or pseudo-metric space. However, when Y is Fuclidean domain contained within TR* it may be beneficial to explore other data structures that offer efficient spatial search. One such structure is R-Lrees (Guttman 1984), which could be particularly well-suiled for constructing cubical covers.
A pantage-pointe free, or up-tree, is binary tree data structure where each internal node organizes the points of the space according to their distance from chosen point, called vantage point. Each internal node stores tuple rp,r) as reference to the ball (p, where is the chosen vantage point, and p's descendants satisfy the up-tree property: for every left descendant we have d(p, y) I and for every right descendant we have d(p, =) 2 (see also Figure
a
b
b
e
a
g
g
Figure 3: Two represenlations of a vp-tree on the dataset Y = {a, b, e, { C R Nodes on the right correspond to balls on the left. The vp-tree property is evident: left descendants are enclosed by circles and right descendats are outside those circles.
Building Vantage Point Trees. The procedure used to build vp-tree can be sketched in this way: given a dataset Y we first chose a vantage point p from Y, then split Y into two equally-sized subsets: those points that are closer to P, and those that are farther. Repeating the procedure two trees L, obtained from the first half, and R obtained from the second one. The result is then obtained as the binary tree rooted at with L as left child and Rt as right child. We will refer to this procedure as the build__ptreeee function which is reported in Algorithm
the two halves we obtain
The time and space complexity of Algorithm 3 can be analyzed in the following way: given dataset Y, every call to build uptree can be implemented using an in-place procedure like quickselect on the input array Y, which takes O((Y)) time and O(1) space. Therefore simple application of the master theorem, building balanced vp-tree has asymptotic time complexity O( log([Y])) and asymptotic space complexity O(Y)).
Range Queries on Vantage Point Trees. After a vp-tree is built, we can perform range queries by descending from the root (see Algorithm 4j. Say we want to perform a range query for a point and radius c. Let (p, r) be the tuple stored at any internal node while visiting the vp-tree. Using the triangle incquality it's possible to skip some of p's children when certain conditions are met. In particular, we can do this in two situations: (a) when B(g,6 <) C B(p,r). equivalent to d(p,4) + e, need to visit only the left child
7

---

Published in Transactions on Machine Learning Research (01/2025)
Algorithm 3 Algorithm for build_epptiieeeee seclldd_ppeeeeY__
Require: Let Y yo, ...., ;.n.11 be a dataset, and let be metric on Ensure: build _ieeid_ppeee_e_e_e d) returns vp-tree on (Y.
if Y== then: return 0
the emply tree
else
- choose in Y.
D chose randomly
Move p at the head of Y, such that yo = p.
Let p == mediangerd(p, Y).
Reorder Y such that d(p, vi) S p for < n/2 and d(p, vz) 2 p for i i n/22
L build uptree([y),.... 1n/22
R + build Sil__pptree([Bu/ ................................ ................................ ,n 1 d)
return [root = (p,p), left L, right R}
end if
(see Figure 4a (b)
when ((q, n B(p,r) 0, equivalent to d(p.g) r e, we need to visit only the right
child (sce Figure 4b
d(p, q) s 8
d(p, q) 2 +
(a) When B(q.c) C (pp,r) r) we skip the right child, since right descendants are outside the range query.
(b) When B(q, B) = 0 we skip the left child, since left descendants are outside the range query.
Figure 4: The conditions when we need visit only one child during range queries.
Range queries can be significantly more efficient with vp-trees than with linear scans. A linear scan requires going through all the points of a dataset Y, which takes YY] steps in total. On the other hand, with vp- trees, a range query usually takes less steps, since we can often skip one child from the search due to the triangle inequality satisfied by the metric (sce Figure 4a and Figure 4b). Giving a general estimation of the average time complexity of range queries via vp-trees is particularly challenging due its dependency on the dataset (Brin 1995). can only state that, for dataset Y, it is bounded between (log([|))) and O(YY). However, when the query radius is sufficiently small, we expect to fall often in cases where skip branch from the range query. In such cases the time complexity becomes closer to O(log([))))
Ball Cover via Vantage Point Trees. It worth emphasizing that the construction of the ball cover can be improved by leveraging vp-trees alone. Specifically, one can first construct a vp-tree T on the dataset Y. Then, in the e-net algorithm, the open balls are generated using range queries T' (see Algorithm

---

Published in Transactions on Machine Learning Research (01/2025)
Algorithm 4 Algorithm for range_query(I, qq.c)
Require: Let Y be a dataset, and metric on Y. Let build vplree((, d). Let be query point, and let be query radius.
Ensure:
The open ball c)
if T is emply terminal then
return {y Tleaves d(g.v) < c
else
(p. r) - Trooot
5+0 0
if d(p, q) + then
> Opposite to Figure
S S range query(T.right,
end if
if r > d(p. q) - then
Opposite to Figure 4b
+ S range guery(T.left, g,c)
end if return end if
Algorithm Construction ball cover vp-trees
Require: Let (Y, d) be a metric space. Let r 2 0.
Ensure: A ball cover of radius r. T build vptree(Y,d)
Algorithm 3
Ne 0
C+ 0
while N * Y do
Take E Y NN - range Saage___ueryTTPpp"
b Algorithm
N N-NUB
C-
end while return C
3 Cubical Cover in Higher Dimensions
In this section, we outline the main contributions of this work. To begin, it is essential to introduce some notation.
Definition 8. Let Y C I compact. Let m, mingey ys, and Mj maxyey Ui with m, M2 for == -l..k. h. We define dy: I R$ by setting for every y (ih)==,...,. E R
- my
a
M, mi iml....k
Remark 4. In the settings of Definition the map oy: g I& is a bijection that maps to the hypercube [0, 1]. The map o -1 k + R is given by setting for each y = (y..k= R
oy (v) (m, + sMM, -m:));=........ ==1).kk
Definition 9. Let Pa: R$
be the map defined by setting for every y (yi)i=1,... E R 2)*
Im
[nnn]] + 1/2
(n(
i=1....k

---

Published in Transactions on Machine Learning Research (01/2025)
Following Definition define helper function that maps each point in Y to its closest hypercube in the standard cubical cover. Specifically, this means the function assigns the hypercube whose center is the nearest neighbor to the point among all other hypercube centers.
Definition 10. Let 0 < n E N and let p E (0, Consider the interval [m, M S R and let w M-m and i == pu. Let Oj + i(w 6) 6/2 and b;
-(1ーn)
+ (i + 1)(w 6) + 8/2. We define the cubical procimily function CP MP, p): [m, M] + P(m,, M]) by setting for every [m, M]
CP Mm, (v) M (ay, Vy E (a, + 8/2, b, 5/2).
For any Y C I compact we can define for every = (y:)i=1,... EY
CRy(n.D)()) II (n, i=1
where Y3 is the projection of Y on the i-axis.
Remark 5. For every y E [m, M] there exists only one j such that y [a, 6/2,b, 6/2), which can be easily computed as
m
j = n M m
We can extend this to higher dimension. In case of Y C R for every y (yi)==,...., Y, for each i there such that yi [ag, 6,/2, bj. 6,/2), and we have M.-ma
exists only one je
mm
CPr(n,,)()) = Y by))
This setting gives well-defined notion for CPy (n, p), since the intervals (a: + 6/2, 5/2) are partition of [m, M]] (see Remark [] We can finally state one of the main contributions of our methodology, in the form of the following result.
Thcorem 2. Let Y S R2 compact. Let n E N and let p (0,1). Then for every y E Y we have
(ny(p,))()) = Boiden ( o pn o (r)) 2n 2mp
Proof. We have (p, II (aj, bj.) where ji
#i m, M.
Then
(C(Cyy(n II
aj m
by. mi
Mi mi
M; mi
Ji + 1/2
1
Ji + 1/2
2n 2npp
2n 2np
1=1
Ji + 1/2
-ddoo
2n 2np
1
Bdoo
Palay(u)) (v)),
2n 2np
Therefore
1 CPy(n,p)()) Bdd (p(ar(u)): By
2n 2mp
-Boddo (or' opoor)()), 2n - 2mp
10

---

Published in Transactions on Machine Learning Research (01/2025)
3.1 Estimating Cardinality
As consequence of Theorem 2 developed more efficient method for constructing the elements of CCPp using vp-trees. In this subsection, provide estimate of the cardinality of CCy", which also allows to assess the overall complexity of its construction. Theorem g establishes an upper bound on the cardinality of a minimal subcover of CCy', while Corollary extends this result. to derive an upper bound on the cardinality of CCPP.
Theorem 3. Let Y C RR Then, there enist subcover C S CCPP with cardinality
dim(Y)
|C| $ 2n p
Proof. Initially we establish some notation that will make the proof casier. Let dÿ and let th oy Pn oay. Under the metric 8, Y is contained in k-dimensional hypercube of side L, and th, acts as an approximation function that maps Y to regular grid of side c, the collection CCTD consists of the balls B3 (1bn()) for each Y, where the radius is Tn 2n-2np'
Then, consequence of Theorem
First, it's easy to observe that 8(y, th (y)) en for every y Y and every n. Therefore every ball BY (r)) is contained within the ball B3 (y, + G,), which has the same center y but larger ra- dius to account for the approxination error introduced by vn. Therefore, for any chosen m, this gives our first inclusion:
By (I' (2), Tm) E By (y, rm + cm).
By recursively applying the notion of doubling dimension, the ball BY (y, Tm + em) can be iteratively covered by x balls of radius = where the depth the iteration and the doubling measure of under the metric Therefore, have:
X BB (U. + cm) S U By
I' + Cm
yj.
2
j=1
where {uy}y are the centers of the covering balls and X is the doubling measure of Y. we now consider any n 2 m, using the same argument as the first inclusion, we can write
B
Tim + cm
S C
(n (2)))
T' + Cm
+ En
2a
2a
which holds for any choice s. we then chose s such that Emttem + en S vn we can further claim that
By (n(l))) I' + em
en S BB (Un(H)))Tn)
2
The inequality tmm + en S In can be easily solved in and gives 2 logg
which holds when
set [log2 (x. 22) After this, finally set L = X and give the following estimate:
dim(Y)
= X = (Y) 2dlm(() [1-loge 2,0) n p
Summing up and chaining the inclusions together, we obtain the following
By (1) rm) C U BY yi I'm Em
c U BY (vn)))))
2a
11

---

Published in Transactions on Machine Learning Research (01/2025)
dim(Y)
Finally, sctting m and 1, = BB (vn(U)); rw), we have L $ (2n 2-
and
Y BC 1 Ö
BB (dn(U)))
U J
j=1
j=1
which concludes the proof.
Corollary 1. Let Y C IR* then
| 3* (2n- 2 - dim(Y)
p
dim(Y)
Proof. Theorem 3 states that always possible to find a subcover S C CCP where |S] (2n 2-
Since S covers every other interval I E CCT? must intersect some interval Therefore we can write
CC
A
IES
where A₁ (J E CCC JnI 0}. It's easy to that for dimensionality reasons |Ar] 3 therefore can claim that
dim(Y)
2
|CC < -8 3*
2n
p
and this concludes the proof.
Theorem 3 asserts that a minimal subcover of CCT." has cardinality bounded by value that depends solely n, p, and dim(Y). This upper bound is intrinsic as it is independent from the dimension of the feature [ is not intrinsic, as it also depends k, yet it justifies
space Rt Conversely, the inequality in Corollary why proximity-net runs in far fewer steps than n². Notably, this upper bound is very rough estimation and could potentially be improved, as the factor 3* is significantly higher than what is typically observed. While smaller factor might be achievable, remains unclear how such an improvement would be influenced by the specific dataset.
Standard Cubical Cover via Vantage Point Trees. Theorem 2 suggests how we can construct the hypercubes of the standard cubical cover as open balls under scaled Lisddittnnce. This insight leads immediate improvement in constructing the standard cubical cover: first, vp-tree T is built using the scaled -isttttacc Then, after identifying all the hypereubes and their centers (noting that some centers may not correspond to points in the dataset), the points within each hypercube can be efficiently retrieved using range queries on T centered at these points (see Algorithm
While this improvement is significant, it is still insufficient. Although it reduces the number of steps compared Algorithm a single point in the dataset may still lie in the intersection of up to 2* open hypercubes. This detail is often overlooked but has critical implications: the standard cubical cover could, in principle, contain more open sets than there are points in the dataset. This issue becomes particularly pronounced in higher dimensions, where such open covers lend to produce Mapper graphs that are too complex to provide meaningful insights.
3.2 Proximity-Net
In this work, we introduce generalization of e-net that we call prozimity-net. This modified algorithm is greedy procedure that takes single paramcter, that we call prozimity function (see Definition 11 and covers the dataset with collection of sets.
Definition 11. A prozimity function Y is map b: Y - P(Y) such that p E b(p) for any p Y.
12

---

Published in Transactions on Machine Learning Research (01/2025)
Algorithm 6 Construction of the standard cubical cover via vp-trees
Require: Let Y _ IR*, let < n E N and p E (0,
Ensure: The standard cubical cover CCV" T +- build Shild_uptree(* oz
Algorithm
3
L - (ay" on (Y)
IE6)
C t range query (T,,, 2n 2np2mp)
Theorem
Algorithm 4
return
Remark 6. The cubical proximity function (n, from Definition 10 is proximity function according to Definition [1
The proximity-net algorithm is reported Algorithm i and the only difference with respect to e-net is that the sets obtained from proximity-net are built by applying the proximity function, and therefore are not required to be open balls. This choice brings improved flexibility and allows to build diverse types of open covers by applying the same procedure to properly chosen parameter. In this section we will see how we can obtain both the ball cover and a cubical cover using proximity-net. More importantly, deriving a cubical cover from proximity-net effectively addresses the flaw of Algorithm 2 as the number of open balls is expected to be significantly fewer than n (Corollary 1
Algorithm 7 Construction of proximity-net
Require: Let Y be datasct, and let be proximity function on Y. Ensure: A cover of Y S - Y, as set
>> S is the set that tracks the points of Y not covered yet
C+ 0
while S do
Take point p S B b(p)
b Randomly or according some heuristic
Add B to C
for E B do
All the points in B are now covered
Remove from $ end for end while return C
It's worth to point out that the original e-net can be obtained by supplying proximity-net with the ball prozimity function defined as Definition 12 and further optimize it using vp-troes. This optimization is reported in Algorithm S and is essentially the same as Algorithm 5
Definition 12. Let Y C Y and let be a pseudo-metric on Y'. For each 0 we define the function (d) Y - P(Y) by setting
(dy y + HHYYn Ba(y,e.
for every y E Y'. Moreover, the restriction of (d) on Y is a proximity function that we call ball prozimity function.
Remark 7. Definition 12 allows use the same notation BPy when want to construct a ball with center that not contained in Y, but in eventually larger space Y". We will use this in Theorem 2
We can improve e-net algorithm by first building a vp-tree T on the dataset be covered. After that we can call proximity-net (Algorithm by supplying a function that for each point p performs range query T. This approach (Algorithm is eventually faster than the original e-nct approach.
Remark The ability to work with pseudo-metrics, rather than just metrics, is an invaluable feature of vp-trees that we can leverage in our implementation. In the sctting of Mapper on Ball Mapper, we have a lens f: X + Y and a metric d on Y. Mapper on Ball Mapper is obtained by taking the pullback of the open sets of Ball Mapper under the lens f. This is equivalent to apply Algorithm to the input dataset Y = X
13

---

Published in Transactions on Machine Learning Research (01/2025)
Algorithm 8 Construction of e-net via proximity-nel and vp-trees
Require: Let Y be dataset and d a pscudo-metric on Y. Let >> 0 be a chosen radius.
Ensure: A ball cover C on Y with balls of radius e. T - build uutrree
D
Algorithm A Algorithm Algorithm
π - - range query(T,P.s P) C prozimity-net(XX,
Definition
12
return C
under the pullback pseudo-metric d. This brings practical benefit in terms of time and space, since the pullback cover is already obtained in this way, without constructing explicitly from a cover on f(X).
Cubical Cover via Proximity-Net and Vantage Point Trees. Under an appropriate choice of prox- imity function, can construct a cubical cover using proximity-nel, while keeping the nunber of open limited, in the case of e-net (see Remark 2.3). eliminating the performance degradation encountered in Algorithm 2
Remark 9. As result of Theorem we can claim that
y Booddn (lor' o pn (u))(u), o 2n 2np
is a proximity function.
By leveraging Theorem 2 we can finally summarize our methodology for computing this cover efficiently, which is also reported in Algorithm g the first step we use Algorithm to construct a vp-tree T on using the pseudo-metric dy..... The range query method on (Algorithm 4 is then equivalent to computing the proximity function BPy (o) for any choice of e. Then, once T has been constructed, we run proximity-
net algorithm (Algorithm
by supplying the proximity function BPy (gydoc 2n-2mp) (oy opn oσy) which
by definition is equivalent to
Bagda (ozz pm oor)()), 2
and therefore can be efficiently computed
y + range quere_query T, (o Pr o (00) 2n 2mp
using the vp-troe T. As stated by Thcorem 2 this is equivalent computing CPy p).
Algorithm 9 Construction of cubical cover via proximity-net and vp-trees
Require: Let Y C R let < n E N and p E 1/2). Ensure: A cubical cover C CCN...
T + build Shhild_uprree{>> oy ordz))
Algorithm
3
π = - range__aunrae (oy' Pnor)(u), 2n-2mp)
Definition 10 Theorem
A Algorithm Algorithm
C prozimilt-nee(())
return C
Since proximity-net is greedy algorithm that selects distinct element of CC at each step, estimating the cardinality of CC also provides upper bound on the total number of iterations of proximity-ned Consoquently, the algorithm produces open cover of Y, where each open set corresponds to one of the hyperrectangles from the original standard cubical cover CCT-". This refined open cover may contain fewer open sets than the original cubical cover, thanks to the application of proximity-net. Despite its smaller size, the cover remains sufficient encompass the entire dataset. Morcover, the Mapper graph derived from this open cover retains its informativeness while being potentially casier to visualize and analyze, particularly in higher dimensions (see Figure 5)
14

---

Published in Transactions on Machine Learning Research (01/2025)
10
100
5.0
-30
110
00
0.0
Figure 5: A visual comparison between the standard cubical cover (left) and the cover from proximity-net (right) on the Digils dataset. (Alpaydin & Kaynak 1998). Node colors represent the average digit values. We ran Mapper using PCA with four principal components as the lens, ten intervals and 50% overlap, and KMeans clustoring with two clusters.
Non-Determinism. Algorithmn does not. prescribe a striet rule for selecting points in its main loop, reflecting the inherent non-determinism e-net construction as defined in Algorithm ! This flexibility mcans that the resulting Mapper graph may vary depending the specific choice of points.
On one hand, it's possible to reduce this variability by picking, al each step, the point p that maximizes the distance d(p, Y S). While this approach increases computational cost, it can improve consistency and reproducibility.
On the other hand, when the good cover condition met, the impact of non-determinism on the Mapper graph is not topologically relevant, since as discussed more deeply in m.1 the topological information encoded in the Mapper graph does not depend the specific open cover. If this condition is not met, the Mapper graph may no longer reflect the topological features of X, and using Mapper in such cases is questionable since the Nerve Theorem does not apply.
Moreover, when the open cover derived from proximity-net is a subcover of a good cover, it inherently satisfies the good cover condition. For instance, the case a standard cubical cover nover-constructed de- terministically-itt the good cover condition satisfied for the standard cubical cover, then the standard Mapper graph is topologically mcaningful, and the Mapper graph obtained via proximity-nct also preserves the same topological features. Under these conditions, the choice of points in Algorithm 7 does not affect the topological features of the Mapper graph.
Computational Complexity. The computational complexity of Algorithm can be estimated we know the cardinality of the open cover produced via the e-net proximity- and the complexity of the proximity function. This estimation is particularly relevant for two cases: the ball proximity function BPy (d, e) and the cubical cover proximity function Cn,(n,,)) p). In both cases, range queries are performed using vp-trees, corresponding to Algorithm for the ball cover and Algorithm g for the cubical cover.
For Algorithm & the main loop iterations correspond to the size of the ball cover, which is ((RRrr)dlm(()) as stated in Proposition However, the time complexity of range queries, that we denote by y is challenging to estimate, also reported by Uhlmann (1911). Additionally, constructing the vp-tree
15

---

Published in Transactions on Machine Learning Research (01/2025)
dataset Y has asymptotic time cost of O( log(({()) and takes O( additional space. Combining these factors, we can write:
(#)
dim(Y)
rr) = [8]-log([Y)) + By (
R dim(Y)
Space 0
|
For the cubical cover, and Y S It, we estimate the cardinality of the open cover using Theorem process is analogous, Icading to:
2
The
1 )m)
(2n- 2 - p
dYm(
Time(Y,n,p) = | (oggoo(((11) uy
3h
(2n-
22n-
2n 2np
p
|1|+3** -
dimll))
2 2-P
Space (,,,))
2n
p
3.3 Experimental Results
To evaluate the benefits of the approach outlined in Algorithm and supported by Theorem Band and Corollary 1 we conducted series of programmalic experiments. Initially, developed Python library called compared it against other open-source libraries. The motivation behind creating ida-mapper was to explore alternative methods for constructing open covers for Mapper and eventually implement more efficient approach. While major open-source implementations like Python Mapper 1.0.1.17) (Müllner & Babu 2013). GUDHT (v3. 10.1) (Carrière 2024), giotto-tda (v0.6.0) 0) (Tauzin et al. 2021). and Kepler Mapper 0220..1 (van Veen et al. 2019) 6.0) can in principle support high-dimensional lenses, they all rely on Algorithm 2 which has known limitations, as previously discussed. The root cause of this issue lies in their source code: a common thread among these libraries is the use of the itertools. product function. This function, described in Python's official www.hhttteetttooooooooooottttttt product, htt.:oollll....l....mmm..mm..mm.
tda-mapper Simi 2024) based on the approach presented in this work. Subsequently,
produuctss.poduct documentation available at hhttpa: : //docs. python.org/3/11 http:///lbbarryiiee is used to perform a nested loop on each one me--imensional open cover, which corresponds to what Algorithm does.
In this section, we report the results obtained from comparing giollo-lda (v0.6.2) 6.2) (Tauzin et al. 2021 Kepler Mapper 1.0) (van Veen et al. 2019) and tila-mapper (v0.9.0) (Simi 2024), focusing on both running time performance and the complexity of the generated graphs. These results align with the expected behavior and demonstrate the clear superiority of our approach, which achieves better scalability with respect to lens dimension while producing less complex graphs. To evaluate the performance and scalability of our approach, we conducted a series of measurements on the running time required to compute Mapper graphs. During these benchmarks, we consistently kept a fixed number of intervals and overlap, while systematically varying the lens dimension. This comparative analysis provides valuable insights into the behavior these implementations when dealing with high-dimensional data. Our experiments were conducted on Debian using Python 3.11, using a PC equipped with a Ryzen 5700G CPU with 2x16GB DDR34 2133Mhz, in dual channel configuration. To ensure the reliability of our benchmarks,
used well-known datasets publicly available at the UCI Machine Learning Repository (Dua & Graffi 2023): (a) the Digits dataset (Alpaydin) & Kaynak 1998), with 1797 instances and 64 fcatures; (b) the MNIST datasct (LeCun et al. 1998). with 70000 instances and 784 fratures; (c) the Cifar-10 dataset (Krizhevsky et al. 2009), with 60000 instances and 1024 features; and (d) the Fashion- dataset (Xiao et al. 2017) with 70000 instances and 784 features. For each dataset we ran Mapper using overlap fraction p ranging in the set (0.125, 0.25, 0.5) and using n 10 as the number of intervals on each feature. This choice is arbitrary, but was enough to get informative Mapper graphs, especially with low-dimensional lenses, with every dataset used.
16

---

Published in Transactions on Machine Learning Research (01/2025)
As final note, it is important to emphasize that our experiments were largely constrained by memory limi- tations. Many instances could not be executed for values of k >> 5 due to out-of-memory errors encountered while benchmarking giotto-tda and kepler-mapper Consequently, direct comparisons are limited to k S 5. Nonethcless, the asymptotic behavior of tda-mapper has been analyzed for higher values of k; up to A = 10. These benchmarks highlight the good scalability properties of our approach in this extended range.
Choosing the open cover. In the following plots we report the running times of tda-mapper on the cubical cover via proximity-net
(Allgoori (Algorithm 7 and on the ball cover via e-net (Algorithm
It's important to point out that these two open covers don't align and need different input parameters, so comparing the two approaches requires a little care. For this reason the ball cover has been constructed by supplying the inputs that better match those of cubical cover, i.e. as the metric we chose the scaled disttana, and as the radius we chose 1/(2n - 2mp) (sce Proposition 2).
As we will see in the plots there is often no clear winner in terms of performance between cubical cover and ball cover, except for a single case where the ball cover scales better with dimension than the cubical cover.
Choosing the clustering algorithm. The choice of clustering algorithm plays a crucial role in the complexity of the Mapper graph. Different clustering approaches may result in varying numbers of nodes and edges, impacting both the interpretability of the graph and its computational cost. For example, clustering algorithms that require the number of clusters k as an input parameter (such as KMeans (MacQueen) 1967) would produce a Mapper graph with k nodes, where is the number of open sets constructed on the image of the lens. Certain clustering algorithms are particularly well-suited to specific lenses. For instance, when using density as the lens, DBSCAN (Eater et al. 1996) might be a good choice. This is because the open sets in the pullback cover will often correspond to regions of approximately uniform density, aligning well with DBSCAN's focus on density.
However, in the context of constructing Mapper graphs using figh-dimensional lenses (one of the key aspects of our method) the reliance on clustering diminishes. High-dimensional lenses often yield open sets that can naturally distinguish clusters without requiring additional clustering (see the discussion in 2. about the Nerve Theorem). This principle can also be observed in Dlotko (2019), where the open cover is directly constructed on the dataset rather than in the lens image, eliminating the need for clustering altogether. Similarly, in our approach, the higher-dimensien to classical Mapper, where lenses are typically low-dimensional (e.g., 2D projections).
lens spaces reduce the dependency on clustering compared
Given these considerations, and because our experiments focus on the asymptotic behavior when the lens dimension is high, we chose trivial clustering strategy. Specifically, we opted for clustering algorithm that assigns all data points to a single cluster. This minimizes the influence of clustering on our benchmarks and isolates the effects of our approach for building open covers in our analysis.
Scaling with the Embedding Dimension. The first experiment involves creating a 1-dimensional dataset embedded in dimension k, referred to as the Line dataset in the plots. This is a toy experiment where the dataset consists of 10000 points lying on the diagonal of the hypercube [o, 1],, with a small random noise. As expected, compared with kepler-mapper and giolto-lda, the running time of Ida-mapper on this datasct demonstrates the advantage of our approach espccially in higher dimensions (sce Figure 6
Scaling with the Intrinsic Dimension. We conducted additional experiments to better reflect typical use cases when employing Mapper libraries (see Figure Principal Component Analysis (PCA) as the lens, varying the mumber of components from 1 to 10. As the number of PCA components k increases, the discrepancy with the doubling dimension of the image is also expected to grow. This range was sufficient to highlight significant performance advantage of tda-mapper in all experiments for A 2 4. In contrast, both kepler-mapper and giollo-lda encountered frequent out-of- memory issues, and their results are shown only for experiments that successfully ran. Memory consumption poscs a major challenge to algorithm scalability, and notably, tda-mapper completed all experiments without any out-of-memory errors, consistently using far less memory. The plots depict running times on a linear scale for the main axes, supplemented by logarithmic scale in the inset plots. Interestingly, k increases,
10). To streamline the process, we used
17

---

Published in Transactions on Machine Learning Research (01/2025)
Line
p = 0.125
= 0.25
p = 0.5
250
150
150
200
time (s)
time (s)
time (s)
100
100
150
100
50
50
50
P
0
0
1
3
8
9
10
1
6 8
10
2
4
6
910
k
k
giotto-tda
Ida-mapper (ball cover)
kepler-mapper
tda-mapper (cubical cover)
Figure 6: Comparison of rumning times on the Line dataset in dimension k.
tda-mapper exhibits sub-exponential growth in running time. Extending these experiments to larger lo values would be worthwhile to determine whether running times stabilize (as observed in the Digits dataset) or continue to grow.
3.3.1 Visualization
To highlight the visual improvements achieved with proximity-nes we present comparisons of Mapper graphs generated from our benchmark datasets in Figures II 13 15 and 17 The Mapper algorithm was configured using PCA with four principal components as the lens, a cubical cover with five intervals and 50% overlap, and KMeans clustering with two clusters was applied to the pullback of each open set. Nodes are colored basod on their labeled classes. As expected, the Mapper graphs generated by giotto-tda and kepler-mapper are less intuitive to navigate compared those produced by Ida-mapper. However, the simpler graphs from tda-mapper effectively capture relationships among the different color-coded classes, offering clearer insights compared to the other libraries.
Additionally, we compare the reported graphs across five distinct metrics in all experiments: densily, Iran- sitivity, degree, clustering coefficients, and betweenness centrality. Detailed comparisons the node-level metrics (degree, clustering coefficients, and betweenness centrality) are presented in Figures 12
14 16 and 18 as histograms, showing their distributions across all nodes. Tables g and provide aggregated values for these distributions, reported as means and standard deviations (sud), along with the graph-level metrics density and transitivity. Notably, transitivity and clustering coefficients exhibit similar patterns across the three libraries tested. This suggests that all librarics maintain similar levels of local clustering, preserving the tendency for nodes within a neighborhood to form tightly-knit clusters. However, we observe several differences in other metrics. Compared to giotto-lda and kepler-mapper, Ida-mapper exhibits lower average degrees, yet maintains the same clustering coefficients and transitivity. Despite having fewer connections overall, the graphs generated by tda-mapper preserve similar levels local cohesiveness, suggesting a focus on more concentrated, direct connections within clusters. A key distinction arises betweenness centrality, where tdo-mapper consistently demonstrates higher values. This indicates that certain nodes play more pivotal role in bridging different parts of the graph, pointing to more centralized or hierarchical structure. These nodes are crucial for comnecting otherwise isolated clusters. Furthermore, the higher density observed in tda-mapper suggests that its graphs are more compact, with fewer nodes but denser interconnections, potentially offering a clearer and more streamlined representation of the key relationships between clusters.
18

---

Published in Transactions on Machine Learning Research (01/2025)
Digits (PCA)
= 0.125
= 0.25
= 0.5
30
30
200
time (s)
20
time (s)
20
time (s)
10
10
100
1
3
4
6
7
9
10
1
3
4
6
7
8
10
2
3
5
6
8
9
10
k
k
k
giotto-tda
tda-mapper (ball cover)
kepler-mapper
uda-mapper (cubical cover)
Figure 7: Comparison of running times on the PCA with components on the Digils dataset.
MNIST (PCA)
p
0.125
p
0.25
p 0.5
1500
10000
1500
8000
1000
time (s)
time (s)
1000
time (s)
6000
4000
500
500
2000
0
0
0
0
0
3
6
7
8
910
4
7
8
90
4
5
8
910
k
k
k
giotto-tda
tda-mapper (ball cover)
kepler-mapper
ida-mapper (cubical cover)
Figure 8: Comparison of running times on the PCA with is components on the MNIST dataset.
19

---

Published in Transactions on Machine Learning Research (01/2025)
Cifar-10 (PCA)
p = 0.125
= 0.25
= 0.5
6000
1250
1250
1000
1000
4000
time (s)
750
time (s)
time (s)
750
500
500
2000
250
250
2
3
4
5
7
8
910
1
2
4
6 7
910
1
2
3
4
6 7
8 910
k
k
k
giotto-tda
tda-mapper (ball cover)
kepler-mapper
tda-mapper (cubical cover)
Figure 9: Comparison of running times on the PCA with k components on the Cifar- 10 dataset.
Fashion-MNIST (PCA)
p
0.125
p 0.25
p 0.5
foo000
1500
1500
4000
time (s)
time (s)
time (s)
1000
1000
2000
500
500
0
0
2
5
7
8
10
2
4
7
910
1
4
6 7 910
k
k
k
giotto-tda
tda-mapper (ball cover)
kepler-mapper
tda-mapper (cubical cover)
Figure 10: Comparison of running times the PCA with i components the MNShion-MNIST dataset.
20

---

Published in Transactions on Machine Learning Research (01/2025)
(a) giollo-tda
(b) kepler-mapper
(c)
ida-mapper
Figure 11: Comparison of Mapper graphs for Digits.
0.6
goota Ae
go
399
200
1.0
69
200
130
242
00
6.2
6-4
3.9
1.0
0.0
652
0,24
0.0
8.30
(a) Degree
(b) Clustering Coefficient
(c) Betweenness Centrality
Figure 12: Comparison of metrics for Digits.
Table 1: Summary metrics for Digits.
Metric
giotto-tda
kepler-mapper
tda-mapper
Density
0.04
0.05
0.12
Transitivity
0.40
0.40
0.41
Degree (std)
46.27 (27.51)
46.82 (29.64)
11.80 (5.77)
Clustering (std)
0.58 (0.22)
0.61 (0.24)
0.46 (0.16)
Betweenness (std)
0.002 (0.003)
0.002 (0.004)
0.016 (0.019)
21

---

Published in Transactions on Machine Learning Research (01/2025)
(a) giollo-tda
(b) kepler-mapper
(c) ida-mapper
Figure 13: Comparison of Mapper graphs for MNIST.
gorta Me
clnta lde
go
0.03
26
180
120
200
63
24
055
C66
872
06
0.
100
006
6.1
8:32
0.00
0.44
8.35
(a) Degree
(b) Clustering Coefficient
(c) Betweenness Centrality
Figure 14: Comparison of metrics for MNIST.
Table 2: Summary metries for MNIST.
Metric
giotto-tda
kepler-mapper
tda-mapper
Density
0.06
0.06
0.16
Transitivity
0.40
0.40
0.44
Degree (std)
66.78
(36.50)
63.58 (37.62)
21.15 (8.29)
Clustering (std)
0.53 (0.19)
0.56 (0.21)
0.47 (0.12)
Betweenness (std)
0.002 (0.002)
0.002 (0.003)
0.01 (0.01)
22

---

Published in Transactions on Machine Learning Research (01/2025)
(a) giollo-tda
(b) kepler-mapper
(c) ida-mapper
Figure 15: Comparison of Mapper graphs for Cifar- 10.
0.07
gorta Me
cinta lde
poto--ta
0023
0073
200
100
200
123
340
83
2.4
3-5
32
2.0
0.9
1.0
1300
0.05
0003
8.113
6:200
0005
2008
000
(a) Degree
(b) Clustering Coefficient
(c) Betweenness Centrality
Figure 16: Comparison of metrics for Cifar-10. 10.
Table Summary metries for Cifar- 10.
Metric
giotto-tda
kepler-mapper
tda-mapper
Density
0.05
0.05
0.18
Transitivity
0.40
0.40
0.45
Degree (std)
62.25 (31.23)
57.54 (31.73)
26.08 (12.43)
Clustering (std)
0.53 (0.19)
0.56 (0.21)
0.50 (0.11)
Betweenness (std)
0.002 (0.002)
0.002 (0.003)
0.008 (0.008)
23

---

Published in Transactions on Machine Learning Research (01/2025)
(a) giollo-tda
(b) kepler-mapper
(c) ida-mapper
Figure 17: Comparison of Mapper graphs for Fashion-MMi MNIST.
200
16-
23
200
320
140
180
00
6.2
3.
100
0.0
0.2
0C04
C.55
8:30
150
(a) Degree
(b) Clustering Coefficient
(c) Betweenness Centrality
Figure 18: Comparison of metrics for Fashion-MNISTT
Table 4: Summary metries for MNSSI
Metric
giotto-tda
kepler-mapper
tda-mapper
Density
0.05
0.05
0.13
Transitivity
0.40
0).0
0.43
Degree (std)
48.09 (30.15)
48.46 (30.36)
13.58 (7.06)
Clustering (std)
0.59 (0.23)
0.61 (0.23)
0.52 (0.17)
Betweenness (std)
0.002 (0.003)
0.002 (0.004)
0.015 (0.021)
24

---

Published in Transactions on Machine Learning Research (01/2025)
Acknowledgements
This work is dedicated to the memory of my father, whose support and encouragement have been a constant source of strength throughout my life. wish lo express my deep gratit to Sofia Torchia for her insightful comments and genuine interest in this work, which have been invaluable. also extend sincere thanks the anonymous reviewers for their constructive feedback and suggestions, which have greatly improved this paper, and to the action editor for their commilment to the review process.
This research was conducted independently and did not receive any external funding or institutional support. The findings presented here are not associated with the author's professional duties or affiliations.
References
Ethem Alpaydin and Cenk Kaynak. Optical Recognition of Handwritten Digits. UCI Machine Learning Repository, 1998. DOI: https://doi.orrg// /tt////ii..o/0.2444333//3 C90049..
Patrice Assouad. Plongements lipschitziens dans <², Bulletin de la Sociélé Mathématique de France, 111:429-
448, 1983. doi: 10.24003/ 10.24033/bsmf..199 btmp/f URL http: http::/wwww.nmmddee www.maaam..rg.aoaeaeemmmmm wttg//aticeess11.222/00 24t////00..433//// 1997/
Karol Borsuk. On the imbedding of systems of compacta in simplicial complexes. Fundamenta Mathematicae, 35(1):217 234, 1948. URL http:://uddll.orr/ddd///ttt
Sergey Brin. Near neighbor search large metric spaces. In Proceedings of the 21th International Conference on Very Large Dala Bases, VLDB '95, pp. 574 584, San Francisco, CA, USA, 1995. Morgan Kaufmann Publishers Inc. ISBN 1558603794.
Gunnar Carlsson. Topology and data. Bulletin of The American Mathemalical Society BULL AMER MATH SOC, 46:255 308, 2009. doi: 10.1000/50273-0099--9-0000 099-099999999---------
Gunnar Carlsson. Topological pattern recognition for point cloud data. Acta Numerica, doi: 10.1017/5096224991 40000000
05 2014.
Mathicu Carrière. Cover complex. In GUDHI User and Reference Manual. GUDHI Editorial Board, 3.10.1 edition, 2024. URL ltttps://gudht:: www.ia.ffddo/......... 1ww.:lgggroop... coverrrpp_ccor__.... cover_ _over___ooppplllle_ee cwwplex.cc...o........ html
Mathieu Carrière, Bertrand Michel, and Steve Oudot. Statistical analysis and parameter selection for mapper. Journal of Machine Learning Research, 19(12):1-39, 2018. URL
html
Kenneth L. Clarkson. Nearest-ncighbor scarching and metric space dimensions. In Nearest- Methods in Learning and Vision: Theory and Praclice. The MIT Press, 03 2006. ISBN 9780262256957. doi: 10.7551 httppprrs//90000003..
URL httpp:::/aii.orrg///// htt.:////000.../..mmmpp////00/00
Dheeru Dua and Casey Graff. Uci machine learning repository, 2023.
Pawel Dlotko. Ball mapper: a shape summary for topological data analysis, 2019. URL https://arxiv.
org/ abs/ 1111119011.11110
Martin Ester, Hans-PPted Kriegel, Jörg Sander, and Xiaowei Xu. A density-based algorithm for discovering clusters in large spatial databases with noise. In Proceedings of the Second International Conference on Knowledge Discovery and Data Mining, KDD'96, pp. 226 231. AAAI Press, 1996.
Jerome H. Friedman, Jon Louis Bentley, and Raphael Ari Finkel. An algorithm for finding best matches in logarithmic expected time. ACM Trans. Math. Softw 3(3):209 209 226, sep 1977. ISSN 0098-3500. doi: 10.1145/355744.35577 URL https::/doii.orr org. 11/110111440 4444///55544.377444
Caleb Geniesse, Samir Chowdhury, and Manish Saggar. Neumapper: scalable computational framework for multiscale exploration of the brain's dynamical organization. Network Neuroscience, 6(2) 06 2022. ISSN 2472-1751. doi: 10.1162/netn 00229. URL https://dooiorrg// 11t.:/0...1112ee...... aatpeett_____a_gggg____ 00229
25

---

Published in Transactions on Machine Learning Research (01/2025)
Teofilo F. Gonzalez. Clustering to minimize the maximum intercluster distance. Thcoretical Computer Science, 38:293-308 336, 1985. ISSN 0304-3975. doi:
URL
pp. http://wwwwaaaaaacoc.ccccccoott/
Anupam Gupta, Robert Krauthgamer, and James R. Lee. Bounded geometries, fractals, and low-distortion embeddings. In 44th Annual IEEE Symposium on Foundations of Computer Science, 2003. Proceedings. 2003. doi: 10.1109/SFCS 2003.
Antonin Guttman. R-trees: a dynamic index structure for spatial searching. SIGMOD Rec. 14(2):47 57, June 1984. ISSN 0163-5808. doi: 011145/97119766022000 URL https://doi. https///ddooor/11//// 10. 1145/971697
602266
Aric A. Hagberg, Daniel A. Schult, and Pieter J. Swart. Exploring network structure, dynamics, and function using networkx. In Gaäl Varoquaux, Travis Vaught, and Jarrod Millman (ods.), Proceedings of the 7th Pylhon in Science Conference, pp. 11 15, Pasadena, CA USA, 2008
Charles R. Harris, K. Jarrod Millman, Stéfan J. van der Walt, Ralf Gommers, Pauli Virtanen, David Cournapeau, Eric Wieser, Julian Taylor, Sebastian Berg, Nathaniel J. Smith, Robert Kern, Matti Pi- cus, Stephan Hoyer, Marten H. van Kerkwijk, Matthew Brett, Allan Haldanc, Jaime Fernándoz del Río, Mark Wiebe, Pearu Peterson, Pierre Gérard-Marchant, Kevin Sheppard, Tyler Reddy, Warren Weckesser, Hameer Abbasi, Christoph Gohlke, and Travis E. Oliphant. Array programming with NumPy. Nature, 585(7825)3337 362, September 2020. doi: (0.108//411556-00022660 2649-2.. URL https:
7/doi //doi..rg//ii org/ro.////./..... 2100100000000//1158800-020-2-200
John D. Hunter. Matplotlib: A 2d graphics environment. Computing in Science & Engineering, 9(3):90 95, 2007. doi: 10.1109 10.1109/MCSBB.. MC55.2007..
Robert Krauthgamer and James R. Lee. Navigating nets: simple algorithms for proximity search. In Pro- ceedings of the Fifteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA '04, pp. 798-807, USA, 2004. Society for Industrial and Applied Mathematics. ISBN 089871558X.
Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images, 2009.
Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to docu- ment recognition. In Proceedings of the IEEE, volume 86, pp. 2278-2324, 1998. doi: 10. 10.1109/5.726791 URL http::/yann. lecun.eelnnmm brecun.com/exdil
James B. MacQueen. Some methods for classification and analysis of multivariate observations. In Proceed- ings of the fifth Berkeley symposium on mathematical statistics and probabilily, volune pp. 281 297. Oakland, CA, USA, 1967.
Daniel Müllner and Aravindakshan Babu. Python mapper: An open-source toolchain for data exploration, analysis, and visualization, 2013. URL http::/danifolld net.:/ddeeemmmpp....
Davide Gurnari Pawel Dlotko and Radmila Sazdanovic. Mapper type algorithms for complex data and rela- tions. Journal of Computational and Graphical Statistics, 33(4):1383-14) 1396, 2024. doi: 10.1080/ (0800006166000 2024.2343321. URL :tttp:://bii.orr/11..1eee 100/100.1000/00118000 2024. 2343321
Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathicu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, Jake Vanderplas, Alexandre Passos, David Cournapeau, Matthieu Brucher, Matthieu Perrot, and Edouard Duchesnay. Scikit-learn: Machine learning in python. Journal of Machine Learning Research, 12(85):2825 2830, 2011. URL httpp://jmrr; htg/ppppers//t22/peeeggaaa html html
Plotly Technologies Inc. Collaborative data science, 2015. URL https://plot.11
Luca Simi. tda-mapper, December 2024. URL http:://bbi.rr///05558/// 14270565
26

---

Published in Transactions on Machine Learning Research (01/2025)
Gurject Singh, Facundo Memoli, and Gunnar Carlsson. Topological Methods for the Analysis of High Dimensional Data Sets and 3D Object Recognition. In M. Botsch, R. Pajarola, B. Chen, and M. Zwicker (eds.), Eurographics Symposium on Point- Based Graphics. The Eurographies Association, 2007. ISBN 978-3-905673-51-7. doi: /
Martin Skrodzki. The k-d tree data structure and proof for neighborhood computation in expected logarithmic time, 2019. URL htttp::/aaaxxv..og//ab//////////
04936
Guillaume Tauzin, Umberto Lupo, Lewis Tunstall, Julian Burella PÅOrez, Matteo Caorsi, Anibal M. Medina- Mardones, Alberto Dassatti, and Kathryn Hess. giotto-ida: : A topological data analysis toolkit for machine learning and data exploration. Journal of Machine Learning Research, 22(39):1-6, 2021. URL html.
Jeffrey K. Uhlmann. Satisfying general proximity / similarity queries with metric trees. Information Process- ing Letters, 40(4):175- 179, 1991. ISSN 0020-0190. doi: URL htttperr/rrn.eiiieeeddrreet. http:///wwa..caeeooocc/.c.o.oaaa
Hendrik Jacob van Veen, Nathaniel Saul, David Eargle, and Sam W. Mangham. Kepler mapper: A flexible python implementation of the mapper algorithm. Journal of Open Source Software, 4(42):1315, 2019. doi:
10.21105/joss.0133 01315. URL bttps:///ois org/oog//// 21.1......1111 20s.111///.s..1111
André Weil. Sur les théorèmes de de rham. Commentarii mathematici Helvetici, 26:119-145, 1952. URL
htt////oc1139944/
Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017. URL
Peter N. Yianilos. Data structures and algorithms for nearest neighbor search in general metric spaces. In Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms,, SODA '93, pp. 311 321, USA, 1993. Society for Industrial and Applied Mathematics. ISBN 0898713137.
A Appendix: Library Overview
Throughout the development process of tda-mapper, one of the objectives was to create API that is easy to understand and use. For this reason adopted an object-oriented approach taking inspiration from the well-known scikit-learn APIs (Pedregosa et al. 2011), ; since we expect some good level of familiarity with it from the intended user base of tda-mapper. Additionally, we made efforts to keep the API of tda-mapper similar to the APIs provided by giotlo-Ida and Kepler Mapper, allowing users to smoothly transition wet these librarics and leverage their existing knowledge. By considcring these factors, we aim to provide user- friendly and seamless experience for users of Ida-mapper, making easier for them to explore and use the library's full potential.
We have implemented our own version of the vp-tree data structure and optimized it for our specific use-case: our implementation allows each leaf of the vp-tree to contain multiple items by stopping the construction when the splitting circle is small, either terms of its cardinality or in terms of its radius (smaller than a given threshold). This optimization beneficial both for range queries and for K-ncarest neighbor (KNN) queries. When, during a search, the visited node becomes smaller than the query, the search operation collapses into faster brute force linear scan.
The implementation of Ida-mapper relies on several dependencies, including networkx (Hagberg et al. 2008
numpy (Harrss et al. 2020), matplotlib (Hunter) 2007], and plotly (Plotly Technologies Inc 2015). Overall, the soft dependencies in tda-mapper are crucial for its functionality and enable users to generate Mapper graphs and visualize them effectively:
networkx is used to generate and manipulate the Mapper graph, which is the primary result of the algorithm.
27

---

Published in Transactions on Machine Learning Research (01/2025)
numpy is necessary for numeric computations, particularly for the CubicalCover function.
matplotlib and plotly are used to create plots for the Mapper graph, providing visualization options.
Additionally, there is weaker dependency sklearn Pedregosa al. 2011 which is used only for testing, ensuring that the implementation aligns with widely-used machine learning standards. The sklearn library is used to check that the custom-defined estimators in Ida-mapper are compatible with sklearn. An extensive amount of effort was devoted to ensure a good level automation during development, especially for testing, which performed using GitHub actions. At the time of writing code coverage is around 96%.
For more in depth information, examples, tutorials, and documentation, the interested reader can visit https::/ttaa-mapeer readthedocs io/en/main/////////
28


Reviews:
[{"review_id": "YVXddjbLjK", "reviewer": "Reviewer_WJji", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "## Strengths\n+ The paper is easy to follow considering the complexity of the proposed topic. The reader is taken by the hand by the main procedure being split up in small algorithms.\n+ The results show that this algorithm is indeed faster then baseline approaches in higher dimensions, making it important for people working in this area\n+ Even though I have not checked the proofs of the theorems in detail, the paper seems sound to me. The argumentation and the mathematical constructions and the belonging theorems are looking sound and reasonable.\n\n## Weaknesses\n- The paper would benefit from a more depth analysis on how the final mapper graphs look like. Are there outstanding characteristics with respect to the mapper-graph produced with proximity-net compared the standard cover?  So, my request would be to not only have the one visualized example in Figure 5, but a rigorous analysis on how the produced graphs behave.\n- I would have been curious to look at the code already to understand how these algorithms are implemented. In 2024, there are various possibilities to share code anonymously....", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "In this paper, the authors propose a more efficient way to compute an open cover\nfor the mapper algorithm. Their procedure works by constructing a vp-tree to\nallow for efficient neighborhood querries and running their proximiy-net\nalgorithm afterwards. They afterwards empirically evaluate to which extent this\nalgorithm is indeed faster then other implementations.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "## Major\nSee my first critique point\n## Minor by descending Priority\n- Definition 10: This needs to be rewritten, CP_Y...is a set, so this notation with the iff statement is not useful. I think I understand it, nevertheless I would strongly recommend to use a proper set notation for CP_Y...\n- There are two statements about the equivalence of Ball Behavior to the boundless of d(p,q) \"hidden\" inside the descriptions of figure 4a) and 4b) which are used in Algorithm 4. Even if they may be trivial for the authors, they are used in algorithm 4 and I would explicitly state them before Algorithm 4.\n- Algorithm 7: Does it make sense to speak of an \"open cover\" of Y? For arbitrary proximity functions and arbitrary sets Y, the concept of \"openness\" is not clear to me. Does maybe \"Ensure Cover Y$ may be more accurate here?\n- What is dim(Y) in the case of Y not being a subspace of an euclidean space?", "broader_impact_concerns": "NA", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "3B9zB2WKf8", "reviewer": "Reviewer_qUwr", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "**Strengths**\n  * Very detailed and clear introduction to all relevant concepts and methods\n  * Practical and useful contribution to the community\n  * Method is released as a Python package\n\n**Weaknesses**\\\nWhile I think the main part of the paper is technically sound and easy to follow, the empirical evaluation could be expanded. Currently, the benefits of the proposed method are only visible in 5 dimensions ($k=1$ in Fig. 6 - 10). Furthermore, only 1 qualitative example (Fig. 5) regarding the quality of resulting Mapper Graphs does not seem sufficient to establish the performance of the proposed method.\n\nA second weakness that stands out is the non-determinism of Algorithm 7 (\"Take a point $p \\in S$\"). How does this affect the resulting Mapper graph? Are the graphs very different for different random seeds?", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper presents an efficient method to compute cubical covers for Mapper graphs. First, the paper identifies a combinatorial problem in existing methods to compute cubical covers for Mapper graphs, which leads to long running times and inflated number of nodes in Mapper graphs. Then, the paper introduces a series of optimizations, such as using vp-trees and efficient range queries. Finally, the paper introduces $\\epsilon$-proximity net as an efficient way of obtaining a cubical cover for the given dataset. The proposed method is benchmarked for speed against two existing libraries that allow computing cubical covers, namely `giotto-tda`and `kepler-mapper`, showing improved speed in higher dimensions.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "* Could the Mapper graphs for Fashion-MNIST, MNIST, and CIFAR (or representative subsets of these datasets) be added to the paper? This would help the reader to get a better impression of the advantages of the propsed method in comparison to existing libraries.\n* Could a discussion be added up to which dimension the proposed method is still feasible, or is there really only an advantage with $k$=5 (In Fig. 6 to 10)?\n* Could a comparison of Mapper Graphs with different random seeds be shown, to assess the impact of non-determinism in Algorithm 7?\n\nIn summary, I think the paper is already very clear and makes an interesting contribution, but especially the non-determinism of Algorithm 7 should be addressed, as it could have important implications regarding the validity of resulting graphs.\n\n**Typos**\n  * Page 1: \"A well-knonw\"\n  * Page 1: \"Singh et al. Singh et al. (2007).\": Double citation?\n  * Page 2: \"These crucial points has been\" -> \"have been\"", "broader_impact_concerns": "No concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "D1zi0VnMm5", "reviewer": "Reviewer_AQbC", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths:\n(1)The paper presents theoretical guarantees, including bounds on the cardinality of covers, ensuring the scalability of the approach. A strong mathematical foundation ties the new method to established results in computational geometry and TDA. I think this will give the audience more confidence even without complexity analysis. \n\n(2) Experimental results on diverse datasets highlight the practicality and efficiency of the proposed approach.\n\nWeakness:\n(1) Although the method performs better than PCA, the practical upper limits of the approach for high-dimensional datasets (e.g., >1,000 features) are not thoroughly analyzed or discussed. In practice, t-SNE and UMAP are more widely used and showed successful results, even on some of the datasets chosen by the authors (e.g., CIFAR-10), but not compared against with. I think comparison with modern dimension reduction method will enhannce the paper quite a bit and attract audience's interest. \n\n(2) The clustering step is briefly mentioned (i.e., \"To minimize the effect of clustering on the benchmarks, we chose a trivial clustering algorithm that for each input dataset creates a single cluster.\"), but its role in graph complexity and interpretability could be explored in more detail. For instance, how sensitive is the method to different clustering algorithms?", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper introduces a  approximate but scalable approach for constructing open covers in the Mapper algorithm, a key tool in Topological Data Analysis (TDA). The contributions of the paper are outlined below:\n(1)) The paper introduces proximity-net, a generalization of the \\epsilon-net algorithm, to construct open covers more efficiently. \n(2) The approach uses vantage-point trees (vp-trees), a specialized data structure, to efficiently handle range queries and reduce the computational complexity of building open covers, especially for high-dimensional datasets.\n(3) The authors provide theoretical upper bounds on the cardinality of the constructed covers, showing that the number of open sets depends on the dataset's intrinsic dimensionality and the resolution parameters, rather than growing exponentially with the feature space dimensionality. Therefore, this serves as a complexity analysis, along with the scaling experiments.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "(1) The construction proximity-net is quite similar to the chaining technique in probability (c.f., the classic Ledoux & Talagrand. Probability in Banach Spaces: isoperimetry and processes, 2013.) where the covering is defined by semi-metrics induced by covariance operators. \nThe authors are applying this to reduce the cardinality of covering sets, which is natural from a algorithmic standpoint. The idea of counting the cardinality of covering balls to approximate actual dimensionality of the targeted manifold has also been developed from an asymptotic angle within the TDA community, to name a few: \nAdler, Robert J., Omer Bobrowski, and Shmuel Weinberger. \"Crackle: The homology of noise.\", 2014.\nLuo, Hengrui, Steven N. MacEachern, and Mario Peruggia. \"Asymptotics of lower dimensional zero-density regions.\", 2023.\nIt would be helpful to see how this line of work in asymptotics can be connected to the motivation of this scalable method. \n\n(2) Since the author introduced a new concept of dimensionality called doubling dimension, it would be helpful to see how this new concept conincide with traditional concept of dimensionality (e.g., in a Hilbert vector space, does this doubling dimension coincide with the usual dimension?), to establish an intuition for the reader. If some example spaces are given, could we use this concept to estimate the computational complexity of the proposed algorithm?\n\n(3) According to the literature, I would suggest that the authors to revise the beginning of section 2 to include how previous work used the \\epsilon-net in the context of TDA, and perhaps drop some notions (e.g., Def 3 L_\\infty distance can be assumed to be known or put into appendices) if we assumed that the audience has some prequisites. \nFrom my expertise, I think the novelty of the current paper is to concretely construct VP-tree to obtain an efficient search regime without running into the memory limit brought by the search tree structure, then the authors should put emphasis on this contribution in their writing. \n\n(4) For Algorithms 7 and 8, can the author present a classic big O complexity analysis? Currently, the complexity analysis is briefly discussed only in remarks (e.g., Rem 5)\n\n(5) The writing style is clean but can be more concise, for example on page 17 \"This dual-scale approach...\" explains the choice of plotting, which is not too relevant to the main message. For another example is the remark 8, which should occur once the choice of vp-tree is made. \n\n(6) When the author presented scaling results like Figures 6-8, is there a convenient way to allow the reader to know how much performance loss by adopting a proximity-net instead of the standard \\epsilon-net? If such a comparison is not possible, could we have an explanation or guidance about what is \"lost\" when using the proximity-net instead of the \\epsilon-net?\n\n(7) Continuing (6) and the second point in weakness, while the proposed method demonstrates superior performance compared to PCA,  but not to widely used dimensionality reduction techniques such as t-SNE and UMAP. A comparative analysis with these modern methods would significantly enhance the paper, showcasing its strengths relative to popular alternatives and increasing its appeal to a broader audience.\n\n(8)The clustering step is briefly described, with the authors opting for a trivial algorithm that produces a single cluster per input dataset to minimize its impact on benchmarks. However, the influence of clustering on the resulting Mapper graph’s complexity and interpretability warrants deeper exploration. For instance, investigating the method’s sensitivity to different clustering algorithms could provide valuable insights into its robustness and practical utility.\n\nPoints (2) and (6) are critical; other points, especially (1) and (7) can greatly strengthen the paper.", "broader_impact_concerns": "I would thank the author for contributing to the important research topic of making TDA/mapper algorithms scalable. Its applications on existing machine learning dataset and comparison against the state-of-the-art libraries makes a convincing case for using better implementation of mapper with proximity-net for ML applications. \nThe paper could attract even more audience if it chooses TDA venue like SoCG or DCG.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: All reviewers were generally positive on the submission, and all their concerns have been addressed, with multiple additions that have significantly improved the presentation and the experimental evaluation. All reviewers are unanimous in proposing acceptance for the paper. The only remaining concern is that the implementation has not been checked by any reviewer (as an anonymous link has not been provided). However, this is a minor concern at this point.
Decision: Accept (poster)