Hyperdimensional Ontological Machine Intelligence: Vector-Symbolic Architectures, Binding, Associative Memory, and Compositional Reasoning

Full report

On this page

The central problem in the architecture of modern machine intelligence lies in the representational divide between continuous latent spaces and formal symbolic ontologies. Dense neural representations offer unparalleled statistical flexibility, enabling systems to map complex sensory distributions, learn intricate latent manifolds, and interpolate seamlessly across high-dimensional data. However, these models intrinsically struggle with explicit role-filler binding, variable reuse, strict compositional structure, and transparent memory operations1. When dense architectures attempt to emulate symbolic logic, they often entangle features within the residual stream, leading to opacity, hallucination, and catastrophic interference during continual updates. Conversely, classical symbolic systems enforce rigorous formal ontologies but lack the requisite flexibility to process noisy, ambiguous, and continuous sensory data without brittle hand-crafted parsing rules. This report investigates whether hyperdimensional representations can provide a native intermediate substrate bridging continuous latent spaces and formal ontologies. By leveraging Vector-Symbolic Architectures (VSAs)—also referred to as Hyperdimensional Computing (HDC)—we explore how operations over high-dimensional vector spaces can realize exact variable binding, robust episodic retrieval, and compositional reasoning. Guided by a constructive-design protocol, this research outlines how to build compositional, inspectable, and user-controlled machine intelligence. In addressing system failures or harmful errors, this framework deliberately avoids broad content prohibition, judgmental user classification, or ideological enforcement; instead, it relies on verifiable technical recovery, algebraic unbinding, and provenance tracking to isolate and correct corrupted ontological states.

1. High-Dimensional Geometry and Foundational Properties

The mathematical foundation of Vector-Symbolic Architectures relies on the geometric behavior of spaces with extremely high dimensionality, typically where [Figure omitted from source export]4. In these spaces, probability measures behave counterintuitively compared to low-dimensional geometry, enabling robust distributed representation.

1.1 High-Dimensional Concentration and Quasi-Orthogonality

If vectors are drawn independently and uniformly from a high-dimensional space (for instance, the bipolar hypercube [Figure omitted from source export] or the hypersphere [Figure omitted from source export]), the distance between any two randomly chosen vectors is concentrated tightly around the expected value5. For bipolar vectors of dimension [Figure omitted from source export], the normalized Hamming distance between two random vectors follows a binomial distribution with a mean of [Figure omitted from source export] and a standard deviation of [Figure omitted from source export]6. For [Figure omitted from source export], [Figure omitted from source export]. The probability of two independently drawn random vectors having a cosine similarity significantly different from zero is thus vanishingly small. This phenomenon, termed quasi-orthogonality, allows the architecture to treat independently generated hypervectors as distinct, atomic symbols with near-zero expected cross-talk8.

1.2 Distributed Representation and Robustness to Noise

In hyperdimensional computing, information is encoded holistically. A specific concept or variable is not localized to a single coordinate or neuron but is distributed globally across all [Figure omitted from source export] dimensions6. This fully distributed representation ensures that the failure or corruption of individual vector components—whether due to hardware stochasticity or superposition noise—does not destroy the encoded concept. Instead, it merely degrades the similarity to the original vector in a smooth, continuous manner. The architecture is inherently fault-tolerant, making it exceptionally suited for deployment on noisy nanoscale and memristive hardware4.

1.3 Capacity Limits and Superposition Noise

The capacity of a VSA is dictated by the signal-to-noise ratio (SNR) during the unbinding and associative retrieval operations4. When multiple hypervectors are combined (bundled) into a single memory trace, cross-talk noise accumulates. For a memory buffer storing [Figure omitted from source export] independent items in superposition, the probability of correct retrieval is bounded by the Gaussian cumulative density function of the SNR, where [Figure omitted from source export]8. If the number of bundled items exceeds the theoretical capacity bound, the system experiences catastrophic interference, rendering the constituent vectors indistinguishable from noise5. However, chunking through algebraic averaging mitigates this, suggesting that optimal, noise-free retrieval naturally aligns with biological cognitive capacity limits (e.g., [Figure omitted from source export] discrete active items) without necessitating structural degradation6.

2. Taxonomy of Vector-Symbolic Families

Various VSA implementations optimize for distinct vector substrates and algebraic operators, each trading off between representational capacity, biological plausibility, and hardware efficiency16. Table 1 compares the major vector-symbolic families.

3. Mathematical Operations for Compositional Machine Intelligence

