Architecture Mapper Overview

• Architecture Mapper is a set of methods that convert latent structures into explicit maps, enabling analysis of connectivity, dependencies, and spatial features.
• It leverages techniques like Mapper and Ball Mapper to capture topological features and parameter sensitivities through adaptive covers and clustering.
• Applications span from topological data analysis and quantum mapping to accelerator scheduling and software visualization, offering actionable insights.

Searching arXiv for relevant papers on “architecture mapper” and related mapper formulations. Architecture mapper, in the surveyed literature, is best understood as a family of methods that externalize latent organization into an explicit map that can be analyzed, optimized, or calibrated. In topological data analysis, Mapper and Ball Mapper convert a point cloud into a graph or simplicial complex that summarizes connectivity, branching, loops, and overlap structure. In systems and hardware research, mappers generate accelerator schedules, quantum placements, or voxelwise magnetic-field maps. In software analysis, they render features and layers as an architectural visualization. This breadth suggests that “architecture” is treated operationally as any structured arrangement—of neighborhoods, dependencies, resources, or fields—that can be made explicit and then manipulated (Dłotko et al., 2021, Kao et al., 2022, Dousti et al., 2015, Morris, 29 Apr 2025, Kobayashi et al., 2013).

1. Formal basis in Mapper-type constructions

The classical foundation is Mapper, introduced as a construction that approximates the Reeb graph of a dataset. Given a point cloud $X$ and a lens function $f:X\rightarrow \mathbb{R}^n$, one chooses a cover $\mathcal{C}$ of $f(X)$, pulls it back to $X$, clusters each pullback set, and builds a graph or simplicial complex by recording nonempty intersections among the resulting clusters. In its graph form, two vertices are connected precisely when the corresponding clusters intersect: $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$ The resulting Mapper graph is a discrete summary of connected structure, and scalar quantities can be visualized on it by averaging over cluster members (Dłotko et al., 2021).

Ball Mapper replaces the lens-driven cover by a metric cover constructed from an $\epsilon$-net. One chooses landmarks $L\subset X$ so that $X\subset \bigcup_{l\in L}B(l,\epsilon)$, then assigns a vertex to each ball and connects two vertices when the corresponding balls jointly cover some points of $X$. This makes the graph a nerve-like summary of the ball cover, directly tied to metric geometry rather than to an externally chosen lens. The contrast between Mapper and Ball Mapper is central: the former emphasizes feature-aware exploration through a chosen filter, whereas the latter emphasizes adaptive coverage in the ambient metric space (Dłotko et al., 2021).

The same formal apparatus appears in statistical analyses of Mapper. A one-dimensional Mapper may be treated as an estimator of the Reeb graph when it is built from a Rips graph at scale $f:X\rightarrow \mathbb{R}^n$0, a cover of interval length $f:X\rightarrow \mathbb{R}^n$1, and overlap ratio $f:X\rightarrow \mathbb{R}^n$2. Under geometric and sampling conditions, its approximation error is controlled by

$f:X\rightarrow \mathbb{R}^n$3

where $f:X\rightarrow \mathbb{R}^n$4 is a modulus of continuity of the filter. This places Mapper within an estimation-theoretic framework rather than a purely heuristic one (Carrière et al., 2017).

2. Parameter sensitivity, stability, and adaptive cover design

A persistent theme in architecture-mapper research is that the output is strongly controlled by parameterization. For Mapper-type algorithms, the lens, cover resolution, overlap, clustering method, and sample all affect the resulting graph. One line of work therefore defines an intrinsic instability measure for Mapper-type algorithms through a Mapper-function distance $f:X\rightarrow \mathbb{R}^n$5, and shows theoretically that instability is driven by boundary mass, sampling fluctuation, empty bins, overlap choices, and the distinctness of clustering optima. A practical consequence is that reliable candidate outputs can be identified as local minima of instability across parameter space (Belchí et al., 2019).

A complementary statistical perspective treats parameter selection as an estimation problem. Under an $f:X\rightarrow \mathbb{R}^n$6-standard sampling model on a smooth compact submanifold, the tuned one-dimensional Mapper is shown to be a minimax-optimal estimator of the Reeb graph up to logarithmic factors. This yields automatic tuning rules for $f:X\rightarrow \mathbb{R}^n$7, $f:X\rightarrow \mathbb{R}^n$8, and $f:X\rightarrow \mathbb{R}^n$9, and confidence regions for topological features such as loops and flares. The same framework extends to inferred filters, including PCA eigenfunctions and density-based filters, with the total error splitting into sampling error and filter-estimation error (Carrière et al., 2017).

Several papers replace uniform covers by adaptive ones. D-Mapper fits a probabilistic model, specifically a Gaussian mixture model on $\mathcal{C}$0, and defines cover intervals by component quantiles,

$\mathcal{C}$1

so that interval width and overlap become density-guided rather than fixed. It also introduces a combined performance metric,

$\mathcal{C}$2

