Recitation 6

Prelude to vector symbolic architectures

Bohan Jiang

2026-10-09

Same words, different meaning

  • The cat chased the dog.
  • The dog chased the cat.

Same three words. Opposite meaning.

Suppose we are given three word vectors.

  • vcat=(2,1,0,0)\mathbf{v}_\text{cat} = (2, 1, 0, 0)
  • vchased=(0,0,1,1)\mathbf{v}_\text{chased} = (0, 0, 1, 1)
  • vdog=(0,1,2,0)\mathbf{v}_\text{dog} = (0, 1, 2, 0)

The simplest sentence vector adds the word vectors.

Both sentences add up to (2,2,3,1)(2, 2, 3, 1).

Question: what is the failed case?

Addition ignores order, so any three vectors give the same sum. The sum keeps which words occur but loses who did what to whom.

The words are the same, but cat is the SUBJECT of one sentence and the OBJECT of the other. These roles are the structure that the summation misses.

Attempt 1: glue the words in order

Instead of adding the word vectors, concatenate them in sentence order.

The two sentences now get different vectors. Word order is kept.

Question: does order give us the roles?

  • Both sentences say that Kay loves Jay. Yet block 1 holds Kay in one and Jay in the other, so compared block by block they look unrelated
  • The passive has 5 words and the active 3, so the two vectors do not even have the same size

Position is not role.

Side attempt: train a role labeler

Jay is loved
by Kay
→
labeler
→
SUBJECT(loved, Jay)
OBLIQUE(loved, Kay)
PASSIVE(loved)
→
one vector?
  • A trained role labeler, such as a dependency parser, reads a sentence, labels each word and marks the passive, so it can tell that Kay does the loving
  • Its output is a set of labels. Labels cannot be added, compared with a cosine, or fed into the vector tools we have built since Session 7

A labeler tells us what to encode. We still need how to encode it in a vector.

From now on the roles are given, by a labeler or by hand, just like the word vectors.

Attempt 2: one slot per role

Reserve one block of the vector for each role, and put the filler in its role’s block. Stack the blocks as rows.

Start with an empty table, one row per role.

Put each sentence’s SUBJECT in the SUBJECT row, cat on the left and dog on the right.

Both verbs are chased. Put its vector in the VERB row.

Put each sentence’s OBJECT in the OBJECT row.

  • The two hook sentences now get different tables
  • Every sentence has the same size, one row per role

Question: where does Attempt 2 break?

  • Jay moves from SUBJECT to OBJECT and Kay from OBLIQUE to ANSWER, while the meaning stays Kay loves Jay. Each construction needs new slots and gives a different table
  • How many slots do we need? SUBJECT, OBJECT, OBLIQUE, INDIRECT OBJECT, COMPLEMENT, and more. Each new role means redesigning the vector
  • Mary knows that the cat chased the dog. What goes in the OBJECT slot of knows?

A whole sentence, which is already a table. A slot made for one word vector cannot hold it.

Attempt 3: the slot table is an outer product

Look at the SUBJECT row alone. A slot number is a one-hot vector, and placing a word in that slot is an outer product.