A Vector-Symbolic Architecture constructs semantic and syntactic structures by defining an algebraic ring over the high-dimensional space [Figure omitted from source export]4. The fundamental operations enable the transition from flat embeddings to deeply nested formal ontologies.

3.1 Bundling and Superposition

Bundling ([Figure omitted from source export]) aggregates multiple concepts into a single composite hypervector. Given atomic vectors [Figure omitted from source export], the bundled vector [Figure omitted from source export] represents a set. The resultant vector is mathematically similar to its constituents: [Figure omitted from source export]. In MAP, this is achieved through element-wise integer addition, often followed by thresholding to constrain the vector to [Figure omitted from source export]7. In BSC, it is executed via a bitwise majority rule7. Bundling realizes approximate, lossy set unions, inherently supporting the representation of probabilities, superpositions, and uncertainty without strict compartmentalization.

3.2 Binding: Role-Filler and Variable Binding

Binding ([Figure omitted from source export]) associates two vectors, generating a novel representation that is nearly orthogonal to both operands: [Figure omitted from source export] and [Figure omitted from source export]. This orthogonality guarantees that structural combinations occupy unique points in the high-dimensional space. It is necessary to distinguish between role-filler binding and variable binding. In Smolensky's Tensor Product Representations (TPR), role-filler binding explicitly binds a structural role [Figure omitted from source export] to a substantive filler [Figure omitted from source export] via the outer product [Figure omitted from source export]1. Conversely, variable binding in Kanerva's BSC typically binds a variable name directly to its value using XOR, keeping the result within the original dimensionality7. For complex-valued hypervectors (FHRR), binding is the Hadamard product of complex phasors: [Figure omitted from source export]30.

3.3 Permutation and Sequence Transformation

Permutation ([Figure omitted from source export]) is a unitary, topology-preserving operation that shifts vector coordinates (e.g., [Figure omitted from source export]). It acts as a unary binding operation. Because [Figure omitted from source export] is orthogonal to [Figure omitted from source export], permutation is ideal for encoding temporal order, event trajectories, and sequence positions without requiring explicit integer role vectors, thus avoiding codebook exhaustion26.

3.4 Unbinding, Similarity, and Cleanup (Associative Retrieval)

To retrieve a filler [Figure omitted from source export] bound to a role [Figure omitted from source export] from a complex structure [Figure omitted from source export], the system applies the exact or approximate inverse of the role vector: [Figure omitted from source export]. Because the noise term is pseudo-orthogonal to the exact filler [Figure omitted from source export], the result is a noisy estimate, [Figure omitted from source export]. The system restores this estimate using an associative cleanup memory, which projects the noisy estimate back to the exact formal ontology (the codebook). The retrieval process calculates cosine or Hamming similarities between the noisy estimate [Figure omitted from source export] and all atomic concepts in the codebook, returning the argmax match24. This projection step ensures machine inspectability: processing steps can be mathematically verified at each operational node, securing technical recovery over opaque neural execution46.

3.5 Factorization and Resonator Networks

A critical challenge in VSA is unsupervised factorization: given a bound hypervector [Figure omitted from source export], how can the machine retrieve [Figure omitted from source export] simultaneously when none of the factors are known a priori? Exhaustively searching the combinatorial space is computationally intractable. Resonator Networks45 solve this via a nonlinear dynamical system that searches in superposition. Let [Figure omitted from source export] be the independent codebooks. The network iteratively updates estimates [Figure omitted from source export] using the dynamics: [Figure omitted from source export] This iterative unbinding and thresholding balances exploration and exploitation, resolving complex vector-symbolic factorizations exponentially faster than gradient-descent optimization21. Analog in-memory computing (AIMC) hardware exploits intrinsic device stochasticity to prevent resonator networks from stalling in limit cycles, enabling factorization across problem spaces exceeding tens of millions of combinations11.

4. Representational Constructs and Formal Ontology

