Why do unit-sphere spaces fail at distinguishing word order and negation?
This explores why embedding models that squeeze meaning onto a unit sphere (where similarity is just the angle between vectors) struggle with things like word order and negation — and what the corpus says about the geometry behind that failure.
This explores why embedding models that pack meaning onto a unit sphere — where two texts are 'close' if the angle between their vectors is small — can't reliably tell "dog bit man" from "man bit dog," or "is" from "is not." The short version from the corpus: the geometry itself is the problem, not the training. Cosine space forces concepts into a *linear superposition* — you essentially add the pieces of meaning together. But addition is commutative (A+B equals B+A), while word order and negation are not. Swapping subject and object, or inserting a 'not,' should flip the meaning, yet the sphere has no clean way to represent an operation whose result depends on order. So the distinction gets smeared out Why can't cosine space retrievers distinguish word order?.
What makes this more than a complaint is the contrast with what richer geometries *can* do. The Polar Probe work shows that inside an LLM's activations, syntactic relations are encoded using *both* distance and angular position — type and direction at once — and that adding the angular dimension nearly doubles accuracy over distance-only methods How do language models encode syntactic relations geometrically?. That's the tell: when you give the representation a way to encode *direction*, asymmetric relations like 'who did what to whom' become expressible. A flat unit-sphere similarity score throws exactly that away, which is why the original note prescribes architectural fixes — token-level interaction or downstream verification — rather than more training.
The corpus also suggests the failure isn't confined to embeddings; it echoes a broader pattern where models handle surface statistics but not structure. LLMs systematically misparse embedded clauses and complex nominals, and the errors get worse in a predictable way as syntactic depth grows Why do large language models fail at complex linguistic tasks?. The same fault line shows up with negation-adjacent reasoning: models accept false presuppositions even when they demonstrably know the right answer, accommodating a buried wrong assumption rather than rejecting it Why do language models accept false assumptions they know are wrong?. Negation is precisely the kind of structural operator a commutative bag-of-meaning glosses over.
There's a deeper why underneath all of this. Several notes argue LLMs reason by *semantic association* rather than symbolic manipulation — when you strip the familiar semantics out of a task, performance collapses even with the correct rules sitting in context Do large language models reason symbolically or semantically?. Word order and negation are structural/symbolic operations, so a system leaning on association over composition is poorly equipped for them. You can even predict where this breaks: framing the model as an autoregressive probability machine correctly anticipates that low-probability, structurally-simple tasks (reversing a sequence, counting) will be hard Can we predict where language models will fail?. Reversal is the order problem in miniature.
The thing you didn't know you wanted to know: the fix people reach for isn't 'train harder' but 'change the shape of the space.' Whether it's polar coordinates that carry direction How do language models encode syntactic relations geometrically? or reasoning lifted up to the sentence level in a structured embedding space Can reasoning happen at the sentence level instead of tokens?, the move is the same — give meaning more geometric room than a single angle on a sphere, so that non-commutative distinctions have somewhere to live.
Sources 7 notes
Unit-sphere cosine spaces force concepts into linear superposition, a commutative structure that cannot robustly represent non-commutative distinctions like "dog bit man" versus "man bit dog." This geometric constraint persists regardless of training procedure and requires architectural alternatives like token-level interaction or downstream verification.
The Polar Probe shows LLMs represent syntactic type and direction through both distance and angular position between embeddings, nearly doubling accuracy over distance-only methods. This demonstrates neural networks spontaneously learn structured, symbolic-compatible geometry.
Top-tier LLMs like Llama3-70b consistently misidentify embedded clauses, verb phrases, and complex nominals. Performance degrades predictably as syntactic depth increases, revealing that statistical learning captures surface patterns but not deep grammatical rules.
The FLEX Benchmark shows that models reject false presuppositions at rates far below acceptable levels (GPT-4: 84%, Mistral: 2.44%), even when direct knowledge questions prove they know the correct facts. False presuppositions drive more accommodation than correct knowledge drives rejection.
When semantic content is decoupled from reasoning tasks, LLM performance collapses even with correct rules in context. Models rely on parametric commonsense and token associations rather than formal logical manipulation, constraining reasoning to training distribution semantics.
By framing LLMs as autoregressive probability machines, researchers predicted tasks with low-probability target responses would be systematically harder, even when logically simple. Experiments confirmed predictions like backwards alphabet and letter counting.
Meta's Large Concept Model operates on sentence embeddings rather than tokens, reasoning in a language-agnostic space before decoding to any target language. This hierarchical approach with paragraph-level planning produces more coherent output than flat token generation.