qFHRR: Rethinking Fourier Holographic Reduced Representations through Quantized Phase and Integer Arithmetic

The paper introduces qFHRR, a quantized phase formulation of Fourier Holographic Reduced Representations that replaces floating-point arithmetic with integer-only modular operations to significantly reduce memory footprint and enable efficient hardware implementation while preserving the algebraic properties and high-fidelity similarity structure of the original complex-valued framework.

The Gist

Imagine you have a massive library of information, and instead of using books, you store everything in giant, multi-colored spinning tops. In the world of computer science, this is called Fourier Holographic Reduced Representations (FHRR).

Here's how the old system works:
Each "top" (or data vector) has thousands of tiny dials. To store a piece of information, you set each dial to a specific angle on a circle (like a clock face). To combine two pieces of information (like "Red" + "Apple"), you spin the dials of both tops and add their angles together. To separate them later, you subtract the angles.

The Problem:
The old way requires these dials to be incredibly precise. Computers have to use complex, heavy-duty math (floating-point numbers) to calculate these exact angles. This is like trying to build a robot that can only work if it has a supercomputer in its brain. It uses a lot of energy, takes up a lot of memory, and is hard to build on small, cheap chips (like those in smartwatches or sensors).

The Solution: qFHRR
The authors of this paper introduced qFHRR (Quantized FHRR). Think of this as replacing the infinite, smooth clock face with a simple, numbered dial.

Instead of allowing the dial to point to any angle (like 12.345 degrees), qFHRR says, "Let's just pick from a fixed list of 8, 16, or 32 specific spots."

• Old Way: "Point the dial to exactly 12.345 degrees." (Requires complex math).
• New Way: "Point the dial to Spot #3." (Requires simple counting).

How It Works in Everyday Terms:

1. The "Lego" Analogy for Math:
   In the old system, combining information was like mixing two liquids in a beaker; you need precise scales and chemistry to get the result right.
   In the new qFHRR system, combining information is like snapping Lego bricks together. You just add the numbers on the bricks. If you have a "3" brick and a "5" brick, you get an "8" brick. If you go past the limit (say, the dial only has 8 spots), you just wrap around to the beginning (like a clock going from 12 back to 1). This is called modular arithmetic, and it's something even a simple calculator can do instantly without needing a supercomputer.

2. The "Menu" Analogy for Similarity:
   To check if two pieces of information are similar, the old system had to do a complex trigonometry dance.
   The new system uses a Look-Up Table (like a restaurant menu). Instead of calculating the distance between two angles, the computer just looks up the answer in a pre-written list. "If I have Spot #3 and Spot #5, the similarity score is X." No math required, just reading.

What Did They Find?
The researchers tested this new "numbered dial" system against the old "precise angle" system:

• It's Tiny: They managed to shrink the data size by over 90%. Instead of needing 64 bits (a huge chunk of memory) for every piece of data, they could get away with just 3 or 4 bits. That's like shrinking a full HD movie down to a tiny thumbnail without losing the plot.
• It's Accurate: Even with such a small, simple dial (only 8 spots), the system worked almost perfectly. It could still combine and separate information just as well as the complex version.
• It Keeps the Map: The paper tested if this system could remember where things are in space (like remembering where a cup, a book, and a pen are on a table). Even with the simplified dials, the system kept the "spatial map" intact. It knew the cup was close to the book and far from the pen, just like the complex version did.

Why This Matters (According to the Paper):
The paper claims this isn't just a math trick; it's a way to make these powerful memory systems run on hardware that doesn't have supercomputers. By switching from "complex math" to "simple integer counting," they make it possible to put this kind of smart memory into devices that are small, cheap, and energy-efficient.

In Summary:
The paper takes a high-tech, math-heavy way of storing information and simplifies it into a "counting game." They proved you don't need a super-precise, expensive engine to drive a car; sometimes, a simple, efficient gear system works just as well and fits in a much smaller box.

Technical Summary

1. Problem Statement

Fourier Holographic Reduced Representations (FHRR) are a prominent Vector Symbolic Architecture (VSA) framework used for encoding structured information using high-dimensional, complex-valued hypervectors. While FHRR offers powerful algebraic properties for compositional memory and spatial reasoning, it relies on floating-point arithmetic and continuous phase representations.

• Limitations: This reliance creates significant overhead in terms of memory bandwidth, energy consumption, and hardware complexity, making FHRR inefficient for resource-constrained environments (e.g., neuromorphic hardware, FPGAs, edge devices).
• Goal: The authors aim to develop a formulation of FHRR that preserves its algebraic structure and geometric properties but enables integer-only computation, thereby reducing memory footprint and eliminating the need for floating-point units.

2. Methodology: Quantized FHRR (qFHRR)