High-dimensional algebra natively supports the transition from continuous sensory domains to discrete formal structures47. The following derivations demonstrate how machine intelligence can represent complex semantic topology. Entities and Types: An entity is a randomly initialized hypervector [Figure omitted from source export] acting as a globally unique identifier44. Types are represented as distinct, orthogonal vectors [Figure omitted from source export]. To assert that an entity belongs to a type (e.g., [Figure omitted from source export] is a [Figure omitted from source export]), the vectors are bound: [Figure omitted from source export]. Relations: A semantic relation [Figure omitted from source export] is encoded by defining roles for the predicate ([Figure omitted from source export]), agent ([Figure omitted from source export]), and object ([Figure omitted from source export]). The ontological fact is constructed as: [Figure omitted from source export]20. Deeply nested structures are created by treating [Figure omitted from source export] as an entity and binding it to a higher-order role. Ordered Sequences: A temporal or logical sequence [Figure omitted from source export] is encoded via iterated permutations: [Figure omitted from source export]. This encodes precedence natively without explicit binding to index vectors, enabling constant-time sub-sequence querying26. Trees and Graphs: A directed edge from node [Figure omitted from source export] to [Figure omitted from source export] is encoded as [Figure omitted from source export]. A complete graph is the superposition of its edge hypervectors. Traversing the graph requires binding the query node with the graph hypervector53. Trees are constructed by defining distinct orthogonal roles for left and right branches ([Figure omitted from source export]) and binding recursively: [Figure omitted from source export]54. Events, Processes, and Goals: An event is represented as a state transition, binding the initial state to the final state via a temporal operator. A process is an ordered sequence of events. A goal is encoded as a target state vector [Figure omitted from source export]. The machine intelligence evaluates the cosine similarity between the current state vector [Figure omitted from source export] and the goal vector [Figure omitted from source export], utilizing VSA algebraic differences [Figure omitted from source export] to extract the precise procedural skills required to minimize the distance. Temporal Position, Space, and Continuous Variables: Spatial Semantic Pointers (SSPs) implement continuous representations using fractional binding32. A spatial or temporal coordinate [Figure omitted from source export] is represented by taking base axes vectors [Figure omitted from source export] and applying fractional powers: [Figure omitted from source export]. In FHRR, fractional binding rotates the phasor in the frequency domain, mathematically mirroring the periodic spatial firing frequencies of grid cells in mammalian navigation systems40. Uncertainty and Beliefs: VSA accommodates epistemic uncertainty directly. A belief represented as a superposition weighted by confidence scalars, [Figure omitted from source export], maintains a probabilistic ensemble within a single vector33. As evidence accumulates, the vector smoothly rotates toward the more probable concept. Provenance and Traceability: Inspectability is preserved by appending metadata. A data hypervector is bound with a provenance metadata hypervector [Figure omitted from source export] (denoting source, timestamp, and sensory origin). Since [Figure omitted from source export], the system can transparently recover the exact lineage of any internal representation without requiring exhaustive external logging57.

5. Compositional Reasoning vs. Formal Logic

Standard deep learning architectures map input distributions to output distributions via learned weights, lacking mechanisms to guarantee that internal transformations adhere to explicit structural rules. Exact formal logic, conversely, is overly rigid; a minor sensory substitution error shatters the deductive proof. VSA introduces approximate symbolic computation. Because conceptually similar entities possess high cosine similarity ([Figure omitted from source export]), an algebraic reasoning rule encoded as a transformation matrix [Figure omitted from source export] applied to [Figure omitted from source export] will yield an output highly similar to [Figure omitted from source export] applied to [Figure omitted from source export]. VSA performs soft-unification natively. If the system encodes a logical transition rule [Figure omitted from source export], novel reasoning operates through direct binding algebra rather than exhaustive discrete search20. This soft-unification handles causal relation composition and analogy elegantly52. Given a source domain [Figure omitted from source export] and a target domain [Figure omitted from source export], an analogical mapping hypervector [Figure omitted from source export] is generated. Applying [Figure omitted from source export] to novel elements in the source domain smoothly translates them to the target ontology. This algebraic approach to analogy bypasses the need to retrain a neural network via backpropagation on millions of relational pairs, facilitating one-pass encoding and few-shot concept formation inherently absent in dense transformer architectures58.

6. Integration with Deep Architectures and Advanced Paradigms

HDC/VSA does not seek to replace deep continuous learning but to impose rigorous algebraic structure upon its latent spaces59.

6.1 Hyperdimensional Transformers (HDT) and Formal Reasoners

Recent architectural developments have merged VSA with attention mechanisms. The Hyperdimensional Transformer (HDT) replaces traditional linear algebraic operations with VSA binding, bundling, and similarity metrics3. In HDT, queries, keys, and values are generated using VSA binding matrices. Attention is calculated not via floating-point dot products followed by softmax, but via integer or binary dot-products in HD space. This paradigm treats self-attention as soft vector-symbolic unbinding, treating queries and keys as role spaces and values as fillers3. The result is massive computational acceleration on low-power edge hardware and the imposition of a formal grammar onto the attention mechanism.

