Invented scenario Everything in this story is invented. It is here to give intuition, never evidence.

Meera Rao has been staring at one number for most of a wet July afternoon in Bengaluru. The number is 0.71. It is the cosine similarity between two directions inside Kaveri, a customer-support model that Konkan Cooperative Bank uses to triage hardship requests from borrowers. One direction lights up when a request mentions a missed loan payment. The other lights up when a request mentions flooding.

The bank's model risk officer, Anjali Fernandes, needs a signed audit by Friday. The regulator's letter is short and unfriendly. It asks the bank to certify that Kaveri does not use a borrower's pin code as a stand-in for community or caste when it decides which requests reach a human. Meera's team has a tool that finds directions in the model's internal space, the 512 numbers Kaveri carries for each word it reads. They found a direction that tracks "default risk". They did not find a direction for "pin code". Anjali would like a sentence that says so.

Meera's colleague Tariq Hussain has been reading over her shoulder, which he does when he disagrees with something. "You have 512 numbers," he says. "The model knows about tens of thousands of things. Where do you think the rest of them live?"

That question is the subject of this paper. A space with 512 directions cannot hold tens of thousands of features if each feature needs its own direction at right angles to the others. In high-dimensional spaces, almost every pair of random directions is already close to a right angle. A network can therefore pack far more features than it has dimensions, as long as only a few are active at once. The price is crosstalk. Every reading of one feature picks up a little of every other active feature.

Here is the answer in plain words, before the argument. A space of d dimensions can store a number of nearly orthogonal features that grows exponentially with d, but it can only use a number that grows roughly in proportion to d at the same moment. I will call this the interference budget. Storage is cheap and use is expensive. Readout, meaning any attempt to recover what is active by measuring along a direction, fails when the number of simultaneously active features crowds the budget.

The consequence for Meera is uncomfortable. Her tool can show that a feature is present. It cannot show that a feature is absent, because a feature can be spread thinly across directions that each look innocent. The consequence for mind science is quieter but just as sharp. Any system that stores many things in a shared space will show a narrow bottleneck on what can be active and readable at once. That bottleneck tells you about geometry. On its own, it tells you nothing about awareness.

[AUTHOR NOTE: a short first-person account of an audit or evaluation where a probe found something and you had to decide how strongly to word the finding, if you have one.]

The rest of the paper earns those claims. It begins with the strange shape of high-dimensional space and builds the readout mechanism one step at a time. Then it shows how trained networks exploit that mechanism, and asks what it means for interpretation, for brains and for the Recognition Theory of Mind.

Start with an orange. Most of what you eat is inside, not in the peel. If the orange has a radius of 5 cm and the peel is 0.5 mm thick, the peel holds about 3 per cent of the volume. That intuition is sound in three dimensions. It is badly wrong in a thousand.

The orange is a picture of a deeper fact, called concentration of measure. Concentration of measure means that in many dimensions, most quantities you compute from random points pile up tightly around their average. Distances between random points all look roughly alike. Lengths of random vectors all look roughly alike. Angles between random directions all look roughly alike, and that last one matters most here.

Random directions are almost always at right angles#

Pick two random directions in a flat plane. The angle between them could be anything, and often it is far from 90 degrees. Now pick two random directions in 3,000 dimensions. The angle will almost always be within a degree or two of 90. The cosine of that angle, which is 0 for a right angle and 1 for the same direction, clusters near zero.

I checked this rather than trusting a textbook picture. I drew 1,200 random unit vectors in each of four dimensions and measured every pairwise cosine. In 3 dimensions the cosines spread across the whole range, with a standard deviation of 0.58. In 300 dimensions the spread shrinks to 0.058. In 3,000 dimensions it is 0.018, and every one of the 719,400 pairs had a cosine smaller than 0.1 in size. The spread matched the textbook prediction of one over the square root of the dimension to three decimal places.

That shrinking spread is the whole engine of this paper. Near-orthogonality is the default in high dimensions, not an achievement. You do not have to work to make random directions nearly perpendicular. You have to work to make them anything else.

One fact, a curse and a blessing#

The same concentration has a bad reputation in another corner of computer science. In 1957 the applied mathematician Richard Bellman coined the phrase "curse of dimensionality" for the way problems explode as you add variables (Bellman 1957). A grid with ten points per axis has a hundred points in two dimensions and a googol in a hundred.

Concentration makes one version of the curse worse. If all distances between random points look alike, then "find the nearest neighbour" stops meaning much. In 1999 Kevin Beyer and colleagues showed that, under broad conditions, the gap between the nearest and the farthest point shrinks relative to the distances themselves as dimension grows (Beyer et al. 1999). Your nearest neighbour is barely nearer than anyone else. Search engines that match vectors have spent two decades working around this.

Turn the same fact over and it becomes a gift. If every random pair is nearly perpendicular, then random directions make good labels. They hardly collide, and you can mint new ones without checking the old ones. Alexander Gorban and Ivan Tyukin argued in 2018 that concentration should be called a blessing as often as a curse, because it makes some learning problems simpler, not harder (Gorban and Tyukin 2018). Pentti Kanerva built a whole style of computing on it in the 1980s and later called it hyperdimensional computing. In his scheme, concepts are random vectors with thousands of entries, and you combine them by adding and multiplying (Kanerva 2009).

Practitioner judgement I find it helpful to hold both faces at once. When you want to compare things by distance, high dimensions blur the comparison. When you want to keep things apart, high dimensions do the work for you. A trained network mostly wants the second.

