The constellation survives the coordinate change

Start with a physical arrow drawn on a sheet of paper. The arrow has a length and a direction before anyone draws axes. Add a horizontal and vertical grid, and the arrow can be described by two coordinates. Rotate the grid and the coordinates change, although the arrow does not. A vector is the arrow-like object. A coordinate list is its description in a chosen basis.

In two dimensions, a basis is a pair of independent reference directions. In a conventional grid they are the unit arrows pointing right and up. In a representation space with 4,096 dimensions, the same principle holds, even though no person can picture all the axes. The vector x is written as a weighted combination of basis directions. Its coordinate xᵢ says how much of basis direction eᵢ participates in that description.

The hidden assumption is easy to miss: we often treat coordinate number 731 as though it were an intrinsic property of the represented object. Usually it is not. If an orthogonal matrix Q rotates or reflects every vector, then the transformed vectors Qx and Qy preserve lengths, angles and dot products. A matching rotation of a linear readout preserves its output as well. Individual coordinates may move while the operational relation remains exactly the same.

The origin is not innocent

A point needs an origin as well as a basis. Shift every point by the same amount and pairwise differences remain fixed, so Euclidean distances between points do not change. Angles measured from the origin can change sharply, however, which means cosine similarity can change. This is why centring an embedding cloud is not a neutral formatting step. It changes the question from “which points point in the same direction from the model’s zero?” to “which deviations from the chosen centre align?”

Take x = (3, 1) and y = (4, 2). Their cosine is about 0.99. Translate both by c = (2, 1). The new coordinates are x′ = (1, 0) and y′ = (2, 1), whose cosine is about 0.89. The distance between the two points remains √2. Nothing contradictory occurred. Distance and cosine preserve different structures.

This matters in learned spaces because the zero vector rarely arrives with a natural semantic interpretation. It may be the output for padding after a mask, the origin implied by an optimiser, or simply the coordinate zero selected by parameterisation. A mean vector can dominate many token directions, and subtracting it can make local contrasts easier to see. Before interpreting an angle, ask what the origin makes that angle an angle from.

When an axis can earn local meaning

The coordinate warning should not be turned into the opposite dogma that axes never matter. An architecture can privilege them. A rectified linear unit acts coordinate by coordinate. Sparse coding rewards a small set of active coordinates. Non-negative representations forbid cancellation across positive and negative values. A downstream component may read one neuron directly. Under those constraints, rotating the space without redesigning the computation changes the system.

An axis earns a local interpretation when three things agree. Its activation predicts a property on held-out cases. Directly changing it produces a selective downstream effect. The relationship remains stable across reasonable prompts, data shifts and retraining seeds, or the instability itself is explicitly scoped. Even then, the right statement is functional: this coordinate participates in this computation under this architecture. It is not “coordinate 731 is the concept” in every equivalent description of the system.