with $\mathcal{C}$3 derived from extended persistence diagrams, thereby coupling clustering quality to topological signal (Tao et al., 2024).

Other variants learn or localize the cover differently. G-Mapper repeatedly applies the Anderson–Darling normality test to current intervals and splits non-Gaussian ones using a Gaussian mixture model, beginning from the entire range of $\mathcal{C}$4 rather than from a prescribed initial cover. Multimapper allows different regions of the same dataset to be represented at different scales and then glues the resulting local Mapper pieces into a single simplicial complex. AdaMapper uses the $\mathcal{C}$5-dimensional persistence diagram to identify loop-critical segments of the filter range and refines the cover there, setting

$\mathcal{C}$6

so that loop-rich regions are sampled more finely than topologically simple ones (Alvarado et al., 2023, Deb et al., 2019, Khourashahi et al., 3 Jun 2026).

3. Relations, symmetries, and multivariate composition

Mapper-type algorithms have also been extended from shape summarization to the explicit representation of internal relations and symmetries. Equivariant Ball Mapper assumes a finite automorphism group $\mathcal{C}$7 of isometries acting on a metric space $\mathcal{C}$8, and constructs the $\mathcal{C}$9-net equivariantly by adding the entire orbit

$f(X)$0

whenever a point $f(X)$1 is selected. Because the group acts by isometries, the action lifts to the Ball Mapper graph itself, making orbit structure and symmetry visible in the resulting graph. This is particularly effective when the data naturally contain mirror or dihedral symmetries, as in knot-invariant vectors or Tic-Tac-Toe endgames (Dłotko et al., 2021).

A second direction concerns multivariate and inter-descriptor mapping. Mapper on Ball Mapper constructs a Ball Mapper cover on the image of a relation $f(X)$2, then pulls each ball back to $f(X)$3, clusters the preimages, and takes the $f(X)$4-dimensional nerve of the resulting cover. This hybrid avoids the $f(X)$5 blow-up of a cubical cover for high-dimensional lens functions and makes it feasible to compare different descriptor spaces of the same dataset. The broader MappingMappers framework goes further by coloring a Ball Mapper graph of one descriptor space according to the image of regions from another descriptor space, thereby visualizing correspondences, splitting, and relative discriminatory power (Dłotko et al., 2021).

The stitching literature studies how multivariate Mapper structure emerges from univariate components. Given two filters $f(X)$6, a composed cover is obtained by intersecting path-connected pullback elements from the two univariate Mapper constructions. Under simple-connectedness assumptions, the stitched result $f(X)$7 equals the standard bivariate Mapper $f(X)$8. The associated algorithmic phases—STITCH, FIX, and COMPLETE—make the construction process explicit, and the paper defines interval-localized gain measures such as Localized Homological Difference,

$f(X)$9

as well as Local Relative Euler Characteristic and two forms of Localized Entropy Difference. These quantities are used to ask which filter contributes additional topological information and where that gain appears (Zhou et al., 2021).

4. Hardware, physical systems, and execution mapping

In hardware and physical systems, architecture mapping departs from topological visualization and becomes a problem of schedule generation, placement, or metrology. The mapped object may be a layer-fusion plan for an accelerator, a module partition for a quantum processor, or a three-dimensional magnetic field inside an MRI bore.

Domain	Mapper	Function
Ultra-low-field MRI	Slug-Mapper	Maps the static field $X$0 voxel by voxel at $X$1 resolution using a repurposed Prusa i3, Raspberry Pi Zero, Arduino Uno, and 3-axis magnetometer
DNN accelerators	DNNFuser	Generates layer-fusion mappings by one-shot inference with a generative pre-trained Transformer and is reported to be $X$2–$X$3 faster than search-based mappers
Fault-tolerant quantum computing	Squash 2	Maps hierarchical quantum modules onto the Requp multi-core reconfigurable quantum processor architecture while sharing physical and logical ancilla qubits

Slug-Mapper is a low-cost, open-source magnetic field scanner for ultra-low-field MRI scanners. It measures the local static field directly rather than performing MRI signal acquisition, producing a $X$4-dimensional mesh of net magnetic strength across the bore. Its purpose is calibration: field homogeneity matters because resonance frequency obeys the Larmor relation

$X$5

and local inhomogeneity $X$6 perturbs magnetization evolution in the Bloch–Torrey equation. The system therefore supports both passive and active shimming, and can also verify whether gradient coils generate the intended field pattern. It is explicitly not an imaging system and does not reconstruct $X$7-space (Morris, 29 Apr 2025).

DNNFuser addresses the inter-layer, or layer-fusion, map-space of DNN accelerators. Rather than performing expensive iterative exploration, it treats mapping as sequence generation and models a distribution $X$8 with a Transformer. The output sequence specifies fusion groups and per-layer mapping parameters such as tiling factors, spatial or temporal partitioning, and execution order, all under hardware feasibility constraints. The result is a one-shot inference-based mapper that seeks search-level mapping quality at substantially lower runtime cost (Kao et al., 2022).

