Every representation is a wager about sameness

A representation is any state used in place of something richer. A road graph stands in for streets. A customer record stands in for a changing person and relationship. A token sequence stands in for an utterance. An image embedding stands in for pixels. An activation vector stands in for prior computation. The substitute may be hand-designed, learned, symbolic, continuous or hybrid. In every case it makes a wager: these differences can be ignored; those differences must remain available.

Let a world state be w. A sensor or data process produces an observation x = h(w). An encoder produces z = φ(x). A decision rule then chooses a = g(z). The full path is:

The diagram is simple, but it locates an irreversible boundary. If φ maps two observations to the same z, no deterministic g can later treat them differently. If that merger joins states requiring different actions, the downstream error is not a reasoning failure. It is a representational collision. The data-processing principle supplies the broad intuition: processing can reorganise or discard information, but it cannot recreate information that is no longer present from the same input alone.

Rate-distortion theory begins with the same uncomfortable requirement. Lossy coding is meaningful only after a fidelity criterion or distortion measure says which errors matter.¹ The information bottleneck similarly seeks a short code for one variable that preserves information relevant to another.² Representation-learning research generalises the practical ambition: transform data so useful information becomes easier for later predictors to extract.³ None of these foundations gives a universal distortion measure. They make its absence visible.

Task equivalence comes before latent distance

Suppose a task T maps world states to the outcomes or actions that matter. Two states are task-equivalent when every distinction between them is irrelevant to the declared decision under the declared context. Write this as w ~T w′. An exact task-sufficient representation preserves enough information for some decoder to recover the task:

Real systems rarely meet exact sufficiency. Observations are partial, labels are noisy, tasks conflict and finite models impose approximation. The equation still exposes the right failure question: when the system errs, did the representation retain a usable distinction, or had it already placed unlike states on top of each other?

Missing from the observation is different from erased by the encoder

The ambulance example contains two possible failures that should not be confused. The road sensor may never observe that the bridge is closed. In that case the observation process h is blind, and no encoder can preserve the missing fact. Alternatively, the sensor may report the closure while the encoder drops road status to save space. That is a failure of φ. The corrective action differs: improve sensing in the first case; change the representation contract in the second.

A third failure occurs when the representation contains the distinction but the decoder cannot access it within its operating budget. A billion-dimensional state may technically retain everything, while the deployed linear head, nearest-neighbour index or bounded planner cannot isolate the relevant relation from available examples. This is why sufficiency must name an allowed decoder family and resource envelope. Information that requires an impractical rescue operation is not operationally equivalent to information arranged for use.

The boundary also matters for governance. An investigation should not blame “the model” as one undifferentiated object. It should ask whether the evidence was observed, normalised, represented, retrieved and consumed. A missing value, identity conflation, stale state, lossy embedding and weak decision head can produce the same wrong output through different mechanisms. The representation stress test belongs between data-quality checks and end-to-end task evaluation because it isolates one of those mechanisms.

Latent distance has no task meaning until a preservation rule gives it one. Cosine similarity, Euclidean distance, graph adjacency and token attention are mathematical relations. They become operationally meaningful only when evidence connects them to a world relation such as substitutability, reachable cost, shared outcome, temporal succession or causal response.

Thought experiment: one parcel, two decisions

A parcel-handling system learns to ignore colour because colour does not affect grip pressure. Red and blue versions of the same mass and fragility should map together. The invariance improves sample efficiency and protects the controller from a packaging redesign.

Now the task changes. Red packaging denotes a hazardous material that must use a separate route. The physical parcel is unchanged. Only the decision changes. The old invariance is now destructive because the representation erased the very signal the routing decision needs. The thought experiment varies one causal feature, the task, while holding the observations constant.