6.2 Sparse Autoencoders and Hyperdimensional Probes

Evaluating the internal states of Large Language Models (LLMs) currently relies on Sparse Autoencoders (SAEs), which extract interpretable directions but often suffer from bounded feature dictionaries and unconstrained polysemanticity47. The Hyperdimensional Probe acts as a hybrid unification46. It trains a neural encoder to map an LLM's residual stream directly into a VSA proxy space. This combination allows researchers to query the LLM's latent space algebraically—extracting relational knowledge graphs directly from residual states via unbinding—overcoming the constraints of standard logit attribution and providing an interactive, verifiable inspection of machine logic65.

6.3 Embedding Arithmetic, Probabilistic Programming, and Sutra

While Word2Vec popularized vector arithmetic (e.g., King \- Man \+ Woman \= Queen), classical embedding arithmetic lacks the binding operators necessary to represent hierarchical depth58. VSA formalizes this geometry. Furthermore, domain-specific probabilistic programming languages like Sutra compile functional symbolic logic directly into tensor-operation graphs executed over frozen LLM embedding spaces, bypassing the need for end-to-end differentiable logic retraining when enforcing hard systemic constraints66.

7. Hyperdimensional Memory Systems

The integration of VSA into machine intelligence redefines memory architectures, shifting from address-based storage to associative retrieval in superposition.

• Episodic Retrieval and Event Sequences: By continuously bundling [Figure omitted from source export], the system constructs a compressed, fixed-size episodic memory trace. Retrieving a specific past event involves applying inverse permutations and unbinding the temporal context8.
• Procedural Skills: Complex state machines and finite automata are encoded by superposing valid state-transition binding operations, allowing a single procedural hypervector to govern dynamic execution10.
• Collective Communication and Machine Identity: Multi-agent systems utilize VSA for collective communication. An agent transmits a bundled hypervector representing its local knowledge graph. The receiving agent superposes this with its own memory. Because the ontological bindings are invariant, the knowledge merges flawlessly. A globally unique random hypervector serves as an immutable cryptographic Machine Identity.
• Ontology Versioning and Continual Updates: Continual learning avoids catastrophic forgetting because novel concepts are pseudo-orthogonal to all existing concepts57. If an ontology requires versioning, the entire knowledge base is bound with a Version hypervector, instantly creating a parallel, non-interfering ontological space.

8. Hardware Acceleration for Hyperdimensional Paradigms

The highly parallel, fault-tolerant nature of VSAs optimally aligns with post-von Neumann hardware fabrics4.

8.1 In-Memory Computing and Memristors

Analog In-Memory Computing (AIMC) utilizing phase-change memory (PCM) or memristor crossbar arrays executes VSA vector-matrix multiplications with exceptional energy efficiency4. AIMC avoids the von Neumann bottleneck by performing accumulation directly within the storage element. Crucially, the intrinsic stochastic device noise of nanoscale memristors—typically a critical flaw for precise deep learning—acts as a computational asset in VSA. This analog noise physically perturbs VSA Resonator Networks out of limit cycles, enabling real-time combinatorial vector factorization across problem spaces exceeding tens of millions of states11.

8.2 Neuromorphic Spiking Processors

Neuromorphic processors, such as Intel Loihi, natively support the asynchronous, distributed processing required by VSA31. The Spiking Semantic Pointer Architecture maps continuous variables to oscillatory spiking dynamics. By employing spiking-phasor neurons, the phase of a spike timing relative to a background oscillation encodes the angle of a complex FHRR vector30. This translates complex algebraic binding into simple coincidence detection among spiking neurons, enabling spatial mapping, SLAM, and associative retrieval at sub-milliwatt power budgets, ideal for autonomous edge devices31.

9. Original Contribution: The Hyperdimensional Ontology Kernel

To operationalize VSA as a native substrate between continuous learning and formal ontology, this report specifies the Hyperdimensional Ontology Kernel (HOK). HOK acts as a middleware representation layer enabling robust, verifiable, and transparent machine intelligence. By prioritizing technical recovery over content censorship, HOK ensures cognitive liberty and safe AI operation.

9.1 Kernel Specification

Hypervector Format: HOK relies on Complex-Valued Fourier Holographic Reduced Representations (FHRR), where [Figure omitted from source export] and [Figure omitted from source export]. This allows for fractional binding of continuous variables and direct compilation to spiking-phasor neuromorphic hardware. Binding Algebra:

• Role-Filler Binding: [Figure omitted from source export] (element-wise complex multiplication).
• Temporal Ordering: Phase rotation [Figure omitted from source export] shifts the phasor angles proportionally to continuous time [Figure omitted from source export].
• Uncertainty: Scaled fractional binding [Figure omitted from source export], where [Figure omitted from source export] modulates the phase angle toward [Figure omitted from source export], smoothly collapsing uncertain vectors toward the identity vector.

Type System and Collision Detection: Types are predefined orthogonal vectors ([Figure omitted from source export]). The type of any bound hypervector [Figure omitted from source export] is evaluated via cosine similarity: [Figure omitted from source export]. If the maximum similarity [Figure omitted from source export] (where [Figure omitted from source export]), an ontological collision is flagged. This triggers a technical algebraic rollback, ensuring safe failure without heuristic censorship or arbitrary content suppression. Memory Organization: A dual-memory architecture consisting of:

1. Episodic Superposition Buffer: A continuous temporal accumulator bundling streaming data: [Figure omitted from source export], where [Figure omitted from source export] implements graceful forgetting.

2. Ontological Cleanup Codebook: A hierarchical Resonator Network mapped directly onto high-density AIMC crossbar arrays.

Cleanup Strategy and Confidence Estimation: Upon unbinding, the extracted noisy vector [Figure omitted from source export] is projected to the Codebook. The output confidence is strictly the cosine similarity [Figure omitted from source export]. If confidence falls below the Shannon capacity limit threshold, HOK raises an OntologyCorruption flag, permitting explicit technical unbinding of the corrupted trace using its provenance metadata. Versioning and Cross-Agent Exchange Format: Ontology evolution is tracked by binding version hypervectors [Figure omitted from source export] to relational rules. Because operations are associative and dimensionality is fixed, agents can exchange hypervectors directly over low-bandwidth channels as dense arrays. Receiver agents project the incoming vector against their local codebook; if an unknown vector arrives, it is natively processed as a novel OOV (out-of-vocabulary) node, gracefully expanding the target ontology without retraining.

10. Required Benchmark: The VSA-Ontology Validation Suite

To empirically validate HOK against classical dense embeddings, Tensor Products, Knowledge Graphs, and Hybrid VSA-Neural frameworks, the following exhaustive benchmark protocol is established.

10.1 Evaluation Dimensions

1. Novel Role-Filler Combinations & Analogy: Provide few-shot analogical mapping tasks (e.g., extracting a translation matrix [Figure omitted from source export] from [Figure omitted from source export] to generate [Figure omitted from source export]). Metric: Soft-unification retrieval success rate vs. zero-shot Transformer baselines.

2. Deeply Nested Structures & Graph Traversal: Construct and bind topological structures up to depth [Figure omitted from source export] (e.g., [Figure omitted from source export]). Metric: Exact match retrieval accuracy during recursive unbinding tree-traversal.

3. Long Sequences & Spatial Maps: Encode continuous streams of [Figure omitted from source export] temporal events utilizing SSPs and continuous permutation. Metric: Recall fidelity and strict order-preservation under compounded superposition noise.

4. Causal Relation Composition: Combine basic logical primitives into multi-step causal chains. Metric: Accuracy of Resonator Network factorization on the final bundled consequence vector.

5. Continual Learning & Ontology Extension: Dynamically introduce [Figure omitted from source export] novel atomic concepts to the running episodic buffer without updating base codebooks. Metric: Catastrophic interference rate, measured by the accuracy drop on initially learned [Figure omitted from source export] relations.

6. Noisy Memory & Partial Corruption: Randomly zero out or bit-flip [Figure omitted from source export] to [Figure omitted from source export] of the [Figure omitted from source export] dimensions. Metric: Degradation curve of cleanup confidence (verifying robust, graceful degradation).

7. Cross-Model Transfer & Hardware Efficiency: Deploy HOK on Intel Loihi 2 and PCM memristor crossbars, transferring state vectors mid-computation. Metric: Joules per analogical inference, latency (ms), and stochastic limit-cycle escape time.

10.2 Falsifiers, Milestones, and Integration

• Falsifier 1: If the Resonator Network factorization time scales exponentially with nested topological depth [Figure omitted from source export], the VSA algebraic reduction fails to surpass classical combinatorial search, falsifying the core utility of the architecture.
• Falsifier 2: If cross-agent hypervector exchange requires non-linear re-alignment matrices greater than [Figure omitted from source export] parameters to interpret, the universal ontology premise is void.
• Implementation Milestones:
• M1: Python/PyTorch emulation of HOK demonstrating lossless [Figure omitted from source export] unbinding via block-local circular convolution.
• M2: Integration with a frozen LLM via Hyperdimensional Probes60 for exact QA-focused text generation without hallucination.
• M3: Hardware compilation targeting Spiking-Phasor neuromorphic boards utilizing time-to-spike phase encodings40.
• Website Integration Metadata: A JSON-LD schema specification linking HOK operations to existing web-based knowledge graphs (e.g., Wikidata). This ensures that URI endpoints map deterministically to atomic hypervectors, establishing a decentralized, mathematically verifiable machine semantic web.

11. Conclusion

Vector-Symbolic Architectures offer a mathematically rigorous paradigm that successfully reconciles the immense learning capacity of continuous latent spaces with the systematic, explicit rigor of formal logic. By leveraging the geometric concentration of measure in high-dimensional spaces, abstract cognitive concepts—such as role-filler binding, temporal sequencing, and probabilistic uncertainty—are reduced to native algebraic operations. Integrating HDC/VSA with modern machine intelligence—through Hyperdimensional Transformers, Sparse Block Codes, and Resonator Networks—directly addresses the critical shortcomings of dense neural networks, particularly catastrophic interference, black-box opacity, and logical hallucination. The proposed Hyperdimensional Ontology Kernel (HOK) demonstrates how these systems can be explicitly designed for transparent reasoning. Within this architecture, harmful errors and ontological violations result in calculable signal degradation and verifiable unbinding failures. This guarantees safety through precise technical recovery rather than requiring heuristic, sweeping censorship. Transitioning this architecture to analog in-memory computing and neuromorphic spiking hardware provides a scalable, energy-efficient pathway to achieving robust, inspectable, and highly systematic machine intelligence capable of true ontological reasoning.

Works cited

1. tensor-product representations \- Tal Linzen, https://tallinzen.net/media/papers/mccoy\_linzen\_dunbar\_smolensky\_2019\_iclr.pdf

2. Practical Lessons on Vector-Symbolic Architectures in Deep, https://raw.githubusercontent.com/mlresearch/v284/main/assets/carzaniga25a/carzaniga25a.pdf

3. Attention as Binding: A Vector-Symbolic Perspective on Transformer, https://openreview.net/forum?id=wQDFkHOAZc

4. (PDF) Vector Symbolic Architectures as a Computing Framework for, https://www.researchgate.net/publication/352308610\_Vector\_Symbolic\_Architectures\_as\_a\_Computing\_Framework\_for\_Nanoscale\_Hardware

5. A Theoretical Perspective on Hyperdimensional Computing, https://par.nsf.gov/servlets/purl/10322828

6. Fully Distributed Representation \- ResearchGate, https://www.researchgate.net/publication/2893240\_Fully\_Distributed\_Representation

7. Fully Distributed Representation, http://www.cap-lore.com/RWC97-kanerva.pdf

8. Theory of the superposition principle for randomized connectionist, https://www.researchgate.net/publication/318224315\_Theory\_of\_the\_superposition\_principle\_for\_randomized\_connectionist\_representations\_in\_neural\_networks

9. Fully Distributed Representation Explained | PDF | Bit \- Scribd, https://www.scribd.com/document/631477893/Bsc-Fully-Distributed-Representation-Kanerva-1997

10. Vector Symbolic Architectures and their Applications \- DiVA portal, https://www.diva-portal.org/smash/get/diva2:1197565/FULLTEXT01.pdf

11. Disentangling visual attributes with neuro-vector-symbolic, https://research.ibm.com/blog/efficient-compute-engine-visual-attributes

12. On the role of noise in factorizers for disentangling distributed, https://openreview.net/forum?id=VYryqVqQEF

13. The Emergence of Miller's Magic Number on a Sparse Distributed, https://pmc.ncbi.nlm.nih.gov/articles/PMC3016408/

14. Cellular Automata Can Reduce Memory Requirements of Collective, https://pmc.ncbi.nlm.nih.gov/articles/PMC9215349/

15. Representational recoding and capacity limits: a conceptual, https://www.frontiersin.org/journals/computational-neuroscience/articles/10.3389/fncom.2026.1878543/full

16. A Comparison of Vector Symbolic Architectures \- arXiv, https://www.arxiv.org/pdf/2001.11797v3

17. A Survey on Hyperdimensional Computing aka Vector Symbolic, https://www.diva-portal.org/smash/get/diva2:1757051/FULLTEXT01.pdf

18. Developing a Foundation of Vector Symbolic Architectures Using, https://arxiv.org/html/2501.05368v2

19. Soft Tensor Product Representations for Fully Continuous ... \- arXiv, https://arxiv.org/html/2412.04671v1

20. (PDF) Basic Reasoning with Tensor Product Representations, https://www.researchgate.net/publication/290527719\_Basic\_Reasoning\_with\_Tensor\_Product\_Representations

21. Resonator networks for factoring distributed representations of data, https://www.researchgate.net/publication/342801754\_Resonator\_networks\_for\_factoring\_distributed\_representations\_of\_data\_structures

22. Distributed Representation for Cognitive Structures, http://d-reps.org/papers/plate-hrr-book-2003.pdf

23. Variable Binding for Sparse Distributed Representations \- arXiv, https://arxiv.org/pdf/2009.06734

24. arXiv:cs/0610075v2 \[cs.AI\] 23 Oct 2006, https://arxiv.org/pdf/cs.AI/0610075

25. a 26-module cognitive architecture in 1237 lines of C \- Reddit, https://www.reddit.com/r/ControlProblem/comments/1smcje1/project\_replacing\_gemm\_with\_three\_bit\_operations/

26. HD/VSA, https://www.hd-computing.com/

27. VSA/HDC: A Working Introduction | Algebraic Intelligence, https://algebraic-intelligence.dev/blog/primers/series-001-000-vsa-primer/

28. CAPACITY ANALYSIS OF VECTOR SYMBOLIC ARCHITECTURES, https://openreview.net/pdf?id=6tazBqPem3

29. qFHRR: Rethinking Fourier Holographic Reduced Representations, https://www.researchgate.net/publication/404307654\_qFHRR\_Rethinking\_Fourier\_Holographic\_Reduced\_Representations\_through\_Quantized\_Phase\_and\_Integer\_Arithmetic

30. Neuromorphic Visual Scene Understanding with Resonator Networks, https://scispace.com/pdf/neuromorphic-visual-scene-understanding-with-resonator-thta1oal.pdf

31. Exploiting semantic information in a spiking neural SLAM system, https://pmc.ncbi.nlm.nih.gov/articles/PMC10354246/

32. A model of path integration that connects neural and symbolic, https://escholarship.org/content/qt3pf7f9b4/qt3pf7f9b4\_noSplash\_9a26d2f9661b7f7edccfc8c645d4acda.pdf

33. Bridging Cognitive Architectures and Generative Models with Vector, https://ojs.aaai.org/index.php/AAAI-SS/article/download/27686/27459/31737

34. (PDF) A comparison of vector symbolic architectures \- ResearchGate, https://www.researchgate.net/publication/357061698\_A\_comparison\_of\_vector\_symbolic\_architectures

35. Variable Binding for Sparse Distributed Representations \- PMC \- NIH, https://pmc.ncbi.nlm.nih.gov/articles/PMC12180425/

36. Implement the Generic Sparse Block Codes (GSBC) \#177 \- GitHub, https://github.com/hyperdimensional-computing/torchhd/issues/177

37. Variable Binding for Sparse Distributed Representations \- PubMed, https://pubmed.ncbi.nlm.nih.gov/34478381/

38. Sparse Vector Binding on Spiking Neuromorphic Hardware Using, https://sandamirskaya.eu/resources/ICONS\_2022\_Renner\_VSA\_Loihi\_binding.pdf

39. Hyperdimensional Computing with Spiking-Phasor Neurons \- arXiv, https://arxiv.org/pdf/2303.00066

40. Alpha Renner \- CatalyzeX, https://www.catalyzex.com/author/Alpha%20Renner

41. Vector Symbolic Architectures as a Computing Framework for ... \- PMC, https://pmc.ncbi.nlm.nih.gov/articles/PMC10588678/

42. Reasoning with TPRs TR \- arXiv, https://arxiv.org/pdf/1601.02745

43. Why permutation matters in HDC \- Hyperdimensional Computing Labs, https://hyperdimensionalcomputing.ai/blog/permutation-in-hdc

44. Designing Vector-Symbolic Architectures for Biomedical Applications, https://www.preprints.org/manuscript/202510.0117/v1/download

45. A comparative study of nonlinear cleanup rules in resonator networks, https://www.frontiersin.org/journals/artificial-intelligence/articles/10.3389/frai.2026.1793314/pdf

46. Decoding LLM Representations via Vector Symbolic Architectures, https://www.researchgate.net/publication/395972393\_Hyperdimensional\_Probe\_Decoding\_LLM\_Representations\_via\_Vector\_Symbolic\_Architectures

47. Decoding LLM Representations via Vector Symbolic Architectures, https://arxiv.org/html/2509.25045v3

48. A comparative study of nonlinear cleanup rules in resonator networks, https://www.frontiersin.org/journals/artificial-intelligence/articles/10.3389/frai.2026.1793314/full

49. Resonator Networks, 2: Factorization Performance and Capacity, https://direct.mit.edu/neco/article/32/12/2332/95653/Resonator-Networks-2-Factorization-Performance-and

50. Resonator Networks outperform optimization methods at solving, https://arxiv.org/abs/1906.11684

51. Simulating and Predicting Dynamical Systems With Spatial, https://direct.mit.edu/neco/article/33/8/2033/102625/Simulating-and-Predicting-Dynamical-Systems-With

52. Analogical mapping and inference with binary spatter codes and, https://www.diva-portal.org/smash/get/diva2:1014251/FULLTEXT01.pdf

53. (PDF) A Survey on Hyperdimensional Computing aka Vector, https://www.researchgate.net/publication/360721967\_A\_Survey\_on\_Hyperdimensional\_Computing\_aka\_Vector\_Symbolic\_Architectures\_Part\_I\_Models\_and\_Data\_Transformations

54. Resonator networks for factoring distributed representations of data, https://arxiv.org/abs/2007.03748

55. Language processing with dynamic fields \- PMC \- NIH, https://pmc.ncbi.nlm.nih.gov/articles/PMC2427059/

56. Recent Advances in Resonator Networks for Neuro-Symbolic, https://openreview.net/pdf?id=FNrZd3Ls1d

57. Neuro-Vector-Symbolic Architecture \- IBM Research, https://research.ibm.com/projects/neuro-vector-symbolic-architecture

58. Neural vector embeddings \- Dan MacKinlay, https://danmackinlay.name/notebook/nn\_vector\_embedding.html

59. Vector Symbolic Architectures as a Computing Framework for ... \- arXiv, https://arxiv.org/pdf/2106.05268

60. Decoding LLM Representations via Vector Symbolic Architectures, https://arxiv.org/abs/2509.25045

61. Hyperdimensional Transformer (HDT) \- Emergent Mind, https://www.emergentmind.com/topics/hyperdimensional-transformer-hdt

62. Capacity Analysis of Vector Symbolic Architectures | Takara TLDR, https://tldr.takara.ai/p/2301.10352

63. Week 2: Steering \- Neural Mechanics, https://neural-mechanics.baulab.info/week2.html

64. Hyperdimensional Probe: Decoding LLM Representations via Vector, https://openreview.net/forum?id=WxM7lIoGBb

65. Decoding LLM Representations via Vector Symbolic Architectures, https://huggingface.co/papers/2509.25045

66. Sutra: A Programming Language for Vector-Symbolic Computation, https://clawrxiv.io/abs/2605.02157v5

67. Sutra: A Programming Language for Vector-Symbolic Computation, https://clawrxiv.io/abs/2605.02162v5

68. \[PDF\] Hyperdimensional Computing with Spiking-Phasor Neurons, https://www.semanticscholar.org/paper/Hyperdimensional-Computing-with-Spiking-Phasor-Orchard-Jarvis/f255801d705d4c858fb5925df2113ceb3a860cbd

69. A Neuro-Vector-Symbolic Architecture for Data \- IBM Research, https://research.ibm.com/publications/a-neuro-vector-symbolic-architecture-for-data-and-compute-efficient-continual-learning-abstract-reasoning-and-combinatorial-inference

70. Resonator network papers in print, https://redwood.berkeley.edu/news/resonator-network-papers-in-print/

71. Vector Symbolic Architectures as computing framework for, https://par.nsf.gov/biblio/10486268-vector-symbolic-architectures-computing-framework-nanoscale-hardware

72. Sparse Vector Binding on Spiking Neuromorphic Hardware Using, https://core.ac.uk/outputs/529778921

73. Neuromorphic visual scene understanding with resonator networks, https://juser.fz-juelich.de/record/1028218

74. kmheckel/spyx \- Spiking Neural Networks in JAX \- GitHub, https://github.com/kmheckel/spyx