Squash 2 is a hierarchical quantum mapper for large fault-tolerant programs. It targets Requp, a multi-core reconfigurable quantum processor architecture with $X$9 quantum cores connected by a $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$0-D mesh, and exploits both physical ancilla sharing and logical ancilla reuse. The mapping flow starts from hierarchical fault-tolerant quantum assembly, builds a quantum module dependency graph, partitions each module into $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$1 parts, binds those parts to cores, and schedules them under ancilla and routing constraints. The architecture–compiler co-design is explicit: module repetition, reconfiguration overhead, and ancilla scarcity are treated as first-class mapping constraints (Dousti et al., 2015).

5. Visualization of software, images, and embedding spaces

Another strand of architecture mapping is explicitly visual and interpretive. SArF Map visualizes software architecture from feature and layer viewpoints using a city metaphor. It first applies the SArF dependency-based software clustering algorithm, which weights dependencies by a Dedication Score and then applies weighted, directed modularity maximization to identify implicit feature clusters. In the resulting visualization, each feature is a city block, each class is a building, and relevance between features is represented as streets. Within a block, class positions expose software layers through level decomposition and energy-based layout. The technique is designed not to display the explicit package hierarchy, but to reveal the implicit structure that packages may obscure (Kobayashi et al., 2013).

Mapper on images treats a simply connected image domain $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$2 with a continuous scalar function $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$3. The construction covers the range of $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$4 by overlapping intervals, pulls those intervals back to the image, computes connected components in the pixel adjacency graph, and builds the $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$5-nerve of the resulting cover. In this setting Mapper generalizes contour, join, and split trees, but with a weaker assumption: continuity rather than piecewise linear Morse structure. The paper also gives an image-specific implementation based on an even/odd interval split, BFS-based component extraction, efficient overlap testing, and graph simplification by removing valency-$$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$6 nodes (Robles et al., 2017).

Explainable Mapper extends the Mapper paradigm to LLM embedding spaces. Given contextual embeddings from one layer of a model such as BERT, it constructs mapper graphs using the $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$7-norm as lens and DBSCAN for clustering, then introduces a taxonomy of explorable elements—nodes, edges, paths, components, and trajectories. Two classes of LLM-based agents are then used: Explanation Agents generate hypotheses about these graph elements, and Verification Agents test the robustness of those hypotheses under perturbation. By default, five perturbed sentences are generated per input data point, retained only if they remain in the same node neighborhood, and explanation similarity is scored by cosine similarity on MiniLM sentence embeddings. The framework is semi-automatic rather than fully automatic, and its stated purpose is to support exploration, explanation, and verification of linguistic properties encoded across model layers (Yan et al., 24 Jul 2025).

6. Inverse design, interpretation, and recurring limitations

A common misconception is that an architecture mapper merely discovers structure already fixed by the data. The inverse-Mapper literature shows that this is not generally true. In the trivial-clustering setting

$$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$8

and if a graph $$\text{edge between } v(A)\text{ and }v(B) \iff A\cap B\neq\emptyset.$$9 has edge set $\epsilon$0 and isolated vertex set $\epsilon$1, then under the size condition

$\epsilon$2

there exist a cover $\epsilon$3 and a function $\epsilon$4 such that $\epsilon$5. A corresponding Euclidean construction realizes any graph as the nerve of a finite convex family in $\epsilon$6. This establishes that Mapper is highly controllable: the output graph is shaped by the data together with the selected lens, cover, and clustering procedure, not by the data alone (Alvarado et al., 2024).

This designability has several implications. First, interpretation requires parameter awareness. Instability analyses, density-guided covers, persistence-guided refinements, and learned-cover schemes all arise because different parameter choices can produce materially different architectures (Belchí et al., 2019, Tao et al., 2024, Alvarado et al., 2023). Second, explanation layers introduce their own epistemic issues. Explainable Mapper explicitly treats hallucination as a risk and therefore pairs explanation with perturbation-based verification; even then, trajectory verification remains manual, and parameter sensitivity remains relevant (Yan et al., 24 Jul 2025). Third, learned mappers inherit the assumptions of their training data or model class: DNNFuser depends on a high-quality mapping corpus and on the serializability of the mapping space, while G-Mapper can vary slightly across runs because Gaussian mixture initialization is not fixed (Kao et al., 2022, Alvarado et al., 2023).

Across domains, the term therefore denotes a methodological role rather than a single implementation. In topological data analysis it is a nerve-based representation of structure; in software analysis it is a feature-and-layer visualization; in accelerator and quantum compilation it is a schedule and placement generator; in ultra-low-field MRI it is a calibration robot that externalizes the otherwise invisible $\epsilon$7 field. The unifying characteristic is the conversion of latent architecture into an explicit artifact—graph, schedule, field mesh, or city map—that can be inspected, compared, and acted upon (Dłotko et al., 2021, Kobayashi et al., 2013, Morris, 29 Apr 2025).