The authors propose qFHRR, a discrete phase formulation that reparameterizes the continuous complex domain into a finite set of integer phase indices.

Core Representation

• Discretization: Instead of representing a dimension as a continuous complex phasor $z_i = e^{j\theta_i}$ where $\theta_i \in [0, 2\pi)$, qFHRR maps each dimension to a discrete integer index $q_i \in \{0, 1, \dots, K-1\}$.
• Mapping: The phase is defined as $\theta_i = \frac{2\pi q_i}{K}$, where $K$ is the number of phase bins. This creates a quantized approximation of the unit circle.

Implementation of Core Operations

The paper demonstrates how standard VSA operations are transformed into integer arithmetic and lookup table (LUT) operations:

1. Binding (Multiplication):

   • Standard FHRR: Element-wise complex multiplication (phase addition).
   • qFHRR: Modular integer addition.
   • Formula: $r_i = (q_{a,i} + q_{b,i}) \mod K$.

2. Unbinding (Division/Conjugate):

   • Standard FHRR: Element-wise complex conjugate multiplication (phase subtraction).
   • qFHRR: Modular integer subtraction.
   • Formula: $\hat{q}_{a,i} = (r_i - q_{b,i}) \mod K$.

3. Similarity (Dot Product):

   • Standard FHRR: Cosine similarity (Real part of inner product).
   • qFHRR: Computed as the mean cosine of phase differences. Since the phase difference is an integer, the cosine values are retrieved via a precomputed Lookup Table (LUT) indexed by $(q_{a,i} - q_{b,i}) \mod K$.

4. Bundling (Addition):

   • Challenge: Vector addition is not closed under modular arithmetic.
   • Solution: The process involves:
     1. Mapping integer indices to Cartesian coordinates $(x, y)$ using sine/cosine LUTs (scaled by an integer factor $\alpha$).
     2. Accumulating the $x$ and $y$ components (integer addition).
     3. Projecting the resulting vector back to the nearest quantized phase bin using an integer-only CORDIC algorithm (to approximate atan2) and rounding.

3. Key Contributions

• Integer-Only Algebra: Introduction of qFHRR, which preserves the underlying algebraic structure of complex FHRR while enabling implementation using only modular arithmetic, integer accumulation, and LUTs.
• Hardware Efficiency: Elimination of floating-point complex multiplication and explicit trigonometric evaluations, making the framework suitable for neuromorphic and FPGA systems.
• Bit-Width Reduction: Demonstration that high-fidelity representations can be achieved with drastically reduced bit-widths (as low as 3–4 bits per dimension) compared to the standard 64-bit complex representation.
• Spatial Structure Preservation: Proof that qFHRR maintains the spatial similarity structure induced by fractional binding (phase scaling), allowing for accurate multi-object memory encoding and retrieval despite quantization.

4. Results

The authors evaluated qFHRR against the complex FHRR baseline across operator-level fidelity and representation-level spatial encoding.

• Quantization Fidelity:

  • Similarity between qFHRR and complex FHRR increases monotonically with phase resolution ($K$).
  • Low Bit-Width Performance: At $K=8$ (3 bits/dimension), binding similarity exceeds 0.94 and bundling similarity exceeds 0.91, representing a ~95% reduction in representation size.
  • Diminishing Returns: Beyond $K=16$ (4 bits), the performance approaches near-perfect agreement (similarity > 0.98) with the complex baseline.

• Spatial Encoding (Fractional Binding):

  • The system was tested on a multi-object spatial memory task.
  • Qualitative: Even at low resolution ($K=8$), qFHRR successfully preserved the location of peak responses and the surrounding similarity gradients.
  • Quantitative: Root Mean Squared Error (RMSE) between quantized and complex similarity maps decreased as $K$ increased. Crucially, the peak response location remained stable across quantization levels, proving the preservation of compositional structure.

5. Significance and Impact

• Scalability: qFHRR offers a scalable alternative to complex FHRR, significantly reducing memory footprint and enabling deployment on hardware where floating-point units are unavailable or too power-hungry.
• Neuromorphic Compatibility: The discrete phase index formulation aligns naturally with spiking neural networks where phase is encoded via spike timing, bridging the gap between algebraic VSAs and biological/neuromorphic plausibility.
• Practical Deployment: By enabling efficient integer arithmetic, qFHRR facilitates the integration of structured, compositional AI models into edge devices, IoT sensors, and specialized neuromorphic chips without sacrificing the ability to perform complex reasoning or spatial mapping.

In conclusion, the paper establishes that quantization does not necessarily degrade the algebraic or geometric utility of FHRR. By shifting from continuous complex numbers to discrete phase indices, qFHRR achieves a highly efficient, hardware-friendly representation that retains the core strengths of vector symbolic architectures.