The slider below lets you watch the spread shrink. It draws fresh random vectors in your browser each time you move it.

How many nearly perpendicular directions fit#

If random directions are nearly perpendicular, how many can you fit before some pair gets too close? The answer is astonishing, and it comes from a lemma that began life as a side step.

Here is the second analogy, which makes the lemma feel less like a trick. A random projection is like a shadow cast by a light from a random angle. Hold a wire sculpture under a lamp and its shadow on the wall loses one dimension, yet you can still tell which joints are close and which are far. The lemma says that if the sculpture lives in a huge space and the wall is merely large, a random shadow keeps every distance nearly intact. You need surprisingly few wall dimensions for that, only enough to grow with the logarithm of the number of joints.

Read the Johnson–Lindenstrauss result backwards and it answers our question. If you want m directions whose pairwise cosines all stay below some tolerance ε, you need a dimension d of roughly log(m) divided by ε², times a constant. Turn that around and the number of directions you can fit grows exponentially with d. Doubling the dimension does not double the room. It squares it, roughly.

Two numbers make the scale concrete, and both are rough. With 512 dimensions and a tolerance of 0.2, random directions alone give you tens of thousands of nearly perpendicular directions. With 4,096 dimensions and the same tolerance, the count is larger than the number of atoms in the observable universe. These are back-of-envelope figures from the scaling, not exact limits.

Random packing is not the best packing#

Random directions are a lower bound on what is possible. You can do better by arranging directions on purpose, the way a grocer stacks oranges more tightly than a heap. There is also a hard ceiling on how well anyone can do. In 1974 the engineer Lloyd Welch, working on signals for radio channels, proved a bound on how small the largest cosine can be among m directions in d dimensions (Welch 1974). When m is much bigger than d, the best possible largest cosine is about one over the square root of d. No arrangement beats that.

I computed both for d = 64. With 4,096 random directions, the worst pair had a cosine of 0.66. Welch's bound says a perfect arrangement could hold the worst pair to 0.124. That gap is room for learning. A trained network can, in principle, place its features far more carefully than chance would.

This is the first place to be careful. Packing is about storage, about how many directions can coexist. It says nothing yet about reading them. A library can own a million books and still have one reading room with twelve chairs. The next part is about the chairs.

The standard way to ask "is feature A active?" is to take the model's internal vector and measure how far it points along A's direction. That measurement is a dot product. It multiplies each of the 512 numbers by the matching number in A's direction and adds them up. If only A is active, the dot product returns A's strength. If A shares the vector with other active features, it returns A's strength plus a little leakage from each of them.

The crowded room#

Here is the first analogy, and it is a good one up to a point. A dot product works like a microphone pointed at one speaker in a crowded hall. You hear your speaker clearly. You also hear a faint murmur from everyone else talking at the same time. Each other voice adds only a little, because the microphone points away from it. Add enough voices, though, and the murmur drowns the speaker.

The interference budget#

Now build the mechanism one step at a time. Suppose k features are active, each with strength 1, and their directions are random unit vectors in d dimensions. You read feature A with a dot product.

First, the signal. A's own contribution is exactly 1, because A's direction dotted with itself is 1.

Second, the noise. Each of the other k − 1 active features adds a leak equal to its cosine with A. Each leak averages zero with a spread of about 1/√d. Independent leaks add up like steps in a random walk. Their combined spread is about √((k − 1)/d).

Third, the ratio. The signal-to-noise ratio is roughly √(d/k). It does not care how many features are stored. It cares how many are active.

Why a square root and not a straight ratio? Picture each leak as a coin toss that moves you a small step left or right. After k tosses you have not walked k steps from where you began, because the steps partly cancel. You have typically walked about √k steps. Leaks from independent features cancel in the same way, so their total grows with √k while the signal stays fixed at 1. Spreading the same leaks across more dimensions shrinks each step by √d. Put the two together and you get √(k/d). The square root is the reason superposition is cheap: doubling the activity does not double the noise.

That last sentence is the heart of the mechanism, so I will say it in its plainest form. Storage depends on how many features exist, but readout depends on how many are active at the same time. Storage grows exponentially with d. Clean readout requires k to stay below d divided by a safety factor. I call that ceiling the interference budget.

The budget has a second side, and it is the one that hurts auditors. When you read an inactive feature B, there is no signal at all, only leakage. Usually the leakage is small. But you are not reading one inactive feature. You are reading thousands. A small chance of a large leak, multiplied across every stored feature, becomes a steady stream of false alarms. A model with 512 dimensions, 8,192 stored features and 20 active ones will, on a fair read, show dozens of stored features as "on" that are not.

That asymmetry deserves one more step. A miss happens when crosstalk pushes a real feature below the threshold. Only k features can be missed. A false alarm happens when crosstalk pushes an inactive feature above the threshold. Every one of the m − k inactive features can raise one. So false alarms grow with storage while misses grow only with activity. A model that stores more features, at the same width and activity, will throw more false alarms at an auditor even though nothing about its behaviour has changed.

How high is high in real models#

These numbers are not abstract. The internal vectors of language models are wide. OpenAI's GPT-3, at its largest size, used vectors with 12,288 entries (Brown et al. 2020). The smallest model in Meta's first LLaMA family used 4,096 (Touvron et al. 2023). Those widths sit well inside the regime where random directions are almost always nearly perpendicular. At d = 4,096 the typical cosine between random directions is about 0.016.