flowchart TD
  A["The bridge the map forgot"] --> B["On this page"]
  B --> C["Every representation is a<br/>wager about sameness"]
  C --> D["What must survive compression"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#B96D00,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

What must survive compression

Every finite representation is selective. Even an apparently lossless store selects a schema, precision, time model and identity rule. Learned embeddings compress more visibly, but the same obligation applies to event tables, ontologies and feature vectors. The engineering problem is not to avoid distortion. It is to allocate distortion where consequences are low.

Three relations form the minimum contract

A practical representation specification should begin with pairs and transformations, not dimensions. The first class contains must-separate pairs: two states for which the correct action, admissible action set or expected consequence differs. The second contains should-merge pairs: states changed only by declared nuisances. The third contains neighbourhood or transition relations: states whose relative order, reachability, cost or successor structure must survive even when no single label captures it.

The following diagnostic ledger makes that contract testable. Let C be the weighted rate of must-separate collisions. Let F measure fragmentation across should-merge variants. Let N measure distortion of required neighbourhood or transition relations. Let S measure how much those failures amplify under declared shifts. A programme can combine them for prioritisation:

The ledger deliberately resists one-number theatre. Teams should retain the components, denominators and failing examples. Two representations with the same total can have opposite operational profiles. One may preserve critical separations but waste capacity on nuisances. Another may look compact while collapsing a rare, high-consequence state.

Multi-task systems need a portfolio, not a mythical universal code

A general representation is often asked to support many future tasks. That changes the contract but does not remove it. The relevant set becomes a portfolio of relations, with weights for current tasks, plausible future tasks and irreversible harms. A representation that serves grip control, hazard routing and inventory counting may need to retain mass, fragility, hazard marking and identity while remaining insensitive to lighting. Compression is still possible, but the equivalence classes become finer.

There are three honest strategies. The first keeps a rich shared representation and accepts higher storage, sample or decoder cost. The second maintains several views, each with a declared purpose, such as semantic similarity, event state, identity graph and temporal sequence. The third learns a base representation that can be adapted with task-specific supervision. None guarantees that an unforeseen task can recover discarded information. “Foundation” describes reuse ambition, not immunity from representational choice.

Multiple views also reduce pressure to force unlike relations into one metric. Documentary relevance need not share a geometry with legal identity. Temporal succession need not be encoded as cosine proximity. A graph can preserve reachability while an embedding supports approximate semantic retrieval, and a typed table can preserve authoritative state. Their outputs can meet in a decision-specific context packet without pretending that one vector is the world.

This portfolio creates a new obligation: cross-view consistency. Two views may refer to the same entity at different times, use different identifiers or disagree about status. The system therefore needs explicit identity, valid-time and provenance links. Otherwise representational richness merely moves distortion into the joins. The contract should state not only what each view preserves, but how evidence crosses their boundaries without silent conflation.

The same world supports several valid geometries

A city has no single correct low-dimensional map. A geographic map preserves bearing and distance. A travel-time map stretches congestion and bridge crossings. A flood-response map groups locations by elevation, drainage and accessible shelter. Each deforms the same physical world to keep a different relation usable. The deformation is not an embarrassment. It is the purpose.

This task relativity does not mean anything goes. Once the target relation and operating conditions are declared, the representation faces empirical tests. A travel-time map that ignores bridge closures is wrong for dispatch. A flood map that groups by postcode while separating adjacent elevations is wrong for evacuation. Context supplies the criterion; measurement judges the result.

Invariance, equivariance and identity

Invariance means a declared transformation should not change the representation, or at least should not change the decision. Equivariance means the representation should change in a predictable corresponding way. Rotating an object image may leave its category invariant while rotating its pose representation. Temporal progression should usually move state, not disappear. Identity should persist across harmless formatting changes while remaining sensitive to genuine entity conflicts.

Achille and Soatto connect minimal sufficient representations with invariance to nuisances under explicit assumptions.⁴ Contrastive learning often induces invariance through augmentations, but the augmentation policy itself chooses what information may be removed. Xiao and colleagues show why this choice is task-dependent: colour invariance can help one task and damage another.⁸ An augmentation is therefore a policy statement about equivalence, even when written as a data pipeline.

Representations learned across purposeful interventions and action consequences may transfer more reliably than representations organised by observational similarity alone, because interventions expose which variations leave a mechanism stable and which change outcomes. Causal representation learning develops versions of this ambition.¹⁵ It remains an open engineering hypothesis at the scale of general systems: identifiability depends on assumptions, interventions are incomplete, and the variables useful for one decision may not form a unique human-readable causal code.

How representations fail while benchmarks look healthy

Representation failures often hide because the training distribution rewards them. If a hospital watermark predicts a diagnosis, an image model may encode the watermark. If a premium account type correlates with a dispute category, an embedding may organise cases around product tier. If successful routes happen to use one bridge during training, a state encoder may treat bridge status as irrelevant. The model is not irrational. It is exploiting the easiest stable-looking relation supplied by the sample.

Shortcut geometry makes the wrong relation easy

Ilyas and colleagues give evidence that highly predictive features can also be non-robust, helping explain adversarial vulnerability.⁶ Geirhos and colleagues place this within the broader phenomenon of shortcut learning, where systems rely on decision rules that work on standard benchmarks but fail under changed conditions.⁷ The representation view adds a useful causal location: shortcuts matter because the encoder makes an unstable feature accessible, often more accessible than the intended relation.

Accessibility is distinct from presence. A representation may retain fragility somewhere in a high-dimensional vector while placing colour on a clean linear axis. A cheap downstream head will choose colour. An unconstrained probe might later recover fragility and tempt us to declare the representation adequate. Operationally, the relevant question is whether the required information is available to the actual decision rule within its data, compute and regularisation budget.

Probe accuracy can over-credit the representation

A powerful probe can learn a task rather than merely reveal an encoded variable. Hewitt and Liang introduced control tasks to estimate this risk in linguistic probing.¹⁴ Representation similarity measures also answer narrower questions. Centred kernel alignment can compare certain relational structures across networks and is invariant to particular transformations, but similarity between two representations is not proof that either preserves the application relation.¹³

Four attractive certificates that do not settle the question

Good reconstruction shows that a decoder can reproduce chosen input detail. It may reward pixels, wording or sensor noise that the decision should ignore, while giving little weight to a rare state transition. Reconstruction is useful when the downstream task needs broad fidelity, but it does not identify the correct distortion budget by itself.

High mutual information with the input shows retention, not organisation. An identity map maximises retention and performs no abstraction. Conversely, aggressive minimality can improve invariance while erasing information needed by a second task. Information bottleneck objectives become decision-relevant only through the selected target variable, assumptions and estimators.

Clean clusters can be created by labels, acquisition sites or protected attributes. A two-dimensional projection can also invent apparent separation through its own distortion. Cluster compactness should be evaluated against must-separate and should-merge cases, then checked in the original representation and under interventions.

Linear probe success establishes accessibility to one restricted decoder under one sample. That can be valuable, especially when the deployed head is also linear. It does not show that the variable causes the model's decision, that it remains accessible after shift, or that a competing shortcut is not easier. The right control compares probes, actual heads, interventions and counterfactual pairs.

These are not useless measurements. Each illuminates one property. The mistake is promotion: reconstruction becomes understanding, retained information becomes usability, geometry becomes semantics, and probe accuracy becomes causal mechanism. A preservation contract prevents that promotion by asking every metric which declared relation it tests.

Negative control: rotate the latent and keep the behaviour

Imagine a two-dimensional representation whose horizontal axis is mass and vertical axis is fragility. It looks pleasingly disentangled. Rotate every point by 37 degrees and rotate the downstream weights accordingly. Individual axes no longer align with named factors, but pairwise Euclidean distances, separability and decisions remain unchanged. The rotated representation looks less interpretable while being functionally equivalent for this task.

This is a serious negative control against an easy story: neat axes are not necessary for useful representation. More generally, Locatello and colleagues show that unsupervised disentanglement is not identifiable without inductive biases on models and data, and their large experimental study found substantial variation across methods and seeds.⁵ Human-readable factorisation may be valuable for inspection or editing, but it is a separate requirement that must be stated.

Underspecification hides rival maps behind one score

Two models can achieve the same validation accuracy while learning different representations and failing on different deployment slices. D'Amour and colleagues call this underspecification: the pipeline's available evidence does not uniquely determine behaviour that matters beyond the training domain.¹⁰ A single held-out score cannot tell whether the model used bridge status, river proximity or neighbourhood identity when all three happened to agree.

The remedy is not to demand one uniquely true latent. Several representations may be equally valid for a bounded task. The remedy is to force rival representations to disagree before release. Intervene on the suspected nuisance. Break the correlation. Construct must-separate pairs. Change acquisition conditions. Test rare topology. Compare outcome stability and inspect the failing examples.

Invariance can fail by being too weak or too strong

Weak invariance leaves the system sensitive to harmless changes. Strong invariance erases useful variation. Contrastive methods show both risks because their positive-pair construction declares two views equivalent. If crops remove the object part needed for fine-grained classification, the objective asks the encoder to forget it. If colour is always changed, colour-sensitive downstream tasks inherit a handicap.

Generic domain-generalisation objectives do not remove the need for a specified shift. In a careful benchmark study, Gulrajani and Lopez-Paz found that several domain-generalisation methods did not consistently beat well-tuned empirical risk minimisation under their evaluation protocol.⁹ The boundary is important: “invariance” is not a free robustness token. It succeeds only when environments expose the right variation and the preserved relation matches deployment.

Stress-test the latent before trusting the policy

A useful evaluation asks what the representation makes easy, impossible and unstable. It should be run before teams spend weeks tuning a downstream model. The following browser lab uses a synthetic parcel task because its ground-truth factors are explicit. It compares four representations under a controlled nuisance shift.

Each parcel has mass, fragility and colour. Grip action depends on mass and fragility. Colour is correlated with fragility during training but is not causally relevant to grip. The task-aware representation encodes mass and fragility. The shortcut representation substitutes colour for fragility. The overcomplete representation keeps all three. The rotated representation is an orthogonal rotation of the task-aware one.

The positive case is the task-aware representation. It should retain high shifted accuracy, low must-separate collision and zero colour-fragmentation because colour never enters its coordinates. The negative case is the shortcut. It can score well when the training correlation remains stable, yet lose accuracy when colour is randomised or reversed. The rotated task-aware representation should track the task-aware one because rotation preserves its pairwise geometry.

The diagnostic win is not merely that one model fails. The lab identifies why: the shortcut's nuisance displacement is large, its action-neighbour purity changes under intervention, and its must-separate collisions rise when colour stops standing in for fragility. Those signals point upstream to the representation contract rather than downstream to a bigger classifier.

A seven-step stress protocol

Start by freezing the decision and consequence boundary. A representation test cannot be designed while “the task” still means anything from similarity search to final approval. Name the consumed output, who acts on it, and which mistakes are materially different. This fixes the unit of must-separate pairs.

Next, build a relation set from real mechanisms and plausible failures. Include ordinary pairs, rare critical pairs, near-boundary cases and contradictions. For each must-separate pair, record why the action differs. For each should-merge pair, record the nuisance transformation. For ordered or relational tasks, include triplets, paths or state transitions rather than forcing everything into independent rows.

Third, choose matched baselines. Compare the learned representation with raw or lightly normalised features, a known shortcut, a richer representation and a deliberately transformed equivalent such as the rotated latent. Baselines prevent a flattering absolute score from hiding that a simpler map already preserves the relation, or that the metric punishes harmless reparameterisation.

Fourth, test accessibility with the actual downstream family. Hold training data, decoder capacity, optimisation budget and evaluation cases constant. A representation that wins only when given a far larger head has not necessarily made the task easier. Report learning curves as labels increase, since sample efficiency is often part of the representation's purpose.

Fifth, intervene one nuisance at a time. Change colour without changing fragility, wording without changing event state, acquisition site without changing pathology, or bridge status without moving locations. Paired interventions have more diagnostic power than a broad out-of-distribution set because they expose which causal feature changed.

Sixth, inject representation-specific failures. Remove a relation, coarsen time, merge identities, perturb units, drop provenance or create a false neighbour. Confirm that the metrics and release gate react. A test that cannot detect a known violation is not evidence that the clean system is sound.

Finally, preserve the failure ledger. Store the encoder version, input transformation, relation-set version, decoder, thresholds, random seeds, failing case identifiers and unsupported regions. Re-run it when data collection, task policy, schema, model or operating environment changes. Representation quality is a maintained claim, not a property conferred forever at pre-training.

const representations = {
  taskAware: p => [p.mass, p.fragile],
  shortcut: p => [p.mass, p.colour],
  overcomplete: p => [p.mass, p.fragile, 0.5 * p.colour],
  rotated: p => rotate37([p.mass, p.fragile])
};

// Positive case: taskAware should survive a colour intervention.
// Negative case: shortcut should degrade when colour stops predicting fragility.

A payment-dispute representation under a wording shift

Consider a synthetic dispute-routing service. It receives customer text, transaction events and authentication records. The required route depends on payment rail, settlement state, authentication path, event order, customer assertion and signed contradictions between sources. During development, one mobile-app template happens to correlate strongly with card-not-present fraud. A text embedding can achieve excellent held-out performance by placing template wording near the fraud queue.

The app is redesigned. Wording changes, but payment mechanisms do not. The template-centred representation now separates semantically equivalent disputes and merges cases whose new language looks alike. A representation organised around typed event state, temporal order and evidence conflict is less elegant as a single generic embedding, but it preserves the relations the routing decision consumes.

This does not prove that typed state always beats learned embeddings. Text can carry essential customer meaning, and event schemas can omit relevant nuance. The design implication is compositional: keep documentary similarity, governed case state, temporal relations and evidence provenance as distinguishable structures, then test the route under controlled paraphrase, channel, template and acquisition shifts.

The representation decision record

Before selecting an embedding model, graph, feature store or state encoder, complete the following record. It turns “we need better representations” into a falsifiable architecture decision.

The record should be replayed whenever the consumer, decoder or operating support changes. A representation that preserved the required relation for one policy may fail after a tighter latency budget forces a weaker decoder, or after a new action makes a previously harmless collision costly. Version the must-separate pairs and nuisance transformations alongside the encoder so that an architecture change cannot silently inherit an obsolete certificate.

Release evidence should be paired at the decision boundary. Compare the incumbent and candidate representation on the same counterfactual cases, using the actual decoder and downstream thresholds. Report collision rates for critical pairs, nuisance sensitivity and unsupported-state abstention separately. Aggregate accuracy is retained as context, not allowed to cancel a rare violation with high consequence.

Formal accounts help by naming the relation. Approximate abstractions can condense states while bounding behaviour loss under stated assumptions.¹² Bisimulation groups states by reward and transition behaviour.¹¹ Bayes-sufficient representations make the target loss-dependent: zero-one loss preserves the Bayes class, squared loss the conditional mean, and proper scoring rules the predictive distribution. These results matter because they declare what must survive and under which assumptions. They are not licences to call every smooth latent a world model.