Concepts

Learn the basics

Hyperdimensional computing turns roles, values, and associations into high-dimensional hypervectors. Once they're in the same space, binding, bundling and permutation let us compose, retrieve and compare them. On this page, we'll demonstrate how that works with a simple example.

01 EncodeA role, value or record becomes a hypervector
02 ComposeSimple algebra preserves (and recovers) structure
03 RetrieveCosine similarity finds what's relevant

Example

A simple dataset

Let's begin with a simple dataset of connected entities. Maya and Noah are two people who know each other. Each has a name, an age, and a list of interests, and they share two interests. We'll use this example to explore encoding, composition, and associative search.

M Person 1

Maya

name: “Maya”
age: 29
interests: sports music hiking

N Person 2

Noah

name: “Noah”
age: 32
interests: music hiking photography

(Maya) -[KNOWS]→ (Noah)

The highlighted labels indicate a connection or overlap. We aren't adding a special “similar people” field. Instead, we'll let the encoded representation capture that overlap for us.

Step 1 · encode

Transform roles, values, and entity records into the same space

An encoder is an adapter that transforms raw data into hypervectors. It accepts the different types in our data and returns a hypervector with the specified dimensionality. Here we'll use 10,000 dimensions. The output shape remains fixed, whether the input is one string, one number, or a whole list.

Strings

Stable identities

A deterministic mapping assigns “Maya” or “music” the same random-looking hypervector every time. Hypervectors for different strings begin almost orthogonal, so accidental collisions are unlikely.

E("music") → v_music

Numbers

Nearby stays nearby

Encoders can model ordinal values by changing the hypervector gradually across a range. Ages 29 and 32 stay similar, while ages 29 and 82 are much farther apart.

cos(E(29), E(32)) = 0.97

Lists

Many become one

Encode each item, then add the hypervectors together. The resulting bundle remains similar to every item in the list, so membership is still visible through cosine similarity.

E([a,b,c]) = E(a) ⊕ E(b) ⊕ E(c)

Why use so many dimensions?

There’s space to keep things distinct

In a very high-dimensional space, two random hypervectors are near-orthogonal. Their cosine similarity is near zero. Across the 500 deterministic random pairs used here, the mean cosine similarity is -0.001. Unrelated hypervectors have similarity near zero, so shared structure produces a clear signal.

E(“music”) · first 44 hypervector values d = 10,000

E(“hiking”) · first 44 hypervector values cos = -0.01

What the hypervector actually contains

An array of numbers

The strips shown above are visual shorthand. In practice, a person's hypervector is an array with 10,000 values. Here, each value is bipolar: either −1 or +1. Other HDC models use binary values (0 or 1) or real-valued numbers (floats). In every case, the same broad concepts can be represented and manipulated in the same high-dimensional space using simple operations.

P_Maya = [ −1+1+1−1−1−1−1+1+1−1+1−1−1+1−1−1 … ]

P_{Maya} \in {- 1, + 1}^{10, 000}

first 16 of 10,000 values shown

Step 2 · compose

Combining binding, bundling and permutation

Binding attaches roles to values. Each role–value pair in the metadata gets its own hypervector. For example, “Maya” is bound to the name role, 29 to age, and “hiking” to interest. Bundling then collects those facts. Permutation lets us preserve position or order. We'll use it when we encode who knows whom. We can compose all three operations.

Bind · associate

Attach a field to its value

⊗

Binding is elementwise multiplication. The result is dissimilar from either input. Because bipolar binding is self-inverse, we can recover a value by binding the result with its role again.

f_{music} = r_{interest} \otimes v_{music}

role interest

value music

bound fact interest ⊗ music

Bundle · collect

Keep several facts together

⊕

Bundling is elementwise addition. The resulting hypervector remains similar to each input hypervector. We threshold the sum back to a bipolar hypervector to keep its shape convenient.

P_{Maya} = sign (f_{1} \oplus f_{2} \oplus \dots \oplus f_{5})

fact 1 name ⊗ Maya

fact 3 interest ⊗ sports

person hypervector P_Maya

Permute · order

Encode position and order