flowchart TD
  A["The constellation that moved<br/>without changing"] --> B["The constellation survives the<br/>coordinate change"]
  B --> C["Similarity depends on the ruler"]
  C --> D["A readable direction is not<br/>yet a mechanism"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Similarity depends on the ruler

Place two arrows tail to tail. When they point in the same direction, their dot product is positive and large if both are long. When they are perpendicular, the dot product is zero. When they point in opposing directions, it is negative. The dot product therefore combines two ingredients: directional alignment and magnitude.

For vectors x and y, the Euclidean dot product is the sum of coordinate-wise products. Its value is also ||x|| ||y|| cos θ, where θ is the angle between the arrows. Cosine similarity divides out the two lengths and keeps only the angle. This is useful when magnitude is nuisance. It is destructive when magnitude carries confidence, frequency, salience or a logit-relevant signal. Cosine similarity is not a discovered law of meaning; it is a modelling decision to treat direction as the relevant relation.

The metric is part of the claim

The ordinary dot product gives every coordinate equal status after units have been chosen. That is sometimes sensible. Suppose one axis records metres and another seconds. Adding their products without a conversion rule is meaningless. Even when every coordinate is dimensionless, treating each axis equally still encodes an assumption.

A more general inner product can be written xᵀMy, where M is a positive-definite matrix. The matrix can weight some directions more heavily or account for correlations. In effect, it installs a ruler. Once the ruler changes, angles, projections and neighbours may change too.

Similarity is not one relation

Cosine is symmetric: cos(x, y) = cos(y, x). Many semantic and operational relations are not. “Surgeon” implies “person” more readily than “person” implies “surgeon”. A query can be adequately answered by a detailed document even when the document would be a poor query for the original phrase. A cause can predict an effect without the effect identifying one cause. Treating all of these as undirected closeness discards structure before the model is evaluated.

Similarity also changes with the comparison set. “Mercury” may be closest to “Venus” in an astronomy corpus, to “cadmium” in a toxicology corpus, and to “Ford” in a list of historic car brands. Nearest-neighbour search asks which candidate wins among those supplied. Add a new candidate or filter the index and the answer can change even when every vector and metric stays fixed.

Recent work on word similarity has explored classifier confusion as an alternative that can condition the comparison on selected features and represent asymmetry or polysemy more directly.[1] The broader lesson is not that one replacement metric is universally superior. It is that the relation required by the decision should choose the scoring geometry, rather than cosine choosing the relation by default.

Directions can encode relations without defining concepts

Vector arithmetic becomes interesting when differences repeat. If the displacement from one city to its country resembles the displacement from another city to its country, a shared relation direction may exist. The familiar analogy pattern subtracts one vector, adds another and searches for a point near the resulting location. Geometrically, it asks whether several examples form approximately parallel sides of parallelograms.

This can work because a training objective arranges many co-occurrence constraints jointly. A stable offset is a compressed regularity across those constraints. It does not follow that the relation is stored in one pristine axis, that every pair obeys it, or that the arithmetic expresses logical composition. Frequency, morphology, social bias and corpus domain can all bend the parallelogram.

A useful test therefore begins with many held-out counterfactual pairs, not one memorable example. Estimate a direction on the training pairs, measure angular dispersion on held-out pairs, compare with label-shuffled pairs, then test whether moving along the direction changes the relevant downstream output. A repeated offset supports a Level 1 geometric claim. It reaches a stronger warrant only when access and use are also demonstrated.

Why learned vectors develop useful geometry

Early word-embedding systems made vector relations unusually visible. Word2vec learned vectors useful for similarity and regularity tasks, while GloVe tied its objective to global co-occurrence statistics.[2][3] Levy and Goldberg then showed that skip-gram with negative sampling implicitly factorises a shifted pointwise-mutual-information matrix.[4] This matters because it replaces a mystical story with a mechanism: dot products become useful because the training objective pushes frequently associated word-context pairs towards values related to corpus statistics.

The result is not “meaning stored as coordinates”. It is a low-dimensional arrangement whose relations support tasks shaped by the objective, corpus and evaluation. A direction can be stable enough to predict a linguistic contrast without being a dictionary definition. An analogy can work for one relation and fail for another. A neighbour can reflect topical association rather than synonymy.

Cross-lingual work has also reported directions associated with latent grammatical concepts across typologically diverse languages.[5] Transfer across languages is stronger evidence than a single-dataset probe because it narrows some shortcut explanations. It still establishes neither a universal concept axis nor downstream causal use without the corresponding interventions.

Comparing two spaces requires an invariance choice

Train the same architecture twice and its useful geometry may appear in different coordinates. Comparing neuron 731 in one run with neuron 731 in another can fail even when both models organise examples similarly. One response is to align the spaces with an orthogonal map. Another is to compare pairwise similarities among the same examples, which ignores the original basis. Each method decides in advance which transformations count as “the same representation”.

Kornblith and colleagues analysed this problem and introduced centred kernel alignment as a representation-similarity measure with a particular invariance profile.[6] Their broader contribution is methodological: a similarity measure that is invariant to too many transformations can declare substantively different spaces equivalent, while one tied too closely to coordinates can miss clear functional correspondence. Representation comparison is therefore another version of the paper’s central rule. State the preserved relation before reading meaning from the score.

Context turns a point into a trajectory

A static embedding gives one vector to “bank”. A contextual model computes a vector for this occurrence of “bank” in this sentence, at this token position and this layer. “She deposited cash at the bank” and “the river crossed the bank” can begin near a shared lexical region and diverge as context is integrated. Different layers may emphasise different relations. Pooling several token vectors introduces another operation.

Ethayarajh found that contextual representations in studied models were anisotropic rather than uniformly spread across directions.[7] That result makes raw cosine harder to interpret because many vectors can share a large common component. Centering, whitening or removing dominant directions may change rankings, but each repair installs a new ruler. A contextual embedding is not a timeless word meaning; it is a state produced by a configured computation.

High dimension changes intuition

In two dimensions, random directions can have almost any angle. In a high-dimensional isotropic space, independently sampled unit vectors concentrate near perpendicular. Under the idealised assumptions, their cosine has mean zero and a standard deviation of roughly 1/√d. At one thousand dimensions, a cosine of 0.10 is already several standard deviations from the random baseline.

This does not rescue cosine as universal meaning. Learned spaces are not usually isotropic, points are not independent and preprocessing changes the baseline. The lesson is narrower: a raw number such as 0.72 has no stable interpretation without a reference distribution for that model, layer and dataset.

A readable direction is not yet a mechanism

Suppose a researcher trains a linear classifier on hidden vectors and predicts whether a sentence is past or present tense with high accuracy. The result is often described as “tense is encoded in the representation”. That phrase compresses several claims. The labels may be recoverable. A simple readout may recover them. The original model may use the same direction. Changing that direction may change behaviour. These statements are not equivalent.

Probes are valuable because they ask whether a property is accessible to a specified decoder. Hewitt and Manning’s structural probe asked whether syntactic tree distances could be recovered after a linear transformation of contextual word representations.[8] Hewitt and Liang showed why probe capacity and control tasks matter: a powerful probe can learn structure that the representation does not make especially accessible.[9] The right conclusion from a good probe is therefore conditional: this property is decodable by this class of readout on this held-out distribution.

Projection as intervention

Projection turns the distinction into an experiment. If a unit direction d is claimed to carry a property, the matrix P = I − ddᵀ removes the component along that direction. Apply P to a representation and measure what changes. Iterative null-space projection, amnesic probing and later closed-form erasure methods build more elaborate versions of this idea.[10][11][12]

A behaviour change is stronger evidence than decodability because the representation has been altered before the model acts. Yet intervention does not automatically settle the mechanism. Removing one direction can also remove correlated information. The edited vector may move off the distribution on which later layers were trained. Redundant features may reconstruct what was erased. A linear eraser can eliminate every linear decoder while nonlinear information remains.

Recent evaluations of causal probing methods report a trade-off between completeness, which asks whether the target information was thoroughly removed, and selectivity, which asks whether unrelated information was preserved.[13] This is the intervention version of the ruler problem. An eraser encodes assumptions about what counts as the concept and what counts as minimal damage.

Three checks make an intervention interpretable

Completeness asks whether the target information actually disappeared. Retest with fresh linear probes, nonlinear probes and counterfactual examples that were not used to learn the eraser. If a decoder immediately recovers the property, an unchanged behaviour cannot tell us whether the model ignored the property or the intervention failed to remove it.

Selectivity asks what else was damaged. Compare performance on matched control tasks, distances to unedited vectors and removal of random subspaces with the same dimension and norm effect. A large target-task drop accompanied by a large general degradation is not a surgical mechanism result. It may be ordinary corruption.

Plausibility asks whether the edited state resembles one the downstream network could have encountered. A projection can create a mathematically valid vector that lies far from the activation distribution. Later layers may respond unpredictably because the intervention is off-manifold. Counterfactual activation replacement, generative editing or small dose-response steps can reduce this problem, but none removes it automatically. An intervention is evidence only after the intervention itself has been validated.

Some concepts are not single directions

The attraction of a direction is simplicity. It lets us classify, steer and erase with one vector. Park, Choe and Veitch formalised versions of the linear representation hypothesis using counterfactuals and showed why the choice of inner product is fundamental.[14] Later work extended the account towards categorical and hierarchical geometry.[15] These results strengthen the case for carefully scoped linear structure.

They do not imply that every useful feature is one-dimensional. Engels and colleagues report irreducibly multi-dimensional circular features, including representations related to days and months that participate in modular computations.[16] A circle cannot be reduced to one globally ordered direction without cutting it. “Monday after Sunday” is local movement around a loop, not movement to a higher scalar value.

The practical boundary is clear. A direction is an empirical hypothesis about geometry, not the default ontology of concepts. It should earn its role by prediction, intervention and transfer.

The representation warrant ladder

The word “encoded” has become too elastic. To make it useful, separate five levels of warrant. Each level permits a stronger sentence and demands a stronger test. This ladder is a practitioner synthesis, not a claim that the scientific literature has adopted one standard vocabulary.

stateDiagram-v2
  [*] --> Claim
  state "The origin is not innocent" as Claim
  state "When an axis can earn local<br/>meaning" as Test
  state "The metric is part of the claim" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The projection notebook

The quickest way to internalise vector geometry is to change one assumption and watch what survives. The notebook below contains three operations. Rotation changes the coordinate basis while preserving Euclidean dot products. Axis weighting changes the ruler and can flip neighbours. Projection erasure removes one declared direction and reveals how much of the observed relation depends on it.

How to use the artefact

The browser lab is immediately runnable. Begin at axis weight one and rotate the space. The displayed coordinates move while both cosines stay fixed. Next change the axis weight. The road and river ranking flips because the metric has changed. Finally remove the purple direction. The remaining vectors show what a single projection preserves and destroys.

For a real model, replace the three toy vectors with a matrix of held-out representations. Define a candidate direction from training-only counterfactual pairs. Run the same sequence with three additions: a calibrated probe, matched control directions and downstream task evaluation. Keep the model version, layer, token selection, normalisation and dataset fixed in the experiment manifest.

from __future__ import annotations

from math import cos, sin, sqrt, radians
from typing import Dict, Tuple

Vector = Tuple[float, float]

VECTORS: Dict[str, Vector] = {
    "bridge": (1.00, 1.00),
    "river": (0.20, 1.76),
    "road": (1.67, 0.56),
}


def dot(a: Vector, b: Vector) -> float:
    return a[0] * b[0] + a[1] * b[1]


def norm(a: Vector) -> float:
    return sqrt(dot(a, a))


def cosine(a: Vector, b: Vector) -> float:
    denominator = norm(a) * norm(b)
    if denominator == 0:
        raise ValueError("Cosine is undefined for a zero vector")
    return dot(a, b) / denominator


def rotate(a: Vector, degrees: float) -> Vector:
    theta = radians(degrees)
    c, s = cos(theta), sin(theta)
    return (c * a[0] - s * a[1], s * a[0] + c * a[1])


def stretch(a: Vector, x_weight: float) -> Vector:
    if x_weight <= 0:
        raise ValueError("Axis weight must be positive")
    return (x_weight * a[0], a[1])


def project_out(a: Vector, direction: Vector) -> Vector:
    denominator = dot(direction, direction)
    if denominator == 0:
        raise ValueError("Projection direction cannot be zero")
    scale = dot(a, direction) / denominator
    return (a[0] - scale * direction[0], a[1] - scale * direction[1])


def transform(
    a: Vector,
    *,
    degrees: float = 0.0,
    x_weight: float = 1.0,
    erase: bool = False,
    direction: Vector = (1.0, 0.73),
) -> Vector:
    value = stretch(a, x_weight)
    if erase:
        value = project_out(value, direction)
    return rotate(value, degrees)


def ranking(degrees: float, x_weight: float, erase: bool) -> list[tuple[str, float]]:
    transformed = {
        name: transform(vec, degrees=degrees, x_weight=x_weight, erase=erase)
        for name, vec in VECTORS.items()
    }
    query = transformed["bridge"]
    scores = [
        (name, cosine(query, vec))
        for name, vec in transformed.items()
        if name != "bridge"
    ]
    return sorted(scores, key=lambda item: item[1], reverse=True)


def main() -> None:
    baseline = ranking(degrees=0, x_weight=1.0, erase=False)
    rotated = ranking(degrees=73, x_weight=1.0, erase=False)
    assert all(abs(a[1] - b[1]) < 1e-12 for a, b in zip(baseline, rotated))

    river_ruler = ranking(degrees=0, x_weight=0.5, erase=False)
    road_ruler = ranking(degrees=0, x_weight=3.0, erase=False)
    assert river_ruler[0][0] == "river"
    assert road_ruler[0][0] == "road"

    direction = (1.0, 0.73)
    erased = {name: transform(vec, erase=True) for name, vec in VECTORS.items()}
    assert all(abs(dot(vec, direction)) < 1e-12 for vec in erased.values())

    print("Baseline:", baseline)
    print("After a 73 degree rotation:", rotated)
    print("First coordinate weighted 0.5x:", river_ruler)
    print("First coordinate weighted 3.0x:", road_ruler)
    print("After projection erasure:", ranking(0, 1.0, True))


if __name__ == "__main__":
    main()

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The constellation that moved without changing
  M->>E: The origin is not innocent
  E-->>M: compare rival explanations
  E->>D: Grant semantic authority only to geometry that survives
  D-->>Q: revise scope or act

Grant semantic authority only to geometry that survives

When a plot, probe or retrieval score appears to reveal a concept, do not ask only whether the picture looks persuasive. Ask what operation made the relation visible and what would remain after changing that operation. The decision is not whether vectors are meaningful in the abstract. The decision is how much authority a particular geometric observation should receive.

1. Name the represented object. Record model, version, layer, token or pooled unit, context, preprocessing and dataset. “The embedding” is not specific enough.
2. Declare the ruler. State the inner product, normalisation, centring, whitening, candidate population and baseline distribution. Treat each as part of the hypothesis.
3. List the expected invariances. Decide which rotations, rescalings, translations or permutations should leave the claim unchanged. A result that fails its own invariance test is a coordinate artefact.
4. Separate access from use. Use controlled probes for accessibility and matched interventions for causal uptake. Read back target effects, collateral effects and recovery.
5. Scope the semantic sentence. Say what the geometry supports for which task and counterfactual range. Do not promote a local, linear relation into a universal account of meaning.

A vector space is powerful because it turns relations into operations. Direction enables comparison. Dot products score alignment. Projection isolates a component. Bases let us rewrite the same object. None of these operations carries its own interpretation. The responsible decision is to grant semantic authority only to geometry that survives its declared ruler, predicts downstream use and defeats plausible rival explanations.