rSUBJECT fcat⊤=(100)(2100)=(210000000000)SUBJECTVERBOBJECT \mathbf{r}_\texttt{SUBJECT}\,\mathbf{f}_\text{cat}^\top = \begin{pmatrix} 1 \\ 0 \\ 0 \end{pmatrix} \begin{pmatrix} 2 & 1 & 0 & 0 \end{pmatrix} = \begin{pmatrix} \color{#b22222}{2} & \color{#b22222}{1} & \color{#b22222}{0} & \color{#b22222}{0} \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix} \begin{array}{l} \texttt{SUBJECT} \\ \texttt{VERB} \\ \texttt{OBJECT} \end{array}

So the whole table of Attempt 2 is a sum of outer products, one per role.

Now let a role be any vector, not only a slot number. This is role-filler binding (Smolensky, 1990) r⊗f=rf⊤ \mathbf{r} \otimes \mathbf{f} = \mathbf{r}\mathbf{f}^\top The filler is the word. The role vector says where it goes.

Why the outer product and not the inner product?

  • Every pair of positions (i,j)(i, j) gives a product aibja_i b_j. That is the full grid
  • The inner product keeps only the diagonal and adds it into one number. Which positions agreed is lost
  • The outer product keeps all n2n^2 cells. Nothing is summed away
  • Cosine and attention are inner products, so they cannot keep a binding

The hook, answered by binding

S=rSUBJECT⊗fcat+rVERB⊗fchased+rOBJECT⊗fdog \mathbf{S} = \mathbf{r}_\texttt{SUBJECT} \otimes \mathbf{f}_\text{cat} + \mathbf{r}_\texttt{VERB} \otimes \mathbf{f}_\text{chased} + \mathbf{r}_\texttt{OBJECT} \otimes \mathbf{f}_\text{dog}

  • Swapping the words swaps the rows. The two sentences are now different matrices
  • Adding up the rows gives back (2,2,3,1)(2, 2, 3, 1) for both, which is exactly the information the sum kept

Question. Given only S\mathbf{S}, how do we read the SUBJECT back out?

Reading a role back

Unbinding: ask for a role

To read the SUBJECT, multiply by the SUBJECT role rSUBJECT⊤ S=(rSUBJECT⊤ rSUBJECT)⏟1 fcat⊤+(rSUBJECT⊤ rVERB)⏟0 fchased⊤+(rSUBJECT⊤ rOBJECT)⏟0 fdog⊤=fcat⊤ \begin{aligned} \mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{S} &= \underbrace{(\mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{r}_\texttt{SUBJECT})}_{1}\,\mathbf{f}_\text{cat}^\top + \underbrace{(\mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{r}_\texttt{VERB})}_{0}\,\mathbf{f}_\text{chased}^\top \\ &\quad + \underbrace{(\mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{r}_\texttt{OBJECT})}_{0}\,\mathbf{f}_\text{dog}^\top = \mathbf{f}_\text{cat}^\top \end{aligned}

  • With one-hot roles this just reads off the SUBJECT row
  • Roles need not be one-hot. Any orthonormal roles work. With rSUBJECT=(1,1,0)/2\mathbf{r}_\texttt{SUBJECT} = (1, 1, 0)/\sqrt{2} and rVERB=(1,−1,0)/2\mathbf{r}_\texttt{VERB} = (1, -1, 0)/\sqrt{2}, the matrix rows look scrambled, yet rSUBJECT⊤ S=(2,1,0,0)\mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{S} = (2, 1, 0, 0) is still cat
  • Orthonormal means each role has length 1 and is perpendicular to the others

Practice

Roles in R2\mathbb{R}^2 are rSUBJECT=(1,0)\mathbf{r}_\texttt{SUBJECT} = (1, 0) and rOBJECT=(0,1)\mathbf{r}_\texttt{OBJECT} = (0, 1). Fillers are fcat=(1,2)\mathbf{f}_\text{cat} = (1, 2) and fdog=(3,0)\mathbf{f}_\text{dog} = (3, 0). Ignore the verb.

  1. Build the 2×22 \times 2 matrix S\mathbf{S} for dog chased cat
  2. Compute rSUBJECT⊤ S\mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{S}. Who is the SUBJECT?
  1. S=rSUBJECTfdog⊤+rOBJECTfcat⊤=(3000)+(0012)=(3012)\mathbf{S} = \mathbf{r}_\texttt{SUBJECT}\mathbf{f}_\text{dog}^\top + \mathbf{r}_\texttt{OBJECT}\mathbf{f}_\text{cat}^\top = \begin{pmatrix} 3 & 0 \\ 0 & 0 \end{pmatrix} + \begin{pmatrix} 0 & 0 \\ 1 & 2 \end{pmatrix} = \begin{pmatrix} 3 & 0 \\ 1 & 2 \end{pmatrix}
  2. (1,0) S=(3,0)=fdog(1, 0)\,\mathbf{S} = (3, 0) = \mathbf{f}_\text{dog}. The SUBJECT is dog

Question: roles that are not perpendicular

  • Suppose rSUBJECT=(1,0,0)\mathbf{r}_\texttt{SUBJECT} = (1, 0, 0) but rOBJECT=(0.6,0.8,0)\mathbf{r}_\texttt{OBJECT} = (0.6, 0.8, 0), so the two roles have cosine 0.60.6
  • What do we get back when we ask for the SUBJECT of cat chased dog?

rSUBJECT⊤ S=fcat⊤+0.6 fdog⊤=(2,1,0,0)+0.6 (0,1,2,0)=(2,1.6,1.2,0) \begin{aligned} \mathbf{r}_\texttt{SUBJECT}^\top\, \mathbf{S} &= \mathbf{f}_\text{cat}^\top + 0.6\,\mathbf{f}_\text{dog}^\top \\ &= (2, 1, 0, 0) + 0.6\,(0, 1, 2, 0) = (2, 1.6, 1.2, 0) \end{aligned}

  • A blend of cat and dog. The OBJECT leaks into the SUBJECT
  • The leak is exactly the cosine between the roles

Question. A language has many roles and many words. Where can we get many vectors that are nearly perpendicular to each other?

Random vectors as symbols

Random arrows are almost perpendicular

Try the laziest answer first. Pick the vectors at random.

  • In 2-D, two random arrows can point anywhere relative to each other
  • In 1000-D, almost every pair lands near 90°, so their cosine is near 0
  • Near-perpendicular random vectors can stand for different roles without anyone designing them

Random vectors work as roles. What about the fillers?

What about the fillers?

  • So far cat, chased and dog were toy vectors we were given
  • Real fillers must carry meaning. Coffee should sit closer to tea than to laptop
  • They must also live in the same high-dimensional space as the random roles

Question. Can we build meaningful word vectors out of random vectors too?

The random indexing algorithm

Random indexing (Kanerva and Sahlgren, late 1990s) does exactly that.

  1. Give every context a random sparse index vector of length dd, mostly zeros with a few ±1\pm 1
  2. Give every word a zero vector of length dd
  3. Walk the corpus. Each time word ww appears with context cc, add cc’s index vector to ww’s vector
context cup brew morning screen battery
index vector (1,1,0,0)(1, 1, 0, 0) (0,1,0,1)(0, 1, 0, 1) (1,0,−1,0)(1, 0, -1, 0) (0,0,1,1)(0, 0, 1, 1) (0,−1,1,0)(0, -1, 1, 0)

Five contexts get squeezed into 4 numbers. In real use the vectors have d≈1000d \approx 1000 or more and thousands of contexts.

Walking a tiny corpus

Follow coffee as the corpus streams by.

event add coffee’s vector
start (0,0,0,0)(0, 0, 0, 0)
coffee, cup (1,1,0,0)(1, 1, 0, 0) (1,1,0,0)(1, 1, 0, 0)
coffee, cup (1,1,0,0)(1, 1, 0, 0) (2,2,0,0)(2, 2, 0, 0)
coffee, brew (0,1,0,1)(0, 1, 0, 1) (2,3,0,1)(2, 3, 0, 1)
coffee, morning (1,0,−1,0)(1, 0, -1, 0) (3,3,−1,1)\mathbf{(3, 3, -1, 1)}
  • We never wrote down a count. Each event is one addition
  • Do the same for tea (cup once, brew twice) and laptop (screen twice, battery once)

The count matrix PP

Write the tiny corpus as a table. A row is a word, a column is a context, and a cell counts how often the word appeared with that context.

P  =  cupbrewmorningscreenbatterycoffee21100tea12000laptop00021 P \;=\; \begin{array}{r|ccccc} & \text{cup} & \text{brew} & \text{morning} & \text{screen} & \text{battery} \\ \hline \color{#b22222}{\text{coffee}} & \color{#b22222}{2} & \color{#b22222}{1} & \color{#b22222}{1} & \color{#b22222}{0} & \color{#b22222}{0} \\ \text{tea} & 1 & 2 & 0 & 0 & 0 \\ \text{laptop} & 0 & 0 & 0 & 2 & 1 \end{array}

  • This is the count matrix from Session 7
  • The coffee row (2,1,1,0,0)(2, 1, 1, 0, 0) is the walk on the previous slide. Cup twice, brew once, morning once
  • Tea and laptop are the two walks you just did

Index matrix times count matrix

The stream computes exactly count matrix PP times index matrix RR.

cupbrewmorn.screenbatt.coffee21100tea12000laptop00021⏟P(3×5)×(1100010110−1000110−110)⏟R(5×4) \footnotesize \underbrace{\begin{array}{r|ccccc} & \text{cup} & \text{brew} & \text{morn.} & \text{screen} & \text{batt.} \\ \hline \color{#b22222}{\text{coffee}} & \color{#b22222}{2} & \color{#b22222}{1} & \color{#b22222}{1} & \color{#b22222}{0} & \color{#b22222}{0} \\ \text{tea} & 1 & 2 & 0 & 0 & 0 \\ \text{laptop} & 0 & 0 & 0 & 2 & 1 \end{array}}_{P \;(3 \times 5)} \;\times\; \underbrace{\begin{pmatrix} 1 & 1 & 0 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 0 & -1 & 0 \\ 0 & 0 & 1 & 1 \\ 0 & -1 & 1 & 0 \end{pmatrix}}_{R \;(5 \times 4)}

=coffee33−11tea1302laptop0−132⏟PR(3×4) \footnotesize =\; \underbrace{\begin{array}{r|cccc} \color{#b22222}{\text{coffee}} & \color{#b22222}{3} & \color{#b22222}{3} & \color{#b22222}{-1} & \color{#b22222}{1} \\ \text{tea} & 1 & 3 & 0 & 2 \\ \text{laptop} & 0 & -1 & 3 & 2 \end{array}}_{PR \;(3 \times 4)}

  • Each row of RR is a context’s index vector, and PP says how many times to add it. That gives coffee’s (3,3,−1,1)(3, 3, -1, 1)
  • PP itself is never stored. Only the small PRPR is

Did the cosines survive?

pair cosine of counts (55 numbers) cosine after random indexing (d=4d = 4)
coffee, tea 0.73 0.84
coffee, laptop 0.00 -0.24
tea, laptop 0.00 0.07
  • The ranking survives. Coffee is still much closer to tea than to laptop
  • But every cosine moved. With d=4d = 4 the index vectors are far from perpendicular (cup and brew have cosine 0.50.5)
  • How large must dd be before the movement becomes small?

Johnson–Lindenstrauss in a picture

  • Each dot is one pair of words. On the red line, the cosine is kept exactly
  • Johnson–Lindenstrauss (1984) says nn points need only about log⁡n/ϵ2\log n / \epsilon^2 random dimensions to keep all distances within a factor 1±ϵ1 \pm \epsilon
  • The bound depends on the number of words, not on how many contexts we started with

Roles and fillers are ready

  • Roles are random vectors. Words are random indexing vectors. Both need around a thousand dimensions to behave like distinct symbols
  • One binding rf⊤\mathbf{r}\mathbf{f}^\top is a d×dd \times d table, so d=1000d = 1000 gives 10610^6 numbers
  • And Attempt 2 left nesting open. What happens when a sentence sits inside a sentence?

A sentence inside a sentence

Mary knows [that the cat chased the dog]

  • The inner sentence is a sum of bindings, a d×dd \times d table Sinner\mathbf{S}_\text{inner}
  • That table is the OBJECT of knows, so rOBJECT⊗Sinner\mathbf{r}_\texttt{OBJECT} \otimes \mathbf{S}_\text{inner} is a cube with d3d^3 numbers
  • Mary and knows still give d×dd \times d tables, so the outer bindings no longer have the same shape and cannot be added

Each level of embedding multiplies the size by dd, so two levels deep is 101210^{12}. Question. Can we keep the binding but stop squaring the size?

Folding the binding back down

Convolution: multiply every pair, add along the diagonals

Read a=(1,2,0)\mathbf{a} = (1, 2, 0) as 1+2x1 + 2x and b=(1,0,1)\mathbf{b} = (1, 0, 1) as 1+x21 + x^2, then multiply term by term.

  • Cell (i,j)(i, j) is ai×bja_i \times b_j and lands on the power term xi+jx^{i+j}. Same power, same color
  • Adding each color gives a∗b=(1,2,1,2,0)\mathbf{a} * \mathbf{b} = (1, 2, 1, 2, 0)
  • These are the coefficients of the product 1+2x+x2+2x3+0x41 + 2x + x^2 + 2x^3 + 0x^4
  • 3 and 3 numbers in, 5 out. Ordinary convolution makes the vector longer

Question. A word has 3 numbers. What can we do to get a vector of length 3?

Solution: Group slots

Keep only 3 slots, and count the powers like hours on a 3-hour clock: 0, 1, 2, then back to 0. So x3x^3 joins slot 0 and x4x^4 joins slot 1.

  • The same nine products, grouped by slot. It folds last slide’s (1,2,1,2,0)(1, 2, 1, 2, 0) onto 3 slots, (1+2, 2+0, 1)=(3,2,1)(1 + 2,\ 2 + 0,\ 1) = (3, 2, 1)
  • 3 numbers in, 3 out, the same size as a word

Circular convolution

HRR (Plate, 1995) binds with circular convolution. The result has nn slots, and kk names one of them. (a⊛b)k⏟slot k of the result=∑i=0n−1ai⏟row i  b(k−i) mod n⏟the column that lands in slot k \underbrace{(\mathbf{a} \circledast \mathbf{b})_k}_{\text{slot } k \text{ of the result}} = \sum_{i=0}^{n-1} \underbrace{a_i}_{\text{row } i}\; \underbrace{b_{(k - i) \bmod n}}_{\text{the column that lands in slot } k}

  • Each cell shows its slot k=(i+j) mod 6{k = (i + j) \bmod 6}, the same clock as before with 6 hours
  • Slot 2 takes one cell per row, in columns 2, 1, 0, then wraps to 5, 4, 3
  • All 36 products are used, 6 per slot, and 6 numbers come out

Why “circular”?

  • Put the 6 columns on a clock. Slot 2 walks 2, 1, 0, and one more step back lands on 5, not on −1-1
  • The subscript (k−i) mod n(k - i) \bmod n is that clock. Row 3 of slot 2 uses column (2−3) mod 6=5(2 - 3) \bmod 6 = 5
  • Nothing falls off the edge, so every slot gets exactly nn products and the result keeps nn numbers

Binding as a walk around the ring

Put b=(1,0,1)\mathbf{b} = (1, 0, 1) on a clock with 3 slots. Each entry aia_i of a=(1,2,0)\mathbf{a} = (1, 2, 0) says turn b\mathbf{b} clockwise by ii slots and scale it by aia_i.

  • Adding the rotated copies gives a⊛b=(1,0,1)+(2,2,0)+(0,0,0)=(3,2,1)\mathbf{a} \circledast \mathbf{b} = (1, 0, 1) + (2, 2, 0) + (0, 0, 0) = (3, 2, 1)
  • So the binding is a walk of b\mathbf{b} around the ring, weighted by a\mathbf{a}. The result stays on a ring of nn slots

The hook, answered by HRR

S=rSUBJECT⊛fcat+rVERB⊛fchased+rOBJECT⊛fdog \mathbf{S} = \mathbf{r}_\texttt{SUBJECT} \circledast \mathbf{f}_\text{cat} + \mathbf{r}_\texttt{VERB} \circledast \mathbf{f}_\text{chased} + \mathbf{r}_\texttt{OBJECT} \circledast \mathbf{f}_\text{dog}

  • Every vector has d=1024d = 1024 random entries, roles included. S\mathbf{S} also has just 1024 numbers
  • The two sentences are now different vectors. They share only the verb binding, about a third of each

Undoing one turn

Binding with r\mathbf{r} turned the filler f\mathbf{f} forward. Unbinding must turn it back.

  • r=(0,1,0)\mathbf{r} = (0, 1, 0) is one turn by 1. Turning back 1 is the same as turning by 2 on 3 slots, so r∗=(0,0,1){\mathbf{r}^* = (0, 0, 1)}
  • The rule moves the weight on turn ii to turn −i-i. This r∗\mathbf{r}^* is the involution of r\mathbf{r}

Undoing a mix of turns

Now r=(1,2,0)\mathbf{r} = (1, 2, 0) and r∗=(1,0,2)\mathbf{r}^* = (1, 0, 2). Pair up their turns.

from r\mathbf{r} then from r∗\mathbf{r}^* weight net turn
no turn (1) no turn (1) 1 × 1 = 1 0
turn 1 (2) back 1 (2) 2 × 2 = 4 0
turn 1 (2) no turn (1) 2 × 1 = 2 1
no turn (1) back 1 (2) 1 × 2 = 2 2
  • Group by net turn. r∗⊛r=(5,2,2)\mathbf{r}^* \circledast \mathbf{r} = (5, 2, 2) is one combined recipe. A perfect undo would be (1,0,0)(1, 0, 0)
  • With f=(2,1,0)\mathbf{f} = (2, 1, 0) we get (12,9,6)=5 f+2 (f turned 1)+2 (f turned 2)(12, 9, 6) = 5\,\mathbf{f} + 2\,(\mathbf{f} \text{ turned } 1) + 2\,(\mathbf{f} \text{ turned } 2). Mostly f\mathbf{f}, plus blur
  • Question. Matched pairs add squares. What about the rest when dd is large?

Unbinding gives a noisy copy

To ask for the SUBJECT, bind the sentence with rSUBJECT∗\mathbf{r}^*_\texttt{SUBJECT}.

  • Each leftover is small, but there are d−1d - 1 of them.
  • The blur points away from every word, so comparing it with every word we know (a clean-up memory) still picks out cat

How blurred, and how to fix it

Cosine between the recovered filler and the right one, for a single bound pair.

d=64d = 64 d=1024d = 1024 d=4096d = 4096
random role vector 0.732 0.709 0.708
unitary role vector 1.000 1.000 1.000
  • Random roles are stuck near 1/2≈0.7071/\sqrt{2} \approx 0.707 for every dd
  • Unitary roles leave no leftovers
  • Question. One binding now comes back exactly, but a sentence is a sum of several bindings into one vector. What happens to each one as we add more?

Superposition and the noise floor

  • With kk bindings in one vector, each comes back with cosine 1/k1/\sqrt{k}, whatever dd is
  • The noise floor is how high a wrong word appears by chance
  • A binding can be read back while its signal stays 5 times above the floor. Each dot marks where that stops

Adding bindings lowers the signal, adding dimensions lowers the noise, and capacity is where they meet.

Question: how many bindings fit in one vector?

dd 64 256 1024 4096 16384
bindings retrievable 3 14 71 228 880
  • Capacity grows linearly in dd. Multiply dd by 16 and you hold about 12 times more
  • This is why VSA is also called hyperdimensional computing, with d≈10,000d \approx 10{,}000
  • Distributional vectors use d≈300d \approx 300, chosen so classifiers work. VSA dimensions are chosen so symbols do not collide

Practice

Use the clock picture with n=3n = 3. Let a=(1,0,2)\mathbf{a} = (1, 0, 2) and b=(0,1,1)\mathbf{b} = (0, 1, 1).

  1. Fill in the 3×33 \times 3 grid of products aibja_i b_j
  2. Add up the cells with the same (i+j) mod 3(i + j) \bmod 3 to get a⊛b\mathbf{a} \circledast \mathbf{b}
  1. Rows are (0,1,1)(0, 1, 1), (0,0,0)(0, 0, 0) and (0,2,2)(0, 2, 2)
  2. Slot 0 gets 0+0+2=20 + 0 + 2 = 2, slot 1 gets 1+0+2=31 + 0 + 2 = 3, slot 2 gets 1+0+0=11 + 0 + 0 = 1. So a⊛b=(2,3,1)\mathbf{a} \circledast \mathbf{b} = (2, 3, 1)
  3. Check with polynomials. (1+2x2)(x+x2)=x+x2+2x3+2x4(1 + 2x^2)(x + x^2) = x + x^2 + 2x^3 + 2x^4, and x3=1x^3 = 1 turns it into 2+3x+x22 + 3x + x^2

Discussion

Back to the hook

Can the representation tell cat chased dog from dog chased cat?

operation tells them apart? size unbinding
adding words a+b\mathbf{a} + \mathbf{b} no nn none
gluing in order (a,b)(\mathbf{a}, \mathbf{b}) by position only grows with the sentence by position
inner product a⋅b\mathbf{a} \cdot \mathbf{b} no 1 none
TPR ab⊤\mathbf{a}\mathbf{b}^\top yes n2n^2 and growing exact
HRR a⊛b\mathbf{a} \circledast \mathbf{b} yes nn approximate
  • TPR pays in size. HRR pays in exactness
  • Both pay nothing for the roles themselves, since random high-dimensional vectors are already nearly perpendicular

The choice

reduces by compares or composes with
Distributional semantics finding structure (SVD, SGNS, GloVe) the inner product
VSA random projection, which finds nothing a folded outer product
  • Distributional semantics gets similarity for free but cannot compose
  • VSA composes but has no graded similarity beyond what you put in