Holographic Reduced Representations

HRR is the classic VSA model developed by Tony Plate. It uses circular convolution for binding and circular correlation for unbinding, providing an approximate inverse.

Properties

When to Use

• Academic research and comparison baselines
• When using established VSA literature methods
• Real-valued continuous data
• When approximate recovery is acceptable

Theory

Vector Space

HRR vectors are real-valued with Gaussian distribution:

The variance scaling 1/d ensures unit expected norm.

Binding Operation

Binding uses circular convolution:

where:

Efficiently computed via FFT:

Unbinding Operation

Unbinding uses circular correlation:

This is an approximate inverse:

Recovery similarity is typically 0.65-0.75.

Why Approximate?

For random vectors:

The cross-terms don't cancel perfectly, leaving residual noise proportional to 1/√d.

Bundling Operation

Bundling is simple addition (no normalization):

HRR specifically does not normalize after bundling to preserve the magnitude relationships needed for correlation-based unbinding.

Capacity Analysis

HRR has good capacity with near-zero noise floor (Gaussian similarity):

Code Examples

Basic Usage

from holovec import VSA

# Create HRR model
model = VSA.create('HRR', dim=10000)

# Generate random hypervectors
a = model.random(seed=1)
b = model.random(seed=2)

# Bind and unbind
c = model.bind(a, b)
a_recovered = model.unbind(c, b)

# Approximate recovery
print(model.similarity(a, a_recovered))  # ~0.65-0.75

Recovery Quality vs Dimension

for dim in [1000, 5000, 10000]:
    model = VSA.create('HRR', dim=dim)
    a, b = model.random(seed=1), model.random(seed=2)
    c = model.bind(a, b)
    recovered = model.unbind(c, b)
    print(f"dim={dim}: similarity={model.similarity(a, recovered):.3f}")

Using Cleanup for Better Recovery

from holovec.retrieval import Codebook, ItemStore

# Create codebook of known items
items = {f"item_{i}": model.random(seed=i) for i in range(100)}
codebook = Codebook(items, backend=model.backend)
store = ItemStore(model).fit(codebook)

# Noisy recovery can be cleaned up
a = items["item_0"]
b = model.random(seed=999)
c = model.bind(a, b)
noisy_a = model.unbind(c, b)

# Clean up to nearest known item
result = store.query(noisy_a, k=1)
print(result[0][0])  # "item_0"

Comparison with Similar Models

Implementation Notes

FFT-Based Binding

# Efficient circular convolution
fa = np.fft.fft(a)
fb = np.fft.fft(b)
c = np.real(np.fft.ifft(fa * fb))

FFT-Based Unbinding

# Circular correlation
fa = np.fft.fft(a)
fb = np.fft.fft(b)
result = np.real(np.fft.ifft(fa * np.conj(fb)))

References

• Plate, T. A. (1991). Holographic Reduced Representations
• Plate, T. A. (1995). Holographic reduced representations: Distributed representation for cognitive structures
• Plate, T. A. (2003). Holographic Reduced Representations (book)

See Also

• Models Overview — Compare all models
• Model-FHRR — Complex version with exact inverse
• Retrieval-Overview — Cleanup strategies