Represent every concept — a name, a role, a value — as one enormous random binary vector, say 10,000 bits wide. In that space two random vectors are almost always near-orthogonal, so a handful of simple bitwise operations — bind, bundle, permute — become a full symbolic algebra that is robust to noise and maps onto trivial hardware. This is hyperdimensional computing (Kanerva), also called a vector symbolic architecture.
Assign each atomic symbol a fresh random hypervector. The counter-intuitive fact that makes everything work is the concentration of measure: in a space of thousands of dimensions, two independently drawn vectors agree on almost exactly half their bits — a normalised Hamming similarity near $0.5$ — and the chance of a large accidental overlap is astronomically small. So "unrelated" is the default, and any measured similarity above chance is meaningful. Meaning is holographic: it is spread evenly across all the bits, so damaging or dropping many of them barely moves the vector.
Each green bar is a bundled symbol's similarity to the bundle; the purple bar is an unrelated symbol. As you bundle more items the members stay clearly above the $0.5$ noise floor — until capacity runs out and they sink into it. Shrink the dimension and that happens sooner.
To say "this role has this filler" — capital = Paris — you bind the two hypervectors with a bitwise XOR. The result is a new vector that is near-orthogonal to both inputs, so a binding is unmistakably different from its parts. XOR is its own inverse, so binding again with the same key unbinds — that is how you later ask "what was the capital?".
To hold a set — a whole record, or a collection of features — you bundle the hypervectors by majority vote per bit. The bundle stays similar to every ingredient, so you can test membership by similarity. Unlike binding, bundling deliberately keeps the parts recognisable.
Bundling is a set — it forgets order. To encode a sequence, permute each element by a fixed amount for its position (a cyclic shift) before bundling. The shift is invertible and near-orthogonalising, so "A then B" becomes distinguishable from "B then A".
Unbinding a field from a bundled record returns a noisy hypervector, not the exact original. The final step is clean-up: compare that noisy vector against an item memory of the known atomic symbols and snap it to the nearest one. Because unrelated symbols sit near $0.5$ and the true match sits well above it, the nearest neighbour is unambiguous.
Everything above rests on one property of large spaces: near-orthogonality. Random vectors are overwhelmingly likely to be dissimilar, the similarity of unrelated items concentrates tightly around $0.5$ with spread $\propto 1/\sqrt{D}$, and information is spread holographically so no single bit is load-bearing. That is what makes HDC robust to noise and hardware faults — and cheap, because the operations are XOR, majority and popcount.
Bind is XOR, bundle is a majority (a popcount and a compare), clean-up is a nearest-Hamming search — every operation is bitwise and embarrassingly parallel. That is why a vector symbolic architecture is one of the cheapest ways to put symbolic reasoning on an FPGA, and why it sits naturally alongside the stochastic and spiking primitives elsewhere in this section.
| Operation | Bitwise form | Result is… | Used for |
|---|---|---|---|
| Bind $\otimes$ | XOR | dissimilar to both inputs | role–filler association |
| Bundle $\oplus$ | majority | similar to every input | sets, records, prototypes |
| Permute $\rho$ | cyclic shift | dissimilar, invertible | order, sequences, $n$-grams |
| Similarity | popcount of XNOR | scalar in $[0,1]$ | matching, clean-up |
Further reading. Kanerva, P. (2009) Hyperdimensional computing: an introduction to computing in distributed representation with high-dimensional random vectors, Cognitive Computation. Plate, T. (2003) Holographic Reduced Representations. Rahimi, A. et al. (2016) A robust and energy-efficient classifier using brain-inspired hyperdimensional computing. For the terminology, see the SC-NeuroCore glossary.
The demo runs a real binary hypervector algebra in your browser at the chosen dimension; the on-device implementation uses the same operations at $D=10{,}000$ with a seeded item memory.