Sub-symbolic networks are good at perception and hopeless at bookkeeping; symbolic logic is the reverse. Hyperdimensional computing bridges them by giving every discrete symbol a wide random hypervector — ten thousand bits — and a small algebra that binds, bundles and compares those vectors. A whole structured record lives in one vector of the same width, and any field can be read back out by nearest-match. SC-NeuroCore uses this as its reasoning substrate, and wraps every inference in a machine-checkable trace. The demo below builds a record and recovers a field from it, running the library's exact operations in your browser.
Draw two random binary vectors of width $D=10{,}000$ and they are almost certainly near-orthogonal: about half their bits differ, so their similarity sits near zero. That near-orthogonality is the whole trick — there is room for enormous numbers of distinct symbols that barely interfere. On top of it sit three operations. Bind ties two symbols together with a bitwise XOR; it is its own inverse, so binding twice returns the original. Bundle superposes several vectors by a majority vote, producing a vector similar to all of its inputs at once. Permute cyclically rotates the bits to stamp a position. Similarity is just one minus twice the normalised Hamming distance.
A key: ⊗ is XOR binding, ⊕ is majority-vote bundling, and $\lVert\cdot\rVert_1$ counts set bits. Because bind is self-inverse, a record built as SHAPE⊗CIRCLE can be interrogated with SHAPE to leave CIRCLE behind. Bundling many bindings into one vector adds noise but preserves enough similarity that the right filler still wins a nearest-match against a clean library.
Assign a filler to each role. The record is R = ⊕ᵢ (roleᵢ ⊗ fillerᵢ) — one vector holding every pair. Pick a role to recover: the demo computes role ⊗ R and ranks its similarity to every filler in the library.
With the default three-pair record the correct filler comes back at a similarity near $0.49$ while every distractor sits near zero — a wide, unambiguous margin even though the record is a single vector no larger than one symbol. Recovery is approximate: majority-vote bundling agrees with each bound pair at roughly three positions in four, so the recovered vector is a noisy copy, not an exact one. High dimension is what turns that noisy copy into a reliable answer. Drop to a two-pair record and the bundle degenerates to an intersection — density falls by half and the margins tighten — which is exactly why bundling favours an odd number of terms.
A symbol becomes a vector through a fixed hash, not a lookup table: the SHA-256 of the symbol name seeds a pseudo-random generator, so encode("CIRCLE") yields the same ten-thousand-bit vector on every machine and every run. Sequences add position with the permute operation — the $k$-th symbol from the end is rotated by $k$ before it is bound — so (A, B) and (B, A) land in different places. Nothing about the mapping is learned or opaque; it can be recomputed and checked from the name alone.
| Operation | Definition | Property |
|---|---|---|
| encode(s) | SHA-256(s) → seed → random $\{0,1\}^{D}$ | deterministic, reproducible |
| bind $a\otimes b$ | bitwise XOR | self-inverse, similarity-destroying |
| bundle $\oplus$ | majority vote across $N$ vectors | similar to every input |
| permute | cyclic bit rotation by $k$ | encodes order / position |
| similarity | $1-2\,d_H$ | $1$ identical, $\approx 0$ unrelated |
Vec<u64> layout as the neuro_symbolic Rust crate — so bind is a word-wise XOR and popcount runs over whole words at a time. The Python class is a bit-compatible fallback for when the compiled FFI library is not present; both produce identical vectors and identical Hamming distances, which is what lets the demo on this page reproduce the library's numbers exactly. The default width of ten thousand bits is Kanerva's canonical figure: large enough that random vectors are reliably near-orthogonal, small enough to stay cheap.A recovered symbol on its own is a guess. SC-NeuroCore pairs each neuro-symbolic result with a self-verification trace — a small set of machine-checkable obligations, each either passing or failing with its own evidence, digested into a stable hash for audit. The reasoning layer records, step by step, which symbol it matched, by which operation, at what similarity, and with what confidence; the confidence is read directly off the Hamming margin between the best and second-best candidate, so a narrow win is reported as low confidence rather than hidden.
| Obligation | Checks | Passes when |
|---|---|---|
| shape | observation vs. prediction dimensionality | shapes agree |
| prediction error | residual of the reconstructed observation | residual $\le 10^{-6}$ |
| SC signature | the error signature's bits are well-formed | signature valid |
| reasoning trace | the trace is finalised and non-empty | complete |
| symbol scores | ranked similarities are ordered and in range | monotone, bounded |
The trace is versioned and JSON-serialisable, and it passes only when every obligation passes; a single failed check names itself. That turns a distributed, sub-symbolic answer into something a downstream system — or a person — can inspect and reject, which is the property a bare embedding never offers.
The neuro-symbolic layer is the reasoning tier above the spiking substrate. Predictive-coding layers turn observations into prediction errors; those errors are encoded into hypervectors and matched against a symbol library; the match, its trace and its obligations flow onward as an auditable result. It is the point where a neuromorphic system stops merely reacting and starts keeping structured, checkable state.
Evidence boundary: the demo runs the library's exact hypervector algebra — XOR bind, majority-vote bundle and normalised-Hamming similarity — on the real ten-thousand-bit symbol vectors produced by the library's deterministic encoder, embedded on this page. Every similarity it shows was cross-checked bit-for-bit against the Python library on the same inputs before publishing. Hyperdimensional computing is a research-tier capability; the figures describe the operations' mathematics, not a benchmark of a deployed reasoning system.