Permutation shifts the values in a hypervector using a fixed, reversible pattern. In our example, we'll use it to give Maya, KNOWS, and Noah different positions before we bind them. This lets us distinguish “Maya knows Noah” from “Noah knows Maya.” If we apply the same permutation to two hypervectors, their similarity stays the same. However, a hypervector and its permuted form will usually be dissimilar.

ρ (h v) = [h v_{D}, h v_{1}, h v_{2}, \dots, h v_{D - 1}]

cos (ρ (a), ρ (b)) = cos (a, b)

The complete record of a "person" in hypervector space

P_{Maya} = (r_{n} \otimes v_{Maya}) \oplus (r_{a} \otimes v_{29}) \oplus (r_{i} \otimes v_{sports}) \oplus (r_{i} \otimes v_{music}) \oplus (r_{i} \otimes v_{hiking})

Every term has the same width, and the finished person hypervector still has 10,000 elements. The representation doesn't grow when we add fields. Each field's value, no matter its type, retains its signal and shares the same space.

Step 3 · retrieve

Search by similarity

Suppose we want to search for a person around age 30 who enjoys music and hiking. We encode that description with the same roles and values, then compare it with each stored person using cosine similarity.

q = (r_{i} \otimes v_{music}) \oplus (r_{i} \otimes v_{hiking}) \oplus (r_{a} \otimes v_{30})

cos (q, p) = \frac{q \cdot p}{∥ q ∥ ∥ p ∥}

The key difference between this approach and traditional vector search is how the hypervector representation is created. Traditional vector search usually compares learned, opaque embeddings of whole items. Here, we build the query hypervector from explicit roles and values. Each shared value, such as an age range or interest, contributes to the score, so the result is composed from the structure we encoded.

Query

age ≈ 30 · music · hiking

cosine ↑

Maya 29 · music · hiking

0.65

Noah 32 · music · hiking

0.65

Distant baseline 78 · no shared interests

0.08

unrelatedcos ≈ 0No encoded structure in common

partly related0 < cos < 1Some roles and values agree

same hypervectorcos = 1All corresponding values match

Beyond entity metadata

Modeling connected data

We already have hypervectors for the persons Maya and Noah. HDC lets us also give the relationship predicate KNOWS its own hypervector. Before we bind the triple, we leave Maya as-is, permute KNOWS once and Noah twice. This gives each part a different position. The whole triple becomes one hypervector.

MsubjectP_Maya

⊗

Kpredicateρ(R_KNOWS)

⊗

Nobjectρ²(P_Noah)

one relationship hypervector T_Maya,KNOWS,Noah

T = P_{Maya} \otimes ρ (R_{KNOWS}) \otimes ρ^{2} (P_{Noah})

Query the relationship

Who does Maya know?

We can bind the stored triple with the parts we know. Maya and the permuted KNOWS hypervector cancel out, leaving Noah in the object's position. We then reverse that permutation to recover the hypervector for Noah.

ρ^{- 2} (T \otimes P_{Maya} \otimes ρ (R_{KNOWS})) = P_{Noah}

Recovered object

Noah

cos(recovered, P_Noah) = 1.00

Where this leads

From search to associative memory

We've seen how to use associative search to find the most similar hypervector to a given query. The same representation can also learn from examples. Using the fixed encoder, we transform a small number of new data samples into hypervectors, then bundle the hypervectors for examples with the same label into a prototype.

New samples are classified by similarity to those prototypes, which together form an associative memory. The learning is online: each arriving sample is encoded on the fly and added to its prototype. This form of learning is different from deep learning, which typically learns its encoder during a separate training phase. With HDC, the encoder stays fixed and only the prototypes change.

01encodea few labeled samples

→

02bundleone prototype per class

→

03comparefind the nearest prototype

A prototype accumulates what its examples share while smoothing away their individual differences. It can begin with one or a handful of samples, grow one update at a time, and remain immediately usable between updates. We don't need to retrain on the full dataset whenever a new example arrives.

Contact

Have a representation problem in mind?

We're actively helping teams push the boundaries of what's possible, aligning real-world use cases with where these techniques best fit. The applications of HDC are broad and varied, from associative search to memory and efficient online learning systems.

Get in touch

We usually reply within two business days.