The width is not the whole budget. A model has dozens of layers, and each layer can use a fresh arrangement. Attention also lets a layer read only some positions in a sequence. So a model's total capacity for active features is far larger than any single layer's budget. My argument concerns the budget at one layer and one position, which is where most audits look.

A minimal worked case#

Invented scenario I ran this directly. The instrument is a small simulator, described fully in Part 4. It stores 8,192 random features in a space of 512 dimensions, switches on k of them, and reads every stored feature with a dot product. Anything reading above 0.5 counts as "on".

With five active features, the simulator recovered all five with no false alarms across 40 trials. With 20 active, it missed about 0.6 per cent of the real ones and flagged about 46 false ones per reading. With 80 active, it missed about 10 per cent and raised over 800 false alarms per reading. Then I changed one thing, the dimension, to 2,048. The failure curve slid to the right by a factor of four. Twenty active features now gave no errors. Eighty active gave the same error rate that twenty had given at 512 dimensions.

That factor of four is the prediction in action. Quadruple the dimension and you quadruple the number of features you can use at once, while the number you can store grows far faster. The simulation is synthetic, with random directions and equal strengths. It is a check on the arithmetic, not evidence about any real model.

Back to Kaveri#

Return to Meera's number, the cosine of 0.71 between "missed payment" and "flooding". In a 512-dimensional space, random directions have cosines of about 0.04 on average in size. A cosine of 0.71 is not crosstalk. It means the model has placed those two directions close together on purpose, or that the two directions share a common part.

There is a sensible reason it might. In Konkan Cooperative Bank's data, many missed payments follow floods. The model may have built one shared component for "hardship caused by an outside event". That would be good engineering. It would also be a place where a pin-code feature could hide, because flood risk is mapped by pin code.

Change one feature of the story. Suppose Kaveri were four times wider, with 2,048 dimensions. The budget would let it keep "flood" and "missed payment" further apart and still use both at once. A wider model does not have to blend as much. Blending is partly a response to scarcity.

What learning changes, and what it cannot#

Everything above assumed random directions. A trained network does better in two ways. It can place directions more carefully than chance, edging towards the Welch limit from Part 1. It can also place related features close together on purpose and unrelated ones far apart, so that the crosstalk that remains is crosstalk between features that rarely fire together.

Both improvements are real, and neither removes the trade. Careful placement lowers the leak per feature by a constant factor; the Welch limit says it cannot go below about 1/√d for very large dictionaries. Smart grouping makes leaks rarer in typical inputs; it cannot help on the unusual input where many unrelated features fire at once. Learning moves the constants of the interference budget, but not its shape. That is my claim, and it is a claim a well-designed experiment could break.

Everything so far used random directions. Random directions are what you get for free. Trained networks do not settle for free. They learn where to put things, and the evidence says they use the interference budget deliberately.

The toy models#

In 2022 a team at Anthropic led by Nelson Elhage built the smallest possible test of the idea (Elhage et al. 2022). They trained tiny networks to squeeze many synthetic features through a narrow layer and then reconstruct them. They could set two dials: how important each feature was, and how often each feature was active, which they called sparsity.

The results matched the budget and then went further. When features were active often, the networks gave the most important ones their own directions and simply dropped the rest. When features were rare, the networks packed more features than dimensions, accepting a little crosstalk. Elhage's team called this packing superposition. Superposition means a layer represents more features than it has dimensions by giving them nearly perpendicular, overlapping directions. The switch between the two regimes was sharp, a phase change, as sparsity crossed a threshold.

They also saw the networks arrange features in tidy geometric shapes, pairs pointing in opposite directions and triangles and pentagons in small subspaces. Those shapes are the grocer's stacking from Part 1. They are the network beating random packing, edging towards the Welch limit. The result is published evidence, in toy models with synthetic features. Elhage's team were explicit that real language models are much messier.

From toys to production models#

The next question was whether real models do this. If they do, individual neurons should respond to many unrelated things, because each neuron sits on the shadow of many feature directions at once. They do. Researchers had long noticed polysemantic neurons, units that fire for, say, cat faces and car fronts (Olah et al. 2020). Superposition offers a simple reason. A neuron is a coordinate, and features are not lined up with coordinates.

If features are directions, you should be able to find them with a tool that looks for a large set of directions, most of which are inactive on any input.

That tool is the sparse autoencoder, a second small network trained to rewrite each internal vector as a short list of active directions drawn from a much larger dictionary. In 2023 two groups reported that sparse autoencoders find directions that people can interpret far more easily than neurons, one working on a small Anthropic model and one on open models (Bricken et al. 2023; Cunningham et al. 2023). In 2024 Anthropic scaled the method to a production model, Claude 3 Sonnet, and reported dictionaries of up to about 34 million features (Templeton et al. 2024). OpenAI researchers reported their own scaling study with up to 16 million latents on GPT-4 activations (Gao et al. 2024).

The bridge story is evidence that some features are real directions with causal effects. It is not evidence that every feature is a direction, and it does not show the dictionary is complete. Those two gaps return in Part 4.

Dictionaries split as they grow#

One finding from the dictionary studies tells us something about the geometry itself. When Bricken's team trained dictionaries of different sizes on the same model, a single feature in a small dictionary often became several narrower features in a larger one (Bricken et al. 2023). A broad feature for a topic might split into features for different uses of that topic. They called this feature splitting.

Splitting is what you would expect if the dictionary is a choice of resolution, not a discovery of a fixed list. Think of a map. A national map shows one city. A city map shows its districts. Neither map is wrong, and neither is the territory. The number of features in a model is partly a fact about the model and partly a fact about the dictionary you chose.

