Binary Spatter Codes

BSC uses XOR binding on binary vectors {0, 1}. It's mathematically equivalent to MAP with bipolar vectors and is ideal for FPGA and low-power implementations.

Properties

When to Use

• FPGA implementation
• Ultra-low-power devices
• Bitwise operations only (no multiply)
• Maximum hardware efficiency
• When storage is measured in bits

Theory

Vector Space

BSC vectors are binary:

Each dimension is independently sampled with P(v_i = 1) = 0.5.

Relationship to MAP

BSC and MAP are equivalent via transformation:

XOR on binary = element-wise multiply on bipolar.

Binding Operation

Binding is XOR:

Self-Inverse Property

XOR is self-inverse:

Since \(b \oplus b = 0\) (identity).

Bundling Operation

Bundling uses majority vote:

Similarity Measure

BSC uses normalized Hamming distance:

Capacity Analysis

BSC has similar capacity to MAP (they are mathematically equivalent):

Code Examples

Basic Usage

from holovec import VSA

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

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

print(set(a.tolist()))  # {0.0, 1.0}

# XOR binding
c = model.bind(a, b)

# Self-inverse recovery
a_recovered = model.bind(c, b)  # or model.unbind(c, b)
print(model.similarity(a, a_recovered))  # 1.0

Conversion to/from Bipolar

# Convert binary to bipolar (for MAP compatibility)
a_binary = model.random()
a_bipolar = model.to_bipolar(a_binary)  # {0,1} → {-1,+1}

# Convert back
a_binary_again = model.from_bipolar(a_bipolar)

Hardware-Oriented Example

import numpy as np

# Pure bitwise operations
def xor_bind(a, b):
    return np.bitwise_xor(a.astype(np.uint8), b.astype(np.uint8))

def majority_bundle(vectors, threshold=None):
    if threshold is None:
        threshold = len(vectors) / 2
    summed = np.sum(vectors, axis=0)
    return (summed > threshold).astype(np.uint8)

def hamming_similarity(a, b):
    return 1 - np.sum(a != b) / len(a)

Hardware Implementation

FPGA Resources (10,000 dim)

Verilog Sketch

// XOR binding - single cycle
assign c = a ^ b;

// Popcount for similarity (parallel tree)
always @(*) begin
    hamming = 0;
    for (i = 0; i < DIM; i = i + 1)
        hamming = hamming + (a[i] ^ b[i]);
end

Comparison with Similar Models

References

• Kanerva, P. (1996). Binary Spatter-Coding of Ordered K-Tuples
• Kanerva, P. (2009). Hyperdimensional Computing

See Also

• Models Overview — Compare all models
• Model-MAP — Bipolar equivalent
• Model-BSDC — Sparse binary alternative