HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations SHAY SNYDER, George Mason University, USA ANDREW CAPODIECI, Neya Systems, USA DAVID GORSICH, U.S. Army Ground Systems, USA MARYAM PARSA, George Mason University, USA
arXiv:2604.15113v1 [cs.AI] 16 Apr 2026
Vector Symbolic Architectures (VSAs) provide a well-defined algebraic framework for compositional representations in hyperdimensional spaces. However, evaluating their behavior on continuous spatial domains remains challenging due to the diversity of backends and the absence of a unified software framework for systematic evaluation. We introduce HyperSpace, an open-source framework that decomposes VSA systems into modular operators for encoding, binding, bundling, similarity, cleanup, and regression. Using HyperSpace, we analyze and benchmark two representative VSA backends: Holographic Reduced Representations (HRR) and Fourier Holographic Reduced Representations (FHRR). Although FHRR provides lower theoretical complexity for individual operations, HyperSpace’s modularity reveals that similarity and cleanup dominate runtime in spatial domains. As a result, HRR and FHRR exhibit comparable end-to-end performance. Differences in memory footprint introduce additional deployment trade-offs where HRR requires approximately half the memory of FHRR vectors. By enabling modular, system-level evaluation, HyperSpace reveals practical trade-offs in VSA pipelines that are not apparent from theoretical or operator-level comparisons alone. Additional Key Words and Phrases: Hyperdimensional Computing, Vector Symbolic Architectures, Spatial Representations, Associative Memory, System-Level Analysis, Distributed Representations
1
Introduction
Vector Symbolic Architectures (VSAs), also commonly known as hyperdimensional computing, provide an algebraic framework for representing and manipulating structured information with high-dimensional distributed vectors [9, 10]. Rather than relying on learned latent spaces, VSAs construct compositional representations through operations such as binding, bundling, inversion, and similarity [10, 16]. These operations support associative recall and symbolic composition within a unified mathematical framework [8, 17]. Recent work has shown that VSAs support a broad range of capabilities, including generative modeling, probabilistic inference, graph learning, and associative memory [3, 5, 14]. VSAs have also shown growing promise for spatial reasoning problems, where continuous coordinates, maps, and value functions must be represented with compositional memory operations [2, 4, 11]. This capability is relevant for robotics and autonomous systems, where spatial representations support mapping, navigation, path planning, and continuous decision-making over structured environments [19–22]. However, evaluating VSA systems on continuous spatial domains remains difficult. Existing spatial VSA implementations are often developed in task-specific settings, making it hard to separate the effects of the underlying backend from the effects of encoding strategy, cleanup dynamics, decoder design, or evaluation protocol [1, 6, 20, 21]. This limitation becomes especially important in dense pipelines, where end-to-end performance depends not only on the theoretical cost of individual operators, but also on how those operators interact across encoding, storage, inversion, DISTRIBUTION STATEMENT A. Approved for public release; distribution is unlimited. OPSEC #10534. Authors’ Contact Information: Shay Snyder, George Mason University, Fairfax, Virginia, USA, [email protected]; Andrew Capodieci, Neya Systems, Pittsburgh, Pennsylvania, USA, [email protected]; David Gorsich, U.S. Army Ground Systems, Warren, Michigan, USA, david.j.gorsich.civ@ army.mil; Maryam Parsa, George Mason University, Fairfax, Virginia, USA, [email protected].
1
2
Snyder et al.
cleanup, and regression. As a result, isolated operator-level comparisons can fail to predict runtime, memory usage, and reconstruction behavior in full spatial workflows. To address this gap, we introduce HyperSpace1 , an open-source framework for constructing and evaluating VSA pipelines with continuous spatial representations. Rather than committing to a single backend, HyperSpace decomposes spatial processing into a shared set of abstract modules for positional encoding, value encoding, memory storage, positional inversion, cleanup, and regression. This abstraction enables heterogeneous VSA backends to be instantiated within the same end-to-end pipeline and compared under controlled conditions. As a result, HyperSpace serves both as an implementation framework and as a methodological tool for identifying computational, memory, and representational trade-offs that are not apparent when evaluating isolated operators. Using HyperSpace, we analyze two representative VSA backends: Holographic Reduced Representations (HRR) and Fourier Holographic Reduced Representations (FHRR) [16, 17]. Although FHRR offers lower theoretical complexity for individual operations, our system-level analysis shows that these savings do not necessarily translate into lower end-to-end cost in spatial domains. Instead, similarity-based cleanup and regression dominate runtime across many configurations, yielding comparable overall latency between HRR and FHRR. At the same time, differences in vector representations create deployment-dependent memory trade-offs, with floating point HRR requiring approximately half the storage of complex FHRR vectors. These results demonstrate why backend selection in spatial VSA systems should be treated as a pipeline-level design decision rather than a comparison of isolated operators. The contributions of this work are summarized as follows: • We introduce HyperSpace, an open-source framework for constructing and evaluating continuous spatial VSA pipelines through shared abstract operators. • We formalize spatial VSA processing as a sequence of modules, enabling controlled comparisons across heterogeneous backends, cleanup mechanisms, and regression methods. • We instantiate HyperSpace with representative HRR- and FHRR-based backends and analyze their computational and memory complexity across the full pipeline. • We identify deployment-dependent trade-offs between HRR and FHRR, showing that backend selection depends jointly on runtime, memory footprint, and decoder configuration. 2
Background & Previous Works
VSAs represent information using high-dimensional vectors and distributed algebraic operations [9]. Fundamental VSA operations include binding, bundling, similarity, and inversion [10]. Binding combines vectors into compositional representations, bundling superposes multiple items into a shared memory, similarity supports associative retrieval, and inversion enables partial recovery of bound vectors. Together, these operations provide an algebraic framework for representing information within distributed vectors. Multiple VSA backends have been proposed, including Holographic Reduced Representations (HRR) [16], Fourier Holographic Reduced Representations (FHRR) [17]. These backends differ in their algebraic formulations, numerical representations, and implementation costs, but they expose closely related operations for encoding, storage, and retrieval [10]. As a result, many VSA systems can be described at the level of shared abstract operations, even when their concrete implementations differ substantially. 1 Publically available at https://github.com/Parsa-Research-Laboratory/HyperSpace
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
3
VSA-based Spatial Representations: VSAs have increasingly been used to represent spatial structure in robotics, navigation, and cognitive modeling [2, 11, 20, 21]. In particular, spatial representations such as Spatial Semantic Pointers [2, 11] and fractional power codes [4, 20] encode continuous coordinates into high-dimensional vectors that preserve geometric relationships while remaining compatible with existing VSA operators. This makes VSAs attractive for tasks such as spatial memory, path planning, and continuous value representations [2, 4, 11, 20, 21]. However, spatial VSA systems are typically evaluated within task-specific implementations, making it difficult to separate backend properties from choices in encoding strategy, cleanup dynamics, decoder design, or evaluation protocol. This challenge is particularly important in continuous spatial domains, where end-to-end performance depends not only on the cost of individual VSA operators, but also on how those operators interact across encoding, storage, cleanup, and decoding. VSA Evaluation Frameworks: Existing software libraries such as TorchHD [6] and Nengo-SPA [1] provide the infrastructure for constructing and experimenting with VSA backends. However, these libraries primarily emphasize representation building and model development rather than controlled, system-level comparisons of heterogeneous VSA backends operating on a common workflow. Consequently, prior works compare individual operators on isolated downstream tasks, making it difficult to determine which trade-offs arise from the backend or the surrounding pipeline [2, 3, 11]. To address this gap, we introduce HyperSpace, a modular framework for analyzing spatial VSA systems through a shared set of abstract operators. Rather than committing to a single backend, HyperSpace decomposes the pipeline into continuous encoding, binding, bundling, inversion, similarity, cleanup, and regression modules that can be instantiated by different backends. This abstraction enables comparisons of heterogeneous backends within a unified environment. As a result, HyperSpace serves not only as an implementation framework, but also as a tool for identifying computational, memory, and representational trade-offs that are not apparent when evaluating isolated VSA operators. 3
The HyperSpace Framework
HyperSpace creates an abstract framework for processing continuous spatial information in VSAs through a series of extensible modules. The framework is agnostic to any specific VSA implementation and instead formalizes a minimal set of abstract operations: • Continuous Encoding (E): maps continuous spatial coordinates or scalar values into high-dimensional vectors • Binding (⊗): combines two or more high-dimensional vectors into a compositional representation • Bundling (⊕): aggregates multiple vectors into a composite representation • Similarity (S): computes the correlation between vectors for retrieval and decoding • Inversion (I): computes the inverse of a vector, enabling the retrieval of constituent components from composite representations • Normalization (N ): normalizes the vector to unit length • Cleanup (C): iteratively remove noise from output vectors • Weighting (⊲⊳): modulate the contribution of a vector by a scalar weight • Regression (R): abstract function for converting from vector space to real-value space A high-level overview of the framework with the operational implementation of each module, as a function of these abstract operations, is shown in Figure 1. These abstractions allow complexity to be expressed generically in terms of the number of encoding, binding, bundling, similarity, and inversion operations, independent of the underlying algebraic formulation. Throughout the remainder of the manuscript, we refer to this type of complexity as Operational Complexity.
4
Snyder et al.
Fig. 1. A high-level overview of the HyperSpace framework. A high-level overview of the HyperSpace framework. (A) Inputs consist of coordinate–value pairs (x, 𝑣). (B) Coordinates are encoded into hypervectors 𝜙𝑝 (x) via compositional positional encoding. (C) Values are encoded as hypervectors 𝜙 𝑣 (𝑣). (D) Position–value pairs are bound and bundled into a shared memory 𝑚. (E) Querying is performed by positional inversion and unbinding. (F) Retrieved representations are refined via cleanup operations (resonator or modern Hopfield). (G) A regression operator decodes the representation into a scalar estimate. (H) The final output yields reconstructed values 𝑣 ′ at query locations.
The operational implementation and complexity of each module is shown in Table 1. Moreover, all mathematical symbols leveraged throughout the manuscript are detailed in Table 2. The following subsections describe each HyperSpace module. Input Representations: To provide a modular framework for processing continuous spatial information, HyperSpace assumes that each dataset D consists of 𝑁 samples: 𝑁 D = {(x𝑖 , 𝑣𝑖 ) | x𝑖 ∈ R𝑛 , 𝑣𝑖 ∈ R}𝑖=1 ,
(1)
where each sample is defined by a position vector x representing an 𝑛-dimensional spatial location, and an associated scalar value 𝑣. As illustrated in the example shown in Figure 1(A), each sample (x, 𝑣) corresponds to a position vector x = (𝑥, 𝑦) within a 2D environment and an associated scalar value 𝑣, representing the measurement at that location. Positional Encoding: As shown in Figure 1(B), the positional encoding module transforms each position vector x into a hypervector 𝜙 𝑝 (x) by encoding each individual dimension of x and binding the resulting encodings together: 𝜙 𝑝 (x) =
𝑛 Ì
E 𝑗 (𝑥 𝑗 ),
(2)
𝑗=1
where E 𝑗 denotes the abstract encoder for the 𝑗-th component of x, and ⊗ represents an abstract binding operator. The operational complexity of positional encoding 𝜙 𝑝 (x) scales with the dimensionality of the point vector 𝑛. Therefore the operation requires 𝑛 encodings and (𝑛 − 1) bindings, yielding a total operational complexity of: 𝑂 (𝜙𝑝 (x)) = 𝑛 𝑂 (E) + (𝑛 − 1) 𝑂 (⊗).
(3)
This formulation allows position vectors to be constructed through iterative or parallel binding and encoding operations.
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
5
Table 1. The baseline implementation of HyperSpace defined through abstract algebraic terminology can will be extended by downstream VSA systems.
Module
Variant -
Abstract Definition Ë𝑛 𝑗=1 E 𝑗 (𝑥 𝑗 )
Spatial Encoding Value Encoding
𝑛 𝑂 (E) + (𝑛 − 1) 𝑂 (⊗)
-
E (𝑣)
𝑂 (E)
Memory Storage
-
Positional Inversion
-
Cleanup
𝑂 (⊗) + 𝑂 (⊕)
Codebook
m ⊕ 𝜙 𝑝 (x) ⊗ 𝜙 𝑣 (𝑣) N (m) ⊗ I 𝜙 𝑝 (x′ ) É 𝑘 ′ N 𝑖=1 Φ𝑖 ⊲⊳ S 𝜙 𝑣 (𝑣 ), Φ𝑖 É𝑘 ′ N 𝑖=1 Φ𝑖 ⊲⊳ NH S(𝜙 𝑣 (𝑣 ), Φ𝑖 ) Í𝑘 ′ 𝑖=1 𝜑𝑖 𝜎𝑖 𝛽S Φ𝑖 , 𝜙 𝑣 (𝑣 )
Neural Network
𝑓𝜃 (𝜙 𝑣 (𝑣 ′ ))
𝜖
Resonator Modern Hopfield
Regression
Operational Complexity
𝑂 (𝜙𝑝 (x′ )) + 𝑂 (I) + 𝑂 (⊗) 𝑂 (N ) + 𝑘 𝑂 (⊲⊳) + 𝑂 (S) + (𝑘 − 1)𝑂 (⊕) 𝑘 𝑂 (⊲⊳) + 𝑂 (S) + 𝑂 (NH ) + 𝑂 (N ) + (𝑘 − 1)𝑂 (⊕) 𝑘 𝑂 (S) + 𝜖
Value Encoding: As shown in Figure 1(C), the value encoding module transforms each scalar input into a hypervector with Equation 2 where 𝑛 = 1: 𝜙 𝑣 (𝑣) = E (𝑣).
(4)
Accordingly, the operational complexity of 𝜙 𝑣 (𝑣) is the simplified form of Equation 3 with 𝑛 = 1: 𝑂 (𝜙 𝑣 (𝑣)) = 𝑂 (E).
(5)
Both 𝜙 𝑝 (x) and 𝜙 𝑣 (𝑣) produce hypervectors in the same representation space, enabling compositional binding or superposition within downstream HyperSpace modules. Memory Storage: As shown in Figure 1(D), the memory storage module aggregates positional and value hypervector pairs into a single memory vector m. Each encoded position and value pair (𝜙 𝑝 (x), 𝜙 𝑣 (𝑣)) is added to the memory by binding the constituent vectors together before bundling with the existing memory vector: m = m ⊕ 𝜙 𝑝 (x) ⊗ 𝜙 𝑣 (𝑣) ,
(6)
where ⊗ denotes the binding operator and ⊕ denotes the bundling operator. For each sample in the dataset D, the memory storage module requires one bind and one bundle, yielding a per-sample operational complexity of: 𝑂 (m) = 𝑂 (⊗) + 𝑂 (⊕).
(7)
This formulation enables the construction of distributed associative memories where spatial and value information are jointly encoded within a unified vector representation. Positional Inversion: As shown in Figure 1(E), the entire dataset D of spatially associated values is encoded into the hypervector memory m, the value at any location x′ can be estimated by normalizing m and performing an inverse binding operation to recover a noisy approximation of the corresponding value vector 𝜙 𝑣 (𝑣 ′ ): 𝜙 𝑣 (𝑣 ′ ) = N (m) ⊗ I 𝜙 𝑝 (x′ ) ,
(8)
6
Snyder et al.
where N denotes the abstract vector normalization operator and I denotes the abstract vector inversion operator. The spatial inversion module requires one positional encoding, one vector inversion, one normalization, and one binding operation per query location. While normalization is required, it can be computed once and reused across multiple query locations, allowing its cost to be amortized and excluded from the per-query complexity. Therefore, the total operational complexity per query is: 𝑂 (𝜙 𝑣 (𝑣 ′ )) = 𝑂 (𝜙𝑝 (x′ )) + 𝑂 (I) + 𝑂 (⊗).
(9)
A critical distinction between positional inversion and traditional end-to-end resonator-based systems is that positional inversion explicitly preserves spatial structure through the encoding and inversion process. In classical resonator formulations [3, 20], the retrieval operation seeks convergence to an attractor basin rather than decoding at fixed query locations. Consequently, these models can recall stored item associations but cannot reliably recover values at arbitrary, previously unseen positions. In contrast, HyperSpace’s positional inversion module enables value estimation at any location. Cleanup: As shown in Figure 1(F), HyperSpace’s cleanup module implements associative memory cleanup through a generalized cleanup operator C. This operator introduces temporal dynamics where decoded value vectors are iteratively "cleaned" for some number of timesteps. Given a decoded value vector 𝜙 𝑣 (𝑣 ′ ), the cleanup operator is defined over one timestep 𝑡 as: 𝜙 𝑣 (𝑣 ′ ) (𝑡 +1) = C(𝜙 𝑣 (𝑣 ′ ) (𝑡 ) ).
(10)
These cleanup operations commonly leverage a codebook Φ that contains a set of vectors representing 𝜙 𝑣 at discrete points. Therefore, a proper derivation of the cleanup operator is defined as 𝜙 𝑣 (𝑣 ′ ) (𝑡 +1) = C(𝜙 𝑣 (𝑣 ′ ) (𝑡 ) , Φ),
(11)
where the operational complexity of C will scale with the cardinality of the codebook |Φ|. HyperSpace provides two baseline cleanup operators: Resonator Networks [3] and Modern Hopfield Networks [18]. We refer to these cleanup operations as C R and C H , respectively. The resonator cleanup operator C R performs iterative refinement through recurrent superposition and feedback with the codebook: C R (𝜙 𝑣 (𝑣 ), Φ) = N ′
𝑘 Ê
! Φ𝑖 ⊲⊳ S 𝜙 𝑣 (𝑣 ), Φ𝑖 ′
,
(12)
𝑖=1
where S(·, ·) denotes a similarity operator, ⊕ represents bundling, N (·) is an optional normalization operator, ⊲⊳ is a weighted normalization operator that modulates the strength of the given codebook element Φ𝑖 by its similarity with the query vector, and 𝑘 = |Φ| is the cardinality of the codebook. Through recurrent updates, C R converges toward a stable attractor corresponding to the most similar stored code. The operational complexity of C R , for a single timestep, is defined as: 𝑂 (C R ) = 𝑂 (N ) + 𝑘 𝑂 (⊲⊳) + 𝑂 (S) + (𝑘 − 1)𝑂 (⊕).
(13)
In contrast, Hopfield cleanup C H is implemented as: C H (𝜙 𝑣 (𝑣 ′ ), Φ) = N
𝑘 Ê 𝑖=1
Φ𝑖 ⊲⊳ NH S(𝜙 𝑣 (𝑣 ′ ), Φ𝑖 ) ,
(14)
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
7
Table 2. The mathematical symbols used throughout this manuscript.
Symbol
Meaning
E
continuous encoder
⊗
bind
⊕
bundle
S
vector similarity
I
vector inversion
N
vector normalizer
C
cleanup
⊲⊳
vector weighting
R
regression decoder
𝑓𝜃
neural network
D
dataset
x
position vector
𝑣
value scaler
𝑣′
decoded value scaler
𝑛
environment dimensionality
𝑁
dataset size
𝑖
abstract iterator
𝜙 𝑝 (x)
position hypervector
𝜙 𝑣 (𝑣)
value hypervector
m
hypervector memory
Φ
codebook
𝜑
codebook values
(·) ′
estimate of a variable
|·|
cardinality
𝑞
individual quantization level
𝑡
discrete time step
𝛽
temperature
where NH is the softmax function. This process corresponds to minimizing an implicit energy function whose minima coincide with stored attractors. The operational complexity of the Hopfield cleanup operator is defined as: 𝑂 (C H ) = 𝑘 𝑂 (⊲⊳) + 𝑂 (S) + 𝑂 (NH ) + 𝑂 (N ) + (𝑘 − 1)𝑂 (⊕) The major takeaway here is that each C H step requires an additional normalization operation compared to C R .
(15)
8
Snyder et al. Table 3. Asymptotic Complexity Comparison of HRR [16] and FHRR [17] Operations
Operation
HRR [16]
FHRR [17]
Encoding E Binding ⊗ Bundling ⊕ Similarity S Inversion I Normalization N Weighting ⊲⊳
𝑂 (𝐷 log 𝐷) 𝑂 (𝐷 log 𝐷) 𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷 log 𝐷) 𝑂 (𝐷) 𝑂 (𝐷)
𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷) 𝑂 (𝐷)
Storage per vector
4D bytes
8D bytes
Explanation FFT-based FPE vs. direct complex exponentiation Circular convolution (FFT) vs. element-wise multiplication Both use element-wise addition Both compute dot products FFT + conjugate + IFFT vs. conjugation only Both use norm + element-wise multiplication Both use element-wise multiplication float32 vs. complex64 representation
Regression: In the final HyperSpace module, we transform the cleaned query vectors 𝜙 𝑣 (𝑣 ′ ) into an estimated value ′ 𝑣 ∈ R with an abstract regression operator R. As shown in Figure 1(G) HyperSpace provides two implementations which we refer to as codebook R C and neural network R N decoding. Codebook decoding is defined as an expectation over the discretized codebook values 𝜑 and the similarity between the query vector and the corresponding code: 𝑣′ =
𝑘 ∑︁
𝜑𝑖 𝜎𝑖 𝛽S Φ𝑖 , 𝜙 𝑣 (𝑣 ′ ) ,
(16)
𝑖=1
where 𝑖 is an iterator representing the 𝑖-th discrete value in the codebook. The operational complexity of codebook decoding is defined as 𝑂 (R C (𝜙 𝑣 (𝑣 ′ ))) = 𝑘 𝑂 (S) + 𝜖,
(17)
where 𝜖 representing the additional logit-wise operations with the softmax and expectation. Given that 𝑘 << size(𝜙 𝑣 ) and the softmax is only used once, we assume this overhead negligible and won’t count towards operational complexity. Neural network decoding is defined as: 𝑣 ′ = 𝑓𝜃 (𝜙 𝑣 (𝑣 ′ )),
(18)
where 𝑓𝜃 is an arbitrary neural network that returns a single scalar value representing the decoded value. Given that no VSA operations are included with this regression approach, we assume the operational complexity is zero. However, the additional training and inference latency will be included in our results. 4
Results & Discussion
We use HyperSpace to evaluate the computational and memory characteristics of two representative VSA backends: Holographic Reduced Representations (HRR) [16] and Fourier Holographic Reduced Representations (FHRR) [17]. We first present an algorithmic analysis that examines how backend-specific operations interact with each module. We then describe the procedure used to generate synthetic training and validation data. Finally, we report empirical results that quantify the performance of each backend and highlight deployment considerations that motivate future research. 4.1
Algorithmic Analysis
We analyze the theoretical computational and memory complexity of HRR and FHRR within HyperSpace. Rather than advocating for a single backend, this highlights how each backend interacts with different workloads, batching strategies, and deployment constraints.
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
9
Table 3 shows the asymptotic complexity of each VSA operation in HRR and FHRR. HRR performs binding and encoding with an additional Fast Fourier Transform (FFT), yielding 𝑂 (𝐷 log 𝐷) complexity for hypervectors of dimensionality 𝐷, whereas FHRR operates directly in the frequency domain with 𝑂 (𝐷) element-wise operations. However, HyperSpace performs all VSA operations in batched operations, where FFT costs amortize across multiple data samples. As batch size increases, FFT complexity is minimized and HRRs approach linear scaling in 𝐷. Beyond arithmetic complexity, memory complexity introduces additional considerations. HRR requires 4𝐷 bytes per vector (float32), whereas FHRR requires 8𝐷 bytes for complex values. In distributed or communication-constrained environments, memory bandwidth, cache utilization, and inter-agent transmission costs may constrain overall system performance [23]. Therefore, HRR’s reduced memory footprint may outweigh FHRR’s arithmetic advantage. This systems-level perspective is a key finding enabled by HyperSpace. When evaluated within a complete pipeline, rather than isolated algorithmic primitives, HRR and FHRR exhibit comparable scaling behavior. Consequently, backend selection shifts from a purely algorithmic comparison to a deployment-dependent trade-off. FHRR provides streamlined frequency-domain computation with consistent 𝑂 (𝐷) element-wise operations, whereas HRR offers storage and memory efficiency. These findings suggest that backend choice is context-dependent, motivating future exploration of hybrid, quantized, or adaptive VSA representations that dynamically balance computational and memory efficiency.
4.2
Experimental Analysis
Data Generation: We generate synthetic 2D maps to simulate cost maps commonly used in robotics [19]. Each map is initialized as a continuous grid with start and goal positions at opposing corners. The lowest cost path is defined by fitting a cubic spline through seven control points between the start and goal. The spline is sampled at 10,000 points to approximate a continuous path. All spline samples are assigned a uniform cost of 1.0, thereby defining the navigable path. The full map is constructed by computing the Euclidean distance transform (EDT) from the optimal path [24]. The EDT induces a radially increasing cost structure where traversal cost grows proportionally with distance from the reference trajectory. This produces smooth gradients that penalize deviation from the optimal path. We sample the grid at a fixed resolution of 28 × 28 to mimic the scale of MNIST [12] and N-MNIST [15]. This discretization results in 28 × 28 = 784 samples per map. Experimental Setup: We evaluate HyperSpace with the following module and backend combinations: (i) HRR and FHRR backends, (ii) none, resonator, and modern Hopfield cleanup operations, (iii) codebook and neural network regression. Latency is measured as the end-to-end runtime, in seconds, of the full pipeline on an Apple M4 Pro CPU. To ensure a consistent comparison, all backends are evaluated using unoptimized implementations without hardware-specific acceleration. As a result, the reported runtimes reflect baseline performance and may be improved with optimized kernels or specialized hardware. Mapping performance is measured as the mean squared error (MSE). Each combination is evaluated across five random seeds with a vector dimensionality of 8096. We report the mean latency and prediction error for each combination. Pipeline Latency Breakdown: Figure 2 reports the mean latency of each combination with a breakdown across individual modules. The stacked bars illustrate the relative contribution of positional encoding, value encoding, memory storage, positional inversion, cleanup, and regression. Because HyperSpace decomposes this pipeline into abstract modules, these results reveal how different pipelines allocate computational effort and runtime latency.
10
Snyder et al.
Fig. 2. Pipeline latency breakdown for HRR and FHRR backends. Stacked bars show the mean per-stage latency, averaged over five random seeds. Abbreviations: MHN = Modern Hopfield Network; Res = Resonator Network; CB = codebook decoding.
Fig. 3. Latency–accuracy tradeoff across backends, cleanup, and regression methods. The x-axis shows the mean pipeline latency, while the y-axis shows the mean squared error. The dashed curve indicates the Pareto frontier.
Although FHRR provides the lowest overall latency, the latency distribution differs substantially between backends. In HRR, encoding and memory storage contribute a larger fraction of the total runtime due to the FFT-based implementation of binding. In contrast, FHRR performs these operations directly in the complex domain using element-wise multiplication.
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
11
Fig. 4. Comparison of reconstructions using HRR and FHRR. The left panel shows the ground truth generated from the environment. The middle and right panels show reconstructions produced by the best-performing HRR and FHRR configurations identified in the latency–accuracy analysis.
Cleanup operations account for a larger share of runtime in FHRR configurations, likely due to the higher cost of complex-valued arithmetic relative to the real-valued operations used by HRR. As a result, while HRR and FHRR exhibit comparable overall latencies, the allocation of computational effort across modules differs significantly. This highlights a key strength of HyperSpace: its abstract modules expose discrepancies between isolated operators and end-to-end pipeline behavior. It therefore reveals how backends reshape the computational profile of VSA-based spatial learning and introduce distinct trade-offs. Latency–Accuracy Trade-offs: Figure 3 illustrates the trade-off between pipeline latency and reconstruction error across all combinations. Each point corresponds to a unique combination of backend, cleanup, and regression strategies. The dashed curve denotes the Pareto frontier, configurations that achieve optimal trade-offs between pipeline latency and reconstruction error. Configurations without cleanup achieve the lowest latency but incur higher reconstruction error due to the noise introduced in the memory storage and positional inversion modules. Conversely, resonator and modern Hopfield cleanup methods reduce reconstruction error by iteratively refining decoded vectors. This process improves reconstruction fidelity but introduces additional computational overhead proportional to the codebook size and number of cleanup iterations. The regression modules introduce additional trade-offs. Codebook decoding relies on similarity comparisons against discretized entries in the codebook, enabling fast inference while constraining outputs to a finite set of predefined values. Neural network regression instead learns a continuous mapping from vectors to scalar values, improving reconstruction fidelity while maintaining comparable or lower inference latencies. However, this introduces additional considerations: neural regression requires offline training and reduces interpretability relative to explicit codebook-based decoding. In our experiments, training takes approximately 10–20 seconds and is performed once. As a result, the choice between regression methods reflects a trade-off between discrete, interpretable representations and continuous, learned mappings with potentially improved performance. Together, these results highlight how the Pareto frontier emerges from competing factors across HyperSpace operators. Rather than reflecting a single optimal backend, the frontier reveals a family of configurations that balance encoding efficiency, cleanup dynamics, reconstruction error, and memory complexity.
12
Snyder et al. Qualitative Reconstruction Analysis: Figure 4 shows the reconstructions generated by the best-performing HRR
and FHRR configurations in the latency–accuracy analysis. The left panel shows the ground-truth map, while the middle and right panels show the reconstructions produced by HRR and FHRR, respectively. Qualitatively, the HRR reconstruction exhibits slightly higher noise near boundaries and regions with steep gradients. These artifacts are consistent with numerical effects introduced by FFT-based circular convolution [16]. In contrast, FHRR performs these operations directly in the complex domain using element-wise complex multiplication. This reduces the accumulation of numerical error during encoding and decoding [17]. Despite these differences, both backends produce similar reconstructions and preserve the dominant spatial features. This supports the earlier quantitative results showing that HRR and FHRR achieve comparable overall reconstruction performance, despite differences in how computational cost is distributed across the pipeline. 5
Conclusion
In this work, we introduced HyperSpace, a generalized framework for constructing, decomposing, and evaluating continuous spatial VSA pipelines through a shared set of abstract operators. By formalizing spatial learning in terms of encoding, binding, bundling, inversion, similarity, cleanup, and regression, HyperSpace enables controlled end-to-end comparisons across heterogeneous backends and module configurations. Therefore, HyperSpace serves not only as an implementation framework, but also as a tool for understanding how design choices propagate through the full pipeline. Using this framework, we instantiated and analyzed representative HRR- and FHRR-based systems [16, 17]. Although FHRR provides lower theoretical complexity for several individual operations, these operator-level advantages did not directly translate into uniformly lower end-to-end cost. Instead, HyperSpace revealed that similarity-driven cleanup and regression can dominate runtime in spatial learning, leading HRR and FHRR to exhibit comparable overall latency even though they rely on different operations. HyperSpace also exposed deployment-level trade-offs that are not apparent from operator-level analysis alone. HRR uses real-valued vectors and requires approximately half the storage of FHRR, while FHRR avoids FFT-based binding and inversion through direct complex-valued operations. As a result, backend selection is not simply a question of asymptotic arithmetic complexity, but a broader system-level decision shaped by runtime distribution, memory footprint, implementation characteristics, hardware compatibility, and decoder design. More broadly, these results illustrate the central value of HyperSpace: it provides a common framework for systematically analyzing spatial VSA systems as complete pipelines rather than isolated operators. This makes it possible to study how backends, cleanup strategies, regression modules, and future extensions interact within end-to-end systems. Future work will extend HyperSpace to support additional backends [10], provide hardware efficient backend implementations, hybrid and compressed representations [7], and larger applications in robotics [2, 20] and other resource-constrained environments [13]. Acknowledgments We acknowledge the technical and financial support of the Automotive Research Center (ARC) in accordance with Cooperative Agreement W56HZV-19-2-0001 U.S. Army DEVCOM Ground Vehicle Systems Center (GVSC) Warren, MI. References [1] Trevor Bekolay, James Bergstra, Eric Hunsberger, Travis DeWolf, Terrence C Stewart, Daniel Rasmussen, Xuan Choo, Aaron Russell Voelker, and Chris Eliasmith. 2014. Nengo: a Python tool for building large-scale functional brain models. Frontiers in neuroinformatics 7 (2014), 48.
HyperSpace: A Generalized Framework for Spatial Encoding in Hyperdimensional Representations
13
[2] Nicole Sandra-Yaffa Dumont. 2025. Symbols, Dynamics, and Maps: A Neurosymbolic Approach to Spatial Cognition. Ph. D. Dissertation. University of Waterloo. [3] E Paxon Frady, Spencer J Kent, Bruno A Olshausen, and Friedrich T Sommer. 2020. Resonator networks, 1: An efficient solution for factoring high-dimensional, distributed representations of data structures. Neural computation 32, 12 (2020), 2311–2331. [4] E Paxon Frady, Denis Kleyko, Christopher J Kymn, Bruno A Olshausen, and Friedrich T Sommer. 2022. Computing on functions using randomized vector representations (in brief). In Proceedings of the 2022 Annual Neuro-Inspired Computational Elements Conference. 115–122. [5] P Michael Furlong and Chris Eliasmith. 2024. Modelling neural probabilistic computation using vector symbolic architectures. Cognitive Neurodynamics 18, 6 (2024), 1–24. [6] Mike Heddes, Igor Nunes, Pere Vergés, Denis Kleyko, Danny Abraham, Tony Givargis, Alexandru Nicolau, and Alex Veidenbaum. 2023. Torchhd: An Open Source Python Library to Support Research on Hyperdimensional Computing and Vector Symbolic Architectures. Journal of Machine Learning Research 24, 255 (2023), 1–10. http://jmlr.org/papers/v24/23-0300.html [7] Mohsen Imani, Samuel Bosch, Sohum Datta, Sharadhi Ramakrishna, Sahand Salamat, Jan M Rabaey, and Tajana Rosing. 2019. Quanthd: A quantization framework for hyperdimensional computing. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 39, 10 (2019), 2268–2278. [8] Mohsen Imani, Abbas Rahimi, Deqian Kong, Tajana Rosing, and Jan M Rabaey. 2017. Exploring hyperdimensional associative memory. In 2017 IEEE international symposium on high performance computer architecture (HPCA). IEEE, 445–456. [9] Pentti Kanerva. 1994. The spatter code for encoding concepts at many levels. In ICANN’94: Proceedings of the International Conference on Artificial Neural Networks Sorrento, Italy, 26–29 May 1994 Volume 1, Parts 1 and 2 4. Springer, 226–229. [10] Denis Kleyko, Dmitri A. Rachkovskij, Evgeny Osipov, and Abbas Rahimi. 2022. A Survey on Hyperdimensional Computing aka Vector Symbolic Architectures, Part I: Models and Data Transformations. Comput. Surveys 55, 6 (2022). doi:10.1145/3538531 [11] Komer, Brent. 2020. Biologically Inspired Spatial Representation. Ph. D. Dissertation. University of Waterloo. http://hdl.handle.net/10012/16430 [12] Yann LeCun, Corinna Cortes, and CJ Burges. 2010. MNIST handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist 2 (2010). [13] Yang Ni, Zhuowen Zou, Wenjun Huang, Hanning Chen, William Youngwoo Chung, Samuel Cho, Ranganath Krishnan, Pietro Mercati, and Mohsen Imani. 2025. HEAL: Brain-inspired hyperdimensional efficient active learning. IEEE Transactions on Artificial Intelligence (2025). [14] Igor Nunes, Mike Heddes, Tony Givargis, Alexandru Nicolau, and Alex Veidenbaum. 2022. GraphHD: Efficient graph classification using hyperdimensional computing. In 2022 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE, 1485–1490. [15] Garrick Orchard, Ajinkya Jayawant, Gregory K. Cohen, and Nitish Thakor. 2015. Converting Static Image Datasets to Spiking Neuromorphic Datasets Using Saccades. Frontiers in Neuroscience Volume 9 - 2015 (2015). doi:10.3389/fnins.2015.00437 [16] Tony Plate et al. 1991. Holographic Reduced Representations: Convolution Algebra for Compositional Distributed Representations.. In IJCAI. 30–35. [17] Tony A Plate. 2003. Holographic Reduced Representation: Distributed representation for cognitive structures. Vol. 150. CSLI Publications Stanford. [18] Hubert Ramsauer, Bernhard Schäfl, Johannes Lehner, Philipp Seidl, Michael Widrich, Thomas Adler, Lukas Gruber, Markus Holzleitner, Milena Pavlović, Geir Kjetil Sandve, et al. 2020. Hopfield networks is all you need. arXiv preprint arXiv:2008.02217 (2020). [19] Mohamed Reda, Ahmed Onsy, Amira Y Haikal, and Ali Ghanbari. 2024. Path planning algorithms in the autonomous driving system: A comprehensive review. Robotics and Autonomous Systems 174 (2024), 104630. [20] Alpha Renner, Lazar Supic, Andreea Danielescu, Giacomo Indiveri, Bruno A. Olshausen, Yulia Sandamirskaya, Friedrich T. Sommer, and E. Paxon Frady. 2024. Neuromorphic visual scene understanding with resonator networks. Nature Machine Intelligence 6, 6 (01 Jun 2024), 641–652. doi:10.1038/s42256-024-00848-0 [21] Shay Snyder, Andrew Capodieci, David Gorsich, and Maryam Parsa. 2026. Brain Inspired Probabilistic Occupancy Grid Mapping with Vector Symbolic Architectures. npj Unconventional Computing 3, 1 (2026), 13. [22] Shay Snyder, Ryan Shea, Andrew Capodieci, David Gorsich, and Maryam Parsa. 2025. Generalizable Reinforcement Learning with Biologically Inspired Hyperdimensional Occupancy Grid Maps for Exploration and Goal-Directed Path Planning. arXiv preprint arXiv:2502.09393 (2025). [23] Ye Tian, Rishikanth Chandrasekaran, Kazim Ergun, Xiaofan Yu, and Tajana Rosing. 2025. Federated Hyperdimensional Computing: Comprehensive Analysis and Robust Communication. ACM Trans. Internet Things 6, 3, Article 14 (May 2025), 30 pages. doi:10.1145/3724129 [24] Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J. van der Walt, Matthew Brett, Joshua Wilson, K. Jarrod Millman, Nikolay Mayorov, Andrew R. J. Nelson, Eric Jones, Robert Kern, Eric Larson, C J Carey, İlhan Polat, Yu Feng, Eric W. Moore, Jake VanderPlas, Denis Laxalde, Josef Perktold, Robert Cimrman, Ian Henriksen, E. A. Quintero, Charles R. Harris, Anne M. Archibald, Antônio H. Ribeiro, Fabian Pedregosa, Paul van Mulbregt, and SciPy 1.0 Contributors. 2020. SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python. Nature Methods 17 (2020), 261–272. doi:10.1038/s41592-019-0686-2
Received 8 April 2026