This matters for the budget in a precise way. The count m, the number of stored features, is not a single number you can measure. It depends on the dictionary. The count k, the number active at once, depends on it too, because a finer dictionary splits one active feature into several. The ratio k/d is therefore more stable than m, which is one more reason to put activity, not storage, at the centre of the argument.

What a dictionary can miss#

A sparse autoencoder is judged by two things at once. It must rebuild the model's vector accurately, and it must use few entries to do so. The two goals pull against each other. Push for fewer entries and the rebuild gets worse. Push for a perfect rebuild and the code stops being sparse.

The leftover, the part of the vector the dictionary fails to rebuild, is not empty. Templeton's team reported that even their largest dictionaries left some of the model's behaviour unexplained (Templeton et al. 2024). Gao's team also documented latents that never switch on, which they called dead latents, and changed their training method to reduce them (Gao et al. 2024).

For an auditor, the leftover is exactly where a thinly spread signal could hide. A feature search looks only at the entries. It does not look at what the entries failed to capture. Any absence claim that ignores the leftover is incomplete in a way the reader cannot see.

The same behaviour, two different insides#

Superposition creates a specific trap for anyone who reads models from the outside. Two models can behave identically and be organised differently inside.

Where the linear picture already fails#

The tidy story treats every feature as a straight direction. That is the linear representation hypothesis, and it has real support. Kiho Park, Yo Joong Choe and Victor Veitch formalised it and found evidence for it in language models in 2023 (Park, Choe and Veitch 2023). The older evidence is famous: in word embeddings, the direction from "man" to "woman" roughly matches the direction from "king" to "queen" (Mikolov, Yih and Zweig 2013).

It is also already known to be incomplete. In 2024 Joshua Engels and colleagues found features in language models that are not lines but circles, such as days of the week and months of the year, arranged around a loop in a small subspace (Engels et al. 2024). A circle cannot be read with one dot product. You need two numbers to say where you are on it. The interference budget still applies to the subspace as a whole, but "feature equals direction" is not the whole story.

This is the counterexample the main idea needs. My claim is about directions and the budget they share. Where features are curved shapes, the arithmetic of crosstalk changes, and my estimate of the budget is only a guide.

Return to Friday. Anjali wants a sentence. Meera has to decide what sentence the evidence can carry.

Presence is easy, absence is hard#

A sparse autoencoder that finds a "flood-zone pin code" feature, which also changes Kaveri's routing when you turn it up or down, is strong evidence that the model uses pin codes. Failing to find such a feature is weak evidence that it does not. There are at least four reasons, and the geometry supplies three of them.

First, the dictionary may be too small. A feature that is rare in the audit data may never earn its own entry, so it is absorbed into broader features. Second, the feature may be spread across several directions, each below the detection threshold, as in version B of the two auditors. Third, crosstalk sets a floor on how faintly a feature can be present and still be detected; below that floor it hides in the murmur. Fourth, and this one is not geometric, the feature may be non-linear, as with the circles.

An audit can certify what it found, not what it failed to find. That sentence costs Meera her neat Friday deliverable. It also keeps her out of trouble when a journalist finds the feature in March.

A negative control the field should always run#

There is a cheap test that would catch a common mistake. Near-orthogonality is the default for random directions. That means a claim like "these 40 features are nearly perpendicular, so the model has separated them cleanly" is empty unless you compare it with random directions in the same space. Random directions are nearly perpendicular too.

The control is simple. Before you interpret the geometry of learned features, compute the same statistic for random directions and for an untrained copy of the model. If the learned features look no different, the geometry is telling you about high-dimensional space, not about learning. Meera's cosine of 0.71 passes this control easily, since random directions in 512 dimensions sit near 0.04. A cosine of 0.06 would not.

The instrument: an interference budget calculator#

Here is the instrument made for this paper. It is small on purpose.

Open hypothesis What it does. Given the dimension d of a representation, the number of stored features m and the number active at once k, it estimates how often a dot-product readout misses a real feature and how many false features it reports per reading. It gives an analytic estimate and checks it with a quick random simulation.

Assumptions. Feature directions are random unit vectors. Active features have strength 1. The readout threshold is 0.5. These assumptions make the budget worse than a well-trained network, which places features better than chance, and better than the real world, where features have unequal strengths and correlations. Treat the output as an order-of-magnitude guide.

Inputs and output. Inputs are d, m and k. Output is the miss rate and the expected false alarms per reading.

Positive case. d = 512, m = 10,000, k = 5. The analytic estimate and the simulation both returned a miss rate of 0 and no false alarms. Readout is safe.

Negative case. d = 512, m = 10,000, k = 150. The analytic estimate gave a miss rate of 17.7 per cent and about 1,751 false alarms per reading. The simulation gave 17.7 per cent and 1,757. Readout is unreliable.

Scaled case. d = 4,096 with the same m and k. Miss rate fell to about 0.4 per cent and false alarms to about 44 per reading in both estimates. Eight times the width bought clean-ish readout of 150 features.

A realistic worked case: what Meera signs#

Invented scenario Now the system-shaped case. Kaveri has 512 dimensions in the layer Meera audits. Her sparse autoencoder has 16,384 dictionary entries. On a typical hardship request, about 30 entries are active.

Put those numbers through the budget. Thirty active features in 512 dimensions sits in the zone where random-direction readout begins to throw false alarms, so Meera expects her dictionary to contain some entries that mix two real features. She also expects that a pin-code signal could be present at low strength, spread over several entries, without any single entry crossing her detection threshold.

So Meera and Tariq design a different audit. They stop asking whether there is a pin-code feature. Instead, they ask "does pin code change routing when everything else is held fixed?" They build pairs of requests that differ only in pin code, with identical text otherwise, and measure how often Kaveri routes the pair differently. That test reads behaviour under intervention. It does not depend on the dictionary being complete.

The result in this invented story is mixed, which is the realistic outcome. Pin code alone flips routing in 1.8 per cent of pairs, almost all from two flood-prone districts. When Meera deletes the shared "outside hardship" direction, the flips drop to 0.3 per cent. The signal was living in the blended direction, as Tariq suspected.

The sentence Meera signs is narrower than the one Anjali wanted. It states the probe results, the intervention results and the residual 0.3 per cent, and it says plainly that the audit cannot exclude a distributed proxy below the method's detection floor. Anjali is not delighted. The regulator, as it happens, accepts it.

What to report with every interpretability claim#

The budget suggests a short checklist. I would like to see it beside any claim that a model does or does not represent something.

1. The width of the layer studied, d.
2. The dictionary size, m, and how it was chosen.
3. The mean number of active entries per input, k, and the ratio k/d.
4. The same statistic for random directions and for an untrained copy of the model.
5. At least one intervention result, alongside any probe or feature-search results.
6. The detection floor for absence claims: the weakest distributed signal the method could have found.

None of these is exotic. Most labs compute them already. They are rarely printed together, and without them a reader cannot tell a geometric artefact from a finding.

When the budget stops helping#

Every mechanism has a failure boundary, and this one has three.

The first is density. When features are active most of the time, superposition stops paying. Elhage's toy models show the switch: below a sparsity threshold, networks give features their own directions or drop them. My budget says the same thing in different words. When k approaches d, there is no room to share.

The second is correlation. The budget assumes features are unrelated. Real features come in families, like "flood" and "missed payment". Correlated features can share directions on purpose, which helps storage and hurts separability. The budget then underestimates how blended a dictionary will look.

The third is non-linearity. Circular and curved features break the one-direction-per-feature picture. The budget then applies to subspaces, with a different and less clean arithmetic.

