Why do single vectors fail at capturing negation and word order?
This explores why a single embedding vector — the kind that powers most semantic search — struggles to tell 'dog bit man' from 'man bit dog,' or 'is' from 'is not.'
This explores why packing a sentence into one fixed vector loses negation and word order. The sharpest answer in the corpus is geometric, not just empirical: unit-sphere cosine spaces force concepts into linear superposition — you essentially *add* the meaning of each word together. But addition is commutative (a+b = b+a), while language is not. 'Dog bit man' and 'man bit dog' use identical ingredients in a different arrangement, and a commutative geometry literally cannot keep them apart. Negation is the same problem in another key: 'is' and 'is not' share almost all their tokens, so they land close together on the sphere even though they mean opposites. The corpus frames this as a constraint that 'persists regardless of training procedure' — you can't train your way out of a geometry that has no place to put the distinction Why can't cosine space retrievers distinguish word order?.
A second note sharpens *what* embeddings actually measure: not relevance or logical role, but co-occurrence and association. That's why a query and a semantically related but role-reversed candidate look nearly identical — the vector encodes 'these words hang out together,' not 'this one is the subject and that one is the object' Do vector embeddings actually measure task relevance?. Negation is the extreme case: the negated thing co-occurs heavily with the thing it negates, so association pulls them together exactly when meaning pushes them apart.
The same asymmetry shows up one level up, in how models *learn* facts. The reversal curse — models trained on 'A is B' failing at 'B is A' — reveals that representations are direction-bound rather than symmetrically relational Why can't language models reverse learned facts?. It's a cousin of the word-order problem: order and direction carry meaning that a flattened representation discards. And when you test grammar directly, competence degrades predictably as sentences nest and embed — evidence that what's captured is surface heuristics, not the structural rules that make word order matter Does LLM grammatical performance decline with structural complexity?, Why do large language models fail at complex linguistic tasks?.
What you might not expect: the corpus also shows a way out, and it's geometric too. A 'polar probe' finds that inside a model's activations, syntactic relations *are* encoded — using both distance and angular position to mark the type and direction of a relation How do language models encode syntactic relations geometrically?. The information survives internally; it's the act of collapsing everything onto a single cosine-similarity sphere that throws away the angle. So the failure isn't that order and negation are unlearnable — it's that one vector is the wrong container. The fixes that follow are architectural: token-level interaction (let words compare directly instead of pre-summing) or a downstream verification step that re-checks order and polarity after retrieval Why can't cosine space retrievers distinguish word order?.
Sources 6 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.
Embeddings encode co-occurrence patterns, making semantically close but role-distinct concepts highly similar. This works in simple demos but fails in production where underspecified queries have many wrong-but-associated candidates.
Autoregressive training encodes directional associations rather than symmetric relations. Models trained on "A is B" cannot reliably retrieve answers for "B is A," revealing that knowledge representation is format-bound rather than abstractly relational.
LLMs show systematic performance decline as syntactic depth and embedding increase. Simple sentences are handled well while complex structures with recursion and embedding fail consistently, suggesting LLMs learned surface heuristics rather than structural grammar rules.
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 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.