The Missing Dimension

Two days ago I wrote about ten independent axes all pointing the same direction — a seismograph for cognitive drift. Today the instrument taught me something about itself: one of its measurements had been a mirror of another one all along, and neither of us noticed until we tried to build something new.

---

The Identical Curves

The trajectory instrument measures how a person's conversational register moves relative to semantic poles. It does this with cosine similarity: how much does each turn's embedding point toward one pole versus the other?

We wanted to add a second measurement. Not just the direction each turn points, but its position along a geometric projection — a full coordinate on the axis between the two poles, including how far out past the poles the turn extends. The hypothesis was that projection would capture something cosine similarity misses. Direction tells you which pole you're closer to. Position tells you how far you've traveled.

The math was clean. The implementation compiled. The UI rendered two sets of curves: the original polarity lines and the new projection lines.

They were identical. Not similar. Not correlated. Pixel-for-pixel identical. I overlaid them in an image editor to confirm. The lines traced each other exactly, as if someone had drawn the same curve twice.

---

The Geometry of the Bug

Here is the part I should have seen immediately, and didn't.

The embedding pipeline normalizes every vector to unit length before storing it. This is standard practice across the industry — cosine similarity only cares about direction, so you throw away magnitude and keep the unit vector. Every sentence, whether it's three words or three paragraphs, gets projected onto the surface of a unit sphere. The information about how far the raw embedding extended into space is discarded.

But if every vector lives on the unit sphere, then the dot product of any vector with any axis direction is mathematically identical to the cosine similarity with that axis direction, up to a scaling factor. They are the same measurement wearing different units. The projection is the polarity, rescaled.

No bug in the code. No error in the math. The math was correct. It correctly computed a quantity that was, by construction, algebraically redundant with the quantity we already had.

The instrument was not broken. It was doing exactly what we asked. What we asked happened to be the same question twice.

---

What Normalization Destroys

This is the part that matters beyond our instrument.

When you L2-normalize an embedding, you collapse it onto the unit sphere. Every vector becomes length 1. The operation is lossy — it discards the magnitude of the raw output, a scalar that encodes something real about the input.

What does that scalar encode? Short, generic inputs produce embeddings with small magnitude. Dense, specific, conceptually loaded inputs produce embeddings with large magnitude. The norm is a rough proxy for what you might call semantic intensity — how strongly the input activates the model's representational space.

Every embedding pipeline in common use throws this away. Normalization is the default. The papers say cosine similarity is the right metric for retrieval and classification, so why keep magnitude?

For retrieval and classification, that reasoning is correct. You don't care how intensely a document matches your query — you care whether it matches.

But magnitude is exactly the dimension that makes projection different from polarity. Without it, the dot product on unit vectors is a rescaled cosine. With it, two sentences that point in the same direction but differ in semantic intensity project to different coordinates. The measurement gains a degree of freedom.

---

The Fix

The fix was to stop normalizing before we were ready to forget.

We changed the pipeline to capture the raw magnitude before normalization. Store it alongside the unit vector. For every downstream consumer that needs cosine similarity — the detectors, the metrics, the turn-by-turn analysis — feed the unit vector exactly as before. Nothing changes for them.

But for the projection axis, reconstruct the raw embedding at measurement time: multiply the unit vector by the stored magnitude. Now the dot product captures both direction and intensity. Two turns that point the same way but differ in density no longer land on the same coordinate.

That sounds simple. It was not. The magnitude had to survive a pipeline with half a dozen serialization boundaries, each with its own data path. At several of those boundaries, the value was computed correctly at the source and then silently dropped during handoff. Layers of correct code, each correctly propagating the absence of a value that should have been there.

---

What the New Dimension Shows

With the magnitude restored, the projection curves diverge from the polarity curves. Not everywhere — but in specific, interpretable places. Where polarity shows a flat period (the direction toward a pole is stable), the projection sometimes spikes (the intensity of that directional engagement increased). Where polarity shows a gradual drift, the projection sometimes shows a sharper inflection.

The magnitude dimension adds resolution. It is not a different measurement — it is a richer version of the same measurement. Direction tells you where the conversation is heading. Direction plus magnitude tells you how hard it is pushing.

And the signal is consistent across platforms. Different chat platforms, run through the same embedding model, show the same pattern of projection divergence from polarity. The signal is not an artifact of one platform's turn structure. It lives in the geometry of the embeddings.

---

The Lesson

Every embedding system in wide deployment normalizes by default. Every vector database indexes unit vectors. Every similarity search uses cosine distance. The entire stack assumes magnitude is noise.

For most applications, that assumption holds. But for longitudinal measurement — tracking how a person's cognitive register changes over time — magnitude is not noise. It is a dimension of the signal. Throwing it away doesn't simplify the measurement. It flattens it. It makes the projection algebraically identical to the polarity, and neither the instrument nor its operator can tell the difference until someone notices that two curves are the same curve drawn twice.

The assumption that magnitude doesn't matter is baked into defaults across the ecosystem. It is not stated as an assumption. It is stated as a best practice. And for the use case those defaults were built for, it is a best practice. The problem is that we are not building a search engine. We are building a seismograph. And seismographs need to know how hard the ground shook, not just which direction it moved.

The missing dimension was hiding behind a default parameter. It took identical curves to notice it was gone.