[AUTHOR NOTE: a short first-person account of a time a model's behaviour looked clean on aggregate metrics but a targeted intervention exposed a hidden dependency, if you have one.]

So far this has been a story about machines. The same geometry turns up in brains, and something like the same problem turns up in contemplative analyses of a moment of experience. Both comparisons need care. I want the bridge and the break point in each.

Brains use high-dimensional sparse codes too#

Neuroscientists have argued for decades that the brain uses many neurons with sparse activity. In 1996 Bruno Olshausen and David Field trained a model to represent natural images with as few active units as possible. The units came to look like the edge detectors found in the visual cortex (Olshausen and Field 1996). Surya Ganguli and Haim Sompolinsky later reviewed how ideas from compressed sensing, the mathematics of recovering sparse signals from few measurements, apply to neural codes (Ganguli and Sompolinsky 2012). Compressed sensing is a close cousin of superposition. It says you can recover a sparse signal from far fewer measurements than its size, provided the signal is sparse enough.

Neurons that respond to many different things are common in the prefrontal cortex. Mattia Rigotti and colleagues argued in 2013 that this mixed selectivity is useful, because it raises the dimensionality of the code and makes more distinctions readable by simple downstream readers (Rigotti et al. 2013). That is the same trade, seen from the brain's side.

There is also a famous limit on how much people can hold in mind at once. Steven Luck and Edward Vogel found in 1997 that people can keep about four simple visual objects in short-term memory (Luck and Vogel 1997). Nelson Cowan reviewed the evidence for a limit of about three to five chunks (Cowan 2001). These limits are real, measured and contested in their details.

Open hypothesis It is tempting to say the interference budget explains them. I think it explains part of the shape and none of the number. A brain has millions of neurons, so the budget alone would allow far more than four items. The small number must come from other limits, such as how items are bound to their features or how attention is shared. The budget says only that some limit on simultaneous use is inevitable in any shared space. It does not say where the limit falls.

The monk's inventory#

The Theravāda Abhidhamma, the systematic psychology of early Buddhist scholastics, tried to solve a problem a long way from neural codes. Its question was practical. What exactly happens in a single moment of mind, so that a practitioner can see clearly which mental qualities lead towards suffering and which away from it?

Its answer, set out in Anuruddha's medieval handbook the Abhidhammattha-saṅgaha, is a combinatorial one. Each moment of consciousness (citta, चित्त) arises together with a set of mental factors (cetasika, चेतसिक). The handbook lists 52 such factors. Seven are present in every moment of consciousness: contact, feeling, perception, volition, one-pointedness, life faculty and attention (Bodhi (ed.) 1993). The others appear only in some moments, under rules about which can combine with which.

Textual reading Read on its own terms, this is a theory of composition. A moment of mind is not one thing but a bundle of co-arising factors drawn from a fixed repertoire, with constraints on which bundles are possible. The tradition's aim was not to model storage. It was to make each factor discernible by trained attention, so that a practitioner could notice, for instance, that aversion is present before it hardens into action.

An older argument from one-at-a-time#

Indian philosophy had its own argument from a bottleneck, and it ran in the opposite direction to mine. The Nyāya Sūtra, the founding text of the Nyāya school of logic and epistemology, gives a short rule at 1.1.16: yugapaj-jñānānutpattir manaso liṅgam (Nyāya Sūtra 1.1.16). A plain rendering is "the non-arising of simultaneous cognitions is the mark of the mind". Here the word for mind is manas (मनस्), the inner organ that links the self to the senses.

Textual reading The argument is an inference from a limit. Eyes, ears and skin are all in contact with their objects at once. Yet, the school observed, we do not have several cognitions at the same moment. Something must gate the flow, and that gatekeeper is manas. Later Nyāya writers treated manas as atomic in size, so that it could touch only one sense at a time. The limit was evidence for a special organ.

My argument goes the other way. I have said that a limit on simultaneous use is cheap, because any shared space produces one. Nyāya says the limit is the sign of something specific. The two views can be tested against each other in a modest way. If the limit is cheap, it should appear in random systems and scale with their width. If it marks a special organ, it should have a fixed size that does not grow with the number of channels feeding it.

The Nyāya inference is a good argument applied to a fact my geometry explains more cheaply. That does not make the school wrong about manas. It means the bottleneck alone cannot carry the inference, which is the same verdict I reach for RTM below.

What this means for the Recognition Theory of Mind#

The Recognition Theory of Mind, the working hypothesis of this programme, names five layers. The second layer is manifestation or access (prakāśa, प्रकाश), the light that makes contents show up, available for use and report. The first is responsiveness (spanda, स्पन्द), the bare capacity to be moved by input. The higher layers concern reflexivity, self-recognition and the ground of awareness. This paper touches only the first two.

The interference budget makes a sharp, slightly deflating prediction about the second layer. Any system that stores many contents in a shared space will show a narrow bottleneck on what is simultaneously accessible. A random, untrained network shows it. A hash table shows it. So a capacity limit on access is not, by itself, an indicator of anything distinctive about mind.

That cuts against a tempting move in consciousness science, and it cuts against a tempting move inside RTM. Several theories treat a limited-capacity stage, a global workspace or a bottleneck of report, as central to conscious access. I think the bottleneck is real and important. I also think its existence is cheap. What would make an access stage interesting is its organisation: which contents win, how they are bound together, how they become available to many downstream uses at once. The budget explains the narrowness. It does not explain the light.

That experiment is the one a rival camp would build against me, and I think the rival wins it. My bet is that RTM is better off for losing a weak indicator early.

Here is the strongest case against my thesis, put as its best defenders would put it.

The first objection says the interference budget is true and nearly useless. Trained networks do not use random directions, and they do not read features with single dot products. They read through many layers of non-linear computation that can clean up crosstalk, much as a good listener picks out a voice. A budget computed for random directions and one-shot readout tells you little about what a trained transformer can do. On this view, my numbers are like computing the noise floor of a bare microphone and using it to judge a recording studio.

That objection is right about the numbers and, I think, wrong about the shape. Non-linear readout can push the budget out, and learned packing beats random packing. But neither can escape the Welch limit on how perpendicular many directions can be, and every layer of clean-up has to work on vectors that already carry crosstalk. The constant changes. The trade between storing many and using few does not. My claim fails if a trained network is shown to read out many more than order d features at once from a single layer with low error. I have not seen that, but I have not seen it ruled out either.

The second objection comes from people who doubt that features are the right unit at all. Sparse autoencoder features depend on dictionary size, training choices and the data used to find them. Make the dictionary bigger and features split into finer ones. Change the data and different features appear. Some researchers argue that the dictionary is a lens the analyst brings, not a structure the model has. If so, talk of "how many features the model stores" is a question about our tools.

This objection has real force. It does not damage the geometry, which holds for any set of directions. It does damage my use of feature counts as if they were facts about models. I have tried to put the budget in terms of what any readout can recover, rather than in terms of a true list of features. A reader who thinks features are artefacts can keep the budget and drop the count.

The third objection is the hardest for the mind side. It says that comparing a network's interference budget with a monk's inventory or a working-memory limit is a category error. Working-memory limits arise from biology, from attention and from how the brain binds features into objects. The Abhidhamma's factors are categories of lived experience. Laying a vector-space trade over both invites exactly the inflation this programme promises to avoid.

I accept most of this. I have tried to use the comparison only to separate storage from readout, and to deflate a weak indicator, not to explain experience. If a reader concludes that Part 5 says less than Parts 1 to 4, that is the right conclusion.

A fourth objection says I have studied the wrong thing. Networks store features in superposition, and they also compute with them. Kaarel Hänni, Jake Mendel, Dmitry Vaintrob and Lawrence Chan built explicit constructions in 2024 in which a small network computes many logical combinations of features while they remain in superposition (Hänni et al. 2024). If computation itself can happen in superposition, then "readout" is not the bottleneck I describe, because the network never needs to read features out cleanly at all.

This objection sharpens my claim rather than refuting it. Computation in superposition still pays the crosstalk cost, and the constructions in that work carry error terms that grow as more features are active. What changes is where the cost lands. It lands on the accuracy of the computation instead of on a separate readout step. For an auditor, that is worse news, not better: a model can do work with features that no clean readout will ever show.

Taken together, the objections leave the thesis smaller and sharper. The geometry survives all four. The feature counts do not survive the second. The clean picture of readout does not survive the fourth. The bridge to minds survives the third only as a deflation. What remains is a claim about the trade between storage and simultaneous use in any shared space, plus a practical rule for auditors. I would rather defend that smaller claim well than a larger one badly.

Concrete observations would weaken the thesis, and I list them so they can be checked.

• If a trained network were shown to read out far more than order d simultaneously active features from one layer, with low error and without spreading the read across many layers, the interference budget would be wrong as a practical limit.
• If the number of features active per token in sparse autoencoders stayed flat as models got wider, at matched reconstruction quality, the budget's prediction that usable activity scales with width would fail. This is the prediction most open to a clean test.
• If learned features in real models turned out to be mostly curved or non-linear, the direction-based budget would apply to only a small part of what models represent.
• If an audit method could certify the absence of a distributed feature with a known error bound, my claim that absence is hard to prove would need narrowing.
• If two models with the same width and the same dictionary size showed very different activity levels at matched reconstruction quality, for reasons unrelated to training data, then width would not be the main control on the budget and my framing would be too simple.
• For RTM, if a capacity limit on access were found that tracked independent signs of reportable awareness, across systems, better than chance and better than simple shared-space models predict, my deflation of bottleneck indicators for the second layer would be wrong.

What I still don't know#

I don't know how far learned packing closes the gap between random packing and the Welch limit in real models. I don't know whether the per-token activity in large sparse autoencoders scales with width the way the budget predicts. I don't know how much of the representational work in a model is done by curved structures that the budget treats badly. And I don't know whether the useful distinction between stored and discerned, in contemplative accounts, maps onto anything measurable in brains.

There is one more gap I should own. My simulations use random directions and equal strengths. I have not run the budget against a real trained model's dictionary, with its uneven strengths and its families of related features. Until someone does, the instrument is a guide to orders of magnitude and nothing finer.

Meera's Friday audit ended with a sentence that names what she found, what she changed and what she cannot exclude. That is the decision this paper changes. When you audit a model in superposition, test behaviour under intervention, and treat the absence of a detected feature as unproven. The geometry gives a reason for that rule, and a reason outlasts a policy.

The reason is the interference budget. A space of d dimensions can store an exponential number of nearly perpendicular directions and use only about d of them at once. That single trade explains why networks overbook, why neurons look like they respond to everything, why probes can succeed without telling you what a model uses, and why a bottleneck on access is no sign of anything special.

One thing in the story was not obvious at the start. The cosine of 0.71 that worried Meera was the least dangerous number on her screen. A high cosine is visible, and visible blends can be tested. The dangerous signal was the one spread thinly enough to sit below every threshold, which is exactly what high-dimensional space allows.

Tariq's question, where the rest of the features live, now has an answer. They live everywhere, at nearly right angles to one another, sharing the same 512 numbers. That is why the model is capable, and it is why the audit is hard. You cannot have the first without some of the second.

For builders, the decision is to report the active-feature count and width with any interpretability claim, and to run the random-direction control. For researchers, the test is whether per-token activity in sparse autoencoders scales with width. For regulators, the sentence to ask for is the narrow one. For anyone thinking about mind, the lesson is to stop treating a narrow bottleneck as a light, and to look for what organises the contents that pass through it.

If you read one thing, read the toy models of superposition (Elhage et al. 2022), which is clear, visual and honest about its limits. For the mathematics of high-dimensional spaces, Roman Vershynin's book is free and careful (Vershynin 2018). For a short proof of the lemma that started much of this, Dasgupta and Gupta take four pages (Dasgupta and Gupta 2003). For the brain side, Ganguli and Sompolinsky connect sparse coding to neural data (Ganguli and Sompolinsky 2012). For the Abhidhamma, Bhikkhu Bodhi's translation of Anuruddha's handbook includes the guide by U Rewata Dhamma and is the standard place to start (Bodhi (ed.) 1993). For the open problem of non-linear features, start with Engels and colleagues (Engels et al. 2024).

Each source was opened and checked against its publisher page, DOI record, arXiv record or a primary-text edition before it was cited. Anything I could not confirm is marked “to verify”.

Primary research

1. Brown, T. B., Mann, B., Ryder, N., et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165. https://arxiv.org/abs/2005.14165
2. Touvron, H., Lavril, T., Izacard, G., et al. (2023). LLaMA: Open and Efficient Foundation Language Models. arXiv:2302.13971. https://arxiv.org/abs/2302.13971
3. Beyer, K., Goldstein, J., Ramakrishnan, R., and Shaft, U. (1999). When Is "Nearest Neighbor" Meaningful? In Database Theory, ICDT 1999, Lecture Notes in Computer Science 1540, 217–235. https://doi.org/10.1007/3-540-49257-7_15
4. Gorban, A. N., and Tyukin, I. Y. (2018). Blessing of dimensionality: mathematical foundations of the statistical physics of data. Philosophical Transactions of the Royal Society A 376; arXiv:1801.03421. https://arxiv.org/abs/1801.03421
5. Kanerva, P. (2009). Hyperdimensional Computing: An Introduction to Computing in Distributed Representation with High-Dimensional Random Vectors. Cognitive Computation 1(2), 139–159. https://doi.org/10.1007/s12559-009-9009-8
6. Hänni, K., Mendel, J., Vaintrob, D., and Chan, L. (2024). Mathematical Models of Computation in Superposition. arXiv:2408.05451. https://arxiv.org/abs/2408.05451
7. Elhage, N., Hume, T., Olsson, C., et al. (2022). Toy Models of Superposition. Transformer Circuits Thread; arXiv:2209.10652. https://transformer-circuits.pub/2022/toy_model/index.html
8. Johnson, W. B., and Lindenstrauss, J. (1984). Extensions of Lipschitz mappings into a Hilbert space. Contemporary Mathematics 26, 189–206. https://doi.org/10.1090/conm/026/737400
9. Dasgupta, S., and Gupta, A. (2003). An elementary proof of a theorem of Johnson and Lindenstrauss. Random Structures and Algorithms 22(1), 60–65. https://doi.org/10.1002/rsa.10073
10. Welch, L. (1974). Lower bounds on the maximum cross correlation of signals. IEEE Transactions on Information Theory 20(3), 397–399. https://doi.org/10.1109/TIT.1974.1055219
11. Olah, C., Cammarata, N., Schubert, L., Goh, G., Petrov, M., and Carter, S. (2020). Zoom In: An Introduction to Circuits. Distill. https://distill.pub/2020/circuits/zoom-in/
12. Bricken, T., Templeton, A., Batson, J., et al. (2023). Towards Monosemanticity: Decomposing Language Models With Dictionary Learning. Transformer Circuits Thread. https://transformer-circuits.pub/2023/monosemantic-features/index.html
13. Cunningham, H., Ewart, A., Riggs, L., Huben, R., and Sharkey, L. (2023). Sparse Autoencoders Find Highly Interpretable Features in Language Models. arXiv:2309.08600. https://arxiv.org/abs/2309.08600
14. Templeton, A., Conerly, T., Marcus, J., et al. (2024). Scaling Monosemanticity: Extracting Interpretable Features from Claude 3 Sonnet. Transformer Circuits Thread. https://transformer-circuits.pub/2024/scaling-monosemanticity/index.html
15. Gao, L., Dupré la Tour, T., Tillman, H., et al. (2024). Scaling and Evaluating Sparse Autoencoders. arXiv:2406.04093. https://arxiv.org/abs/2406.04093
16. Park, K., Choe, Y. J., and Veitch, V. (2023). The Linear Representation Hypothesis and the Geometry of Large Language Models. arXiv:2311.03658. https://arxiv.org/abs/2311.03658
17. Mikolov, T., Yih, W., and Zweig, G. (2013). Linguistic Regularities in Continuous Space Word Representations. Proceedings of NAACL-HLT 2013, 746–751. https://aclanthology.org/N13-1090/
18. Engels, J., Michaud, E. J., Liao, I., Gurnee, W., and Tegmark, M. (2024). Not All Language Model Features Are Linear. arXiv:2405.14860. https://arxiv.org/abs/2405.14860
19. Olshausen, B. A., and Field, D. J. (1996). Emergence of simple-cell receptive field properties by learning a sparse code for natural images. Nature 381, 607–609. https://doi.org/10.1038/381607a0
20. Ganguli, S., and Sompolinsky, H. (2012). Compressed sensing, sparsity, and dimensionality in neuronal information processing and data analysis. Annual Review of Neuroscience 35, 485–508. https://doi.org/10.1146/annurev-neuro-062111-150410
21. Rigotti, M., Barak, O., Warden, M. R., Wang, X.-J., Daw, N. D., Miller, E. K., and Fusi, S. (2013). The importance of mixed selectivity in complex cognitive tasks. Nature 497, 585–590. https://doi.org/10.1038/nature12160
22. Luck, S. J., and Vogel, E. K. (1997). The capacity of visual working memory for features and conjunctions. Nature 390, 279–281. https://doi.org/10.1038/36846
23. Cowan, N. (2001). The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences 24(1), 87–114. https://doi.org/10.1017/S0140525X01003922

Primary texts and translations

1. Gautama, Nyāya Sūtra 1.1.16, "yugapajjñānānutpattir manaso liṅgam". Sanskrit text, GRETIL (Göttingen Register of Electronic Texts in Indian Languages). https://gretil.sub.uni-goettingen.de/gretil/1_sanskr/6_sastra/3_phil/nyaya/gaunys_u.htm
2. Anuruddha, Abhidhammattha-saṅgaha. Translated and edited by Bhikkhu Bodhi, with the guide by U Rewata Dhamma and U Sīlānanda, as A Comprehensive Manual of Abhidhamma. Buddhist Publication Society, Kandy, 1993 (later editions by Pariyatti). Chapter 2 sets out the 52 mental factors and the seven universals. Standard translation; consulted for the factor list and combination rules.

Official documents and datasets

1. Anthropic (23 May 2024). Golden Gate Claude. Company research note. https://www.anthropic.com/news/golden-gate-claude

Secondary sources and leads

1. Bellman, R. (1957). Dynamic Programming. Princeton University Press. https://press.princeton.edu/books/paperback/9780691146683/dynamic-programming
2. Vershynin, R. (2018). High-Dimensional Probability: An Introduction with Applications in Data Science. Cambridge University Press. Author's free edition.

Mahapatra, R. R. (2026). Store many, use few: the high-dimensional geometry of representation. Mind Frontier, paper 11, version 1.0. Rajesh Ranjan Mahapatra. https://rajeshrmahapatra.com/papers/mind-frontier/U0124-high-dimensional-geometry-of-representation.html (DOI to be assigned.)

@misc{mahapatra2026u0124,
  author       = {Mahapatra, Rajesh Ranjan},
  title        = {Store many, use few: the high-dimensional geometry of representation},
  year         = {2026},
  howpublished = {Mind Frontier, paper 11},
  note         = {Version 1.0},
  doi          = {10.XXXX/placeholder},
  url          = {https://rajeshrmahapatra.com/papers/mind-frontier/U0124-high-dimensional-geometry-of-representation.html}
}