# The Convergence of Fast Weights, Linear Attention, and State Space Models

December 19, 2025 5-minute read

Modern Large Language Models (LLMs) are dominated by the Transformer architecture. However, as context windows grow, the computational cost of the Transformer’s attention mechanism has become a primary bottleneck. Recent discussions in the AI community—most notably by Geoffrey Hinton—have highlighted a theoretical link between biological memory mechanisms (“Fast Weights”) and efficient engineering solutions like Linear Transformers and State Space Models (SSMs).

This article explores the mathematical equivalence between Hinton’s concept of Fast Weights as Associative Memory and the recurrence mechanisms found in models such as Mamba and RWKV.

## 1. The Standard Transformer Bottleneck Link to heading

To understand the motivation for Fast Weights, one must first identify the inefficiency in standard Transformers. The core operation is Self-Attention, defined as:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d}}\right) V $$

During inference (generating tokens one by one), the model computes a Query ($Q$) for the current token and compares it against the Keys ($K$) and Values ($V$) of all previous tokens.

- Computational Cost: Quadratic $O(N^2)$ during training; Linear $O(N)$ per step during inference.
- Memory Cost: The KV Cache. To calculate the softmax, the model must explicitly store the $K$ and $V$ vectors for the entire history in GPU memory. For long contexts (e.g., 1 million tokens), this memory footprint becomes prohibitive.

The Softmax function is the culprit. It introduces a non-linearity that binds $Q$ and $K$ together, preventing the mathematical separation of the current query from the historical context.

## 2. Fast Weights as Associative Memory Link to heading

Geoffrey Hinton proposes that the brain does not maintain a “digital buffer” of past activations (like a KV cache). Instead, it relies on Fast Weights.

In this framework, neural connections possess two timescales:

1. Slow Weights: The standard parameters learned over long periods (training).
2. Fast Weights: Synaptic strengths that change rapidly during a forward pass to store temporary context.

Hinton formalizes this temporary storage as an Associative Memory. When a network encounters a new key-value pair ($k, v$), it does not store the vectors in a list. Instead, it updates a fast weight matrix $W_{fast}$ using the Hebbian learning rule (outer product):

$$ W_{fast} \leftarrow \lambda W_{fast} + (v \otimes k) $$

Here, $\lambda$ is a decay factor ($0 < \lambda < 1$) representing forgetfulness. This matrix $W_{fast}$ compresses the history into a fixed-size representation of size $d \times d$, regardless of the sequence length.

## 3. Mathematical Unification: Linear Attention Link to heading

The connection between Fast Weights and Transformers is established by removing the softmax function from the attention mechanism, a technique known as Linear Attention.

If we treat the interaction between $Q$ and $K$ as linear, the attention equation becomes:

$$ \text{LinearAttention} = (Q K^T) V $$

Using the associative property of matrix multiplication, we can reorder the operations:

$$ Q (K^T V) $$

This reordering fundamentally alters the mechanism:

- Left Side $(Q K^T) V$: Compare Query to all Keys, then multiply by Values. Requires storing history.
- Right Side $Q (K^T V)$: Compute the summation of Key-Value outer products first.

The term $(K^T V)$ represents the summation of all past associations. This term is the Fast Weight matrix $W_{fast}$ described by Hinton.

$$ \text{State}_t = \sum_{i=1}^t k_i v_i^T $$

Thus, Linear Attention is effectively a system where the “state” is a matrix of Fast Weights that is updated at every time step.

## 4. State Space Models (SSMs) as Recurrent Fast Weights Link to heading

State Space Models (like S4 and Mamba) typically define sequence modeling through continuous control theory, discretized into a recurrence:

$$ h_t = \bar{A} h_{t-1} + \bar{B} x_t $$

$$ y_t = \bar{C} h_t $$

While derived differently, this recurrence is mathematically equivalent to the Linear Attention/Fast Weight mechanism. We can demonstrate this by “unrolling” the SSM recursion to see how the output $y_t$ depends on the history.

The output at time $t$ is the sum of inputs weighted by decaying powers of $\bar{A}$:

$$ y_t = \sum_{j=1}^t \bar{C} (\bar{A}^{t-j}) (\bar{B} x_j) $$

Comparing this to the Linear Attention formulation with decay $\lambda$:

$$ \text{Attention}_t = q_t \sum_{j=1}^t (\lambda^{t-j}) (k_j^T v_j) $$

The mapping between architectures becomes clear:

- Query ($q_t$) $\leftrightarrow$ Output Matrix $\bar{C}$
- Key/Value ($k_j^T v_j$) $\leftrightarrow$ Input Matrix $\bar{B} x_j$ (Input Projection)
- Decay Factor ($\lambda$) $\leftrightarrow$ State Matrix $\bar{A}$
- Fast Weight Matrix ($S_t$) $\leftrightarrow$ Hidden State $h_t$

Therefore, an SSM is mechanically a Transformer that uses Fast Weights (a fixed-size recurrent state) rather than a KV Cache (a growing buffer) to handle attention.

## 5. Implications for Inference Optimization Link to heading

This theoretical convergence has significant implications for inference efficiency.

### Standard Transformer Link to heading

- Mechanism: Stores history in a KV Cache.
- Memory: $O(N)$ (Grows linearly with sequence length).
- Performance: High recall/precision because it retains the exact history.

### Fast Weight / SSM (Mamba / RWKV) Link to heading

- Mechanism: Compresses history into a single Matrix/Vector state.
- Memory: $O(1)$ (Constant memory, regardless of sequence length).
- Performance: Historically lower than Transformers due to “compression loss” (trying to stuff infinite history into a finite matrix).

The Solution: Modern SSMs like Mamba improve upon basic Linear Attention by introducing Selectivity. Instead of compressing all history equally (which blurs the memory), Mamba allows the model to dynamically gate the inputs—choosing to store relevant information and reset/forget irrelevant noise. This allows the Fast Weight approach to compete with the accuracy of explicit Attention while maintaining constant memory usage.

### References Link to heading

1. Hinton, G. E., & Plaut, D. C. (1987). “Using Fast Weights to Deblur Old Memories.” Proceedings of the 9th Annual Conference of the Cognitive Science Society.
2. Ba, J., Hinton, G. E., et al. (2016). “Using Fast Weights to Attend to the Recent Past.” Advances in Neural Information Processing Systems (NeurIPS).
3. Katharopoulos, A., et al. (2020). “Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention.” International Conference on Machine Learning (ICML).
4. Gu, A., & Dao, T. (2023). “Mamba: Linear-Time Sequence Modeling with Selective State Spaces.” arXiv preprint arXiv:2312.00752.
5. Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems (NeurIPS).