Number, Measurement and Representation

The room that moved without moving

At 08:12, a control-room dashboard marks storage room C4 as the second-highest heat risk on a site. Four fields support the ranking: 31, (18, 6), 7 and 0.64.

The first number is a temperature in degrees Celsius. The pair is the room’s location on a site map. The third is a fault code. The fourth is a modelled probability of spoilage within six hours. Every field is numerical. None has the same meaning, and none supports the same operations.

During a software migration, the temperature display changes to Fahrenheit, the site map is rotated to align north with the top of a new screen, fault codes are reissued, and the probability service starts returning log odds. The physical room, sensor state, fault and forecast have not changed. Yet the dashboard now ranks C4 ninth.

The bug is not in any conversion. Each new value can encode the same information as the old one. The bug lies downstream. A threshold remained at 30 after Celsius became Fahrenheit. A routing rule still used the first coordinate as a proxy for distance. The fault code entered a weighted average as if larger identifiers meant greater severity. A probability threshold of 0.6 was applied directly to log odds.

Numbers inherit no universal meaning. A number can measure, locate, label or express uncertainty. Its legitimate use depends on the structure that produced it and the transformations under which the intended claim should survive.

The hidden assumption in a clean dashboard

A dashboard encourages a simple intuition: once observations have become numbers, they can be sorted, averaged, thresholded and combined. That intuition is sometimes correct. Lengths measured in metres may be added. Probabilities may be marginalised. Coordinates may be transformed. It fails when the operation does not belong to the representation.

The hidden assumption is that the numerical surface preserves the empirical relation we care about, and that the next operation preserves it again. A display can look precise while breaking either bridge.

This leads to the paper’s central claim: conversion is not preservation unless the downstream rule transforms too. The same empirical content may have many valid expressions. A defensible decision must depend on what those expressions preserve, not on their accidental numerals.

Four instruments, four contracts

The words quantity, coordinate, code and probability are often used as if they named four file formats. They name four different ways of making a phenomenon tractable. Each has a target, an admissible transformation and a set of operations that survive that transformation.

Quantity: comparison through a reference

The International Vocabulary of Metrology defines a quantity as a property with a magnitude expressible as a number and a reference. The current SI framework also treats a reported measurement result as an estimated value accompanied by uncertainty, not as a naked exact number.^{1, 2, 3} A temperature reading therefore contains at least a target quantity, a unit, a measurement procedure, a value and an uncertainty claim.

A quantity is not just a numeral. “31” becomes a temperature only through a reference such as degrees Celsius and a bridge from sensor behaviour to thermodynamic temperature. Even then, the number may describe the sensor, a local air pocket or an inferred room average. The measurand must be named.

Stevens’s influential scale typology distinguished nominal, ordinal, interval and ratio scales by their admissible transformations.⁴ The typology is not the final word on measurement, but its durable lesson is useful: scale type controls valid algebra. An order can survive every monotone relabelling while a difference cannot. An interval can survive a change of origin and unit while a ratio cannot. Additive conjoint measurement went further by showing that attributes without direct physical concatenation can admit numerical representation when observable comparisons satisfy demanding axioms.⁵

Coordinate: location relative to a frame

A coordinate is not a property carried by an object in isolation. It locates an object relative to an origin, axes, basis, chart or reference frame. Rotate the map and the coordinates change. Translate the origin and they change again. The relation of the room to an exit can remain fixed.

Coordinates are descriptions relative to a frame. Their power comes from exposing geometry to calculation. Their danger comes from treating frame-dependent components as if they were intrinsic properties.

This distinction now appears explicitly in machine learning. Equivariant architectures are designed so that transforming an input produces a corresponding transformation of internal or output representations, while invariant outputs remain unchanged where the task requires it.^{6, 7} The design question is not “can the model ignore rotation?” It is “which parts should ignore it, and which should move with it?”

Code: a designed partition of possibilities

A code associates distinctions with symbols. A fault may be represented as 7, FAN_STALL, a bit pattern or a sentence. If the mapping is one-to-one and shared, the receiver can recover the selected distinction. That does not make the code’s numeric order, spacing or internal fragments meaningful.

Shannon’s communication theory deliberately separated the engineering problem of transmitting selected messages from the semantic question of what those messages mean.⁸ This separation remains essential. A code can preserve decodability while destroying neighbourhood, morphology, emphasis or context.

Codes preserve distinctions, not meaning. Meaning may be carried by a code in a larger system, but it does not follow from the code values alone.

Learned codes add another complication. A latent coordinate may predict a concept without uniquely representing it. Locatello et al. showed that unsupervised disentanglement is not identifiable without inductive biases in the model and data.¹⁰ Several internal representations can explain the same observations. A neat axis in a latent space is therefore evidence about a chosen model and probe, not automatic discovery of nature’s own variables.

Probability: uncertainty attached to a proposition

A probability is neither a physical amount inside an event nor a decorative confidence badge. It is a formal assignment to an event or proposition under a model, information state and sample space. It supports operations such as conditioning, marginalisation, expectation and scoring. Those operations require the event and model to remain clear.

Probability is a claim about uncertainty under a model. The value 0.64 is incomplete until we know: probability of what, within which horizon, conditional on which evidence, for which population, estimated how, and evaluated under what deployment conditions?

Modern neural classifiers can be miscalibrated even when accurate, and calibration may degrade under dataset shift.^{13, 14} This matters because a decision threshold combines probability with losses. If unnecessary inspection costs 1 unit and missed spoilage costs 9, an expected-loss rule may justify intervention above 0.1, not 0.5. “High probability” is not a decision rule.

What survives a change of representation

The four instruments now share one deeper question: what must remain unchanged when the representation changes? The answer is not always a value. It may be an order, distance, identity, decoded message, probability distribution or action.

A useful formal ideal begins with an empirical state e and a representation R(e). Let g be an admissible transformation of the representation: a unit conversion, coordinate change, label permutation or invertible probability parameterisation. Let A be a decision rule with parameters θ, such as a threshold or codebook.

The notation g*(θ) means “transform the rule’s associated parameters coherently”. Celsius becomes Fahrenheit, so the temperature threshold must also become Fahrenheit. Probability becomes log odds, so the probability threshold must become log odds. A label code is permuted, so the semantic lookup must use the new codebook. The decision is representation-respecting when both sides agree for the cases that matter.

Decision invariance is the practical test. It asks whether the action belongs to the empirical relation or to an accidental feature of its expression. Exact equality is not always required. Compression, sampling and finite precision may justify a declared tolerance. What matters is that the permitted deviation follows from the representation contract rather than appearing by surprise.

Invariants, equivariants and discarded structure

An invariant does not change under the selected transformation. A route length is invariant under rigid rotation. Category identity is invariant under a consistent relabelling. A decoded message is invariant under a lossless recoding. The represented probability distribution is invariant under switching from probability to log odds, provided the transformation is invertible.

An equivariant object changes in a predictable way. Coordinate components rotate with the axes. A bounding box rotates with an image. A temperature value changes with its unit. Equivariance is not a defect. It is often the correct relation between representation and transformation.

Discarded structure is what the representation cannot recover. Rounding 31.47 °C to 31 °C discards precision. Mapping a continuous risk to red, amber or green discards within-band order. Tokenising text discards some candidate boundaries while highlighting others. Collapsing a distribution to its mean discards spread and tail shape. No later calculation can retrieve discarded structure without new assumptions.

A configured system: heatwatch

Consider a synthetic site-monitoring system called HeatWatch. It receives a temperature sensor value, a room coordinate, a fault code and a model probability. A planner proposes an inspection route. An authority rule approves dispatch when expected avoided loss exceeds travel and inspection cost.

The system can be correct at every component boundary and still fail as a whole. The sensor service may validly convert Celsius to Fahrenheit. The map service may validly rotate the site. The maintenance service may validly version its codebook. The model service may validly expose log odds. The compound failure arises when the orchestrator erases the types and assumes every field remains directly comparable to the old rule.

Failure case: the threshold survives while the queue moves

An engineer defines severity as the displayed temperature divided by its threshold. In Celsius, C4 scores 31 / 30 = 1.033, while D2 scores 10.4 / 10 = 1.040. D2 therefore goes first. A later interface migration converts the readings and thresholds correctly: C4 becomes 87.8 °F against 86 °F, and D2 becomes 50.72 °F against 50 °F. The alert predicates remain true, yet the ratios become 1.021 and 1.014. C4 now goes first. The queue reverses although every physical state and every threshold decision is unchanged.

The failure is subtler than forgetting to convert a threshold. Celsius and Fahrenheit are interval representations with different origins. Differences transform coherently, but ratios of their displayed values do not. Co-transforming the numerator and denominator therefore preserves the Boolean test T > θ while failing to preserve the ranking rule T / θ. The ranking borrowed an operation that the scale did not license.

Ordinary component tests are likely to miss this case. The sensor test proves that 31 °C becomes 87.8 °F. The configuration test proves that 30 °C becomes 86 °F. The alert test proves that both representations trigger the same room. Even a shadow run can pass if it compares only the number of alerts. The defect appears only when two rooms with different thresholds compete for scarce authority and the test asks whether their order survives the admissible transformation.

The operating consequence can be serious. Suppose D2 contains material whose tolerated excursion is narrow, while C4 has more thermal inertia. A unit migration can silently defer the more time-sensitive inspection. The resulting decision receipt would show valid inputs, valid conversions and an authorised dispatch, yet still record the wrong priority because the comparison rule was representationally unstable. This is not evidence of an actual deployment. It is a synthetic failure injection that identifies a release condition.

The repair begins by naming the intended comparison. If the team needs normalised threshold excess, it can use (T - θ) / Δ, where Δ is a domain-approved excursion width expressed as a temperature difference. Differences convert by scale without inheriting the arbitrary origin. If time-to-spoilage is the real target, a validated thermal-risk model should replace the proxy altogether. In either case, transformation tests must compare the complete ordered queue, not merely each alert in isolation.

The smallest useful release test needs at least two zones, distinct thresholds and a constrained action budget. Generate temperatures on both sides of each threshold, calculate the original queue, convert every reading, threshold and difference scale, then calculate the queue again. The metamorphic oracle is equality of alert membership and ordering, except where the contract explicitly permits a frame-dependent result. A passing test permits the team to claim stability only for the sampled transformation family and operating range. A failure does not show that the source readings are wrong. It localises an unlicensed operation between representation and allocation, which is precisely where ordinary accuracy checks have no reason to look.

Representation debt

Most systems do not make one representation choice once. A score is created for a research study, copied into a dashboard, used as a threshold, converted into a target, joined with another score and later fed into a model. Each reuse can add an assumption about what the score means and which operations it supports.

Representation debt is the accumulated gap between the original representation contract and the operations now performed on the value. The debt is invisible while decisions happen to remain stable. A unit migration, codebook change, population shift or new objective reveals it.

This is related to underspecification in machine learning. Several models can achieve similar held-out performance while behaving differently under deployment conditions.¹⁵ Representation debt adds a systems-level route to the same surprise: several encodings or transformations can look equivalent on the validation path while exposing different downstream behaviour.

The strongest boundary: invariance can preserve the wrong thing

A stable decision is not automatically a valid or ethical decision. A perfectly invariant score may measure the wrong construct. A coordinate-independent rule may still optimise an unjust objective. A calibrated probability may concern a poorly defined event or a population for which action is unauthorised.

Construct-validity traditions insist that observed scores require an argument connecting them to the intended attribute and its theoretical relations.^{16, 17} Measurement modelling in algorithmic systems likewise asks what construct is operationalised, how indicators relate to it and where social choices enter.¹⁸ The causal conception proposed by Borsboom et al. is one strong position: variation in the attribute should cause variation in the measure. Other validity traditions place more weight on interpretive arguments and nomological relations.

There is also a legitimate class of frame-dependent decisions. “Move east” depends on an agreed orientation. “Use code 42” depends on a codebook. “Trigger above 30 °C” depends on a unit-labelled threshold. Such dependence is not an error when the frame is part of the target and remains explicit. The error is accidental dependence on a frame that the decision claims to ignore.

Audit the representation before the result

The practical response is not to avoid numbers. It is to make their contracts visible. The representation-choice notebook below turns the central thesis into a repeatable review. It can be used for a sensor, score, embedding, token stream, probability service or business metric.

The representation-choice notebook

Complete the notebook before implementing the downstream calculation. Begin with the decision, not the available field. The instrument should be selected because it preserves the relation the decision needs.

The notebook is deliberately stricter than a data dictionary. A data dictionary may say that risk_score is a float between zero and one. The notebook asks whether it is a calibrated probability, a rank-preserving score, an arbitrary model output or a normalised composite. Those types permit different decisions.

Type the value before you compute with it. A field named “score” should not cross an action boundary until its target, transformation behaviour and licensed operations are known.

Run the audit in three passes

The first pass is semantic. Hold the intended phenomenon fixed and ask whether two teams would name the same target. “Customer risk”, “room temperature” and “model confidence” are not yet precise targets. Specify the event, quantity, boundary, horizon and population. Then identify plausible rival targets that the instrument could be measuring instead. This pass catches construct substitution before algebra makes it look settled.

The second pass is representational. Generate equivalent expressions without changing the case: convert units, shift or rotate the frame, permute nominal labels, change a lossless code, or move between probability and log odds. Transform every legitimate companion object, including thresholds, covariance matrices, codebooks and utility parameters. The purpose is not random perturbation. It is a controlled test of the equivalence class the design already claims.

The third pass is operational. Replay cases near decision boundaries, not only comfortable examples. Compare rankings, routes, abstentions, approvals and typed actions. Record where small representational loss becomes consequential, such as rounding near a threshold or token expansion near a context limit. Repeat the test across schema and model versions. A representation contract that passes once but cannot survive versioned replay is documentation, not assurance.

Executable lab: decision-invariance audit

The browser lab runs four synthetic scenarios. In coherent mode, it transforms both the representation and its associated rule. In bug mode, it transforms only the value or applies an operation the type never licensed. A positive result means the tested action survived the selected re-expression. A negative result identifies representational dependence that requires redesign or an explicit justification.

The lab tests one narrow property: action stability under declared transformations. It encodes the assumption that the transformation preserves the relevant empirical content. A passing result permits the claim that this decision is not sensitive to the tested re-expression. It does not prove measurement validity, model calibration, causal correctness or ethical legitimacy. A failing result does not prove the source value is wrong. It shows that the downstream rule depends on how the value was written.

from __future__ import annotations

from dataclasses import dataclass
from math import log
from typing import Callable, Generic, Iterable, TypeVar

State = TypeVar("State")
Rep = TypeVar("Rep")
Rule = TypeVar("Rule")

@dataclass(frozen=True)
class RepresentationSpec(Generic[State, Rep, Rule]):
    name: str
    represent: Callable[[State], Rep]
    transform: Callable[[Rep], Rep]
    transform_rule: Callable[[Rule], Rule]
    decide: Callable[[Rep, Rule], bool]
    relation: str

@dataclass(frozen=True)
class AuditResult(Generic[Rep]):
    original: Rep
    transformed: Rep
    decision_before: bool
    decision_after: bool
    stable: bool


def audit(
    spec: RepresentationSpec[State, Rep, Rule],
    states: Iterable[State],
    rule: Rule,
    *,
    co_transform_rule: bool = True,
) -> list[AuditResult[Rep]]:
    """Test action stability under an admissible re-expression.

    Invariant: the empirical state is held fixed. Only its representation
    changes. A legitimate rule parameter is transformed with the value.
    """
    transformed_rule = spec.transform_rule(rule) if co_transform_rule else rule
    results: list[AuditResult[Rep]] = []

    for state in states:
        original = spec.represent(state)
        transformed = spec.transform(original)
        before = spec.decide(original, rule)
        after = spec.decide(transformed, transformed_rule)
        results.append(AuditResult(
            original=original,
            transformed=transformed,
            decision_before=before,
            decision_after=after,
            stable=(before == after),
        ))
    return results


# Quantity example: alert above 30 °C, then re-express in °F.
quantity = RepresentationSpec[float, float, float](
    name="temperature",
    represent=lambda c: c,
    transform=lambda c: 1.8 * c + 32.0,
    transform_rule=lambda threshold_c: 1.8 * threshold_c + 32.0,
    decide=lambda value, threshold: value > threshold,
    relation="order relative to a co-transformed threshold",
)

# Probability example: act above p=0.60, then use log odds.
probability = RepresentationSpec[float, float, float](
    name="spoilage_probability",
    represent=lambda p: p,
    transform=lambda p: log(p / (1.0 - p)),
    transform_rule=lambda p: log(p / (1.0 - p)),
    decide=lambda value, threshold: value > threshold,
    relation="event ordering under an invertible parameterisation",
)

if __name__ == "__main__":
    for spec, states, threshold in [
        (quantity, [29.0, 31.0], 30.0),
        (probability, [0.55, 0.64], 0.60),
    ]:
        good = audit(spec, states, threshold, co_transform_rule=True)
        bad = audit(spec, states, threshold, co_transform_rule=False)
        print(spec.name, "coherent:", [r.stable for r in good])
        print(spec.name, "bug:", [r.stable for r in bad])

The Python version makes the hidden logic explicit: the empirical state is fixed, the representation changes, and legitimate rule parameters travel with it. Extend it with tolerances for lossy or approximate transformations.

How to use the result

A positive audit result permits a limited statement: under the tested transformations, with the associated rules transformed correctly, the action was stable. It supports release evidence for that representation boundary. It does not authorise extrapolation to untested populations, transformations or decisions.

A negative result has three common meanings. The first is a simple implementation defect, such as a threshold left in the old unit. The second is type confusion, such as arithmetic on category identifiers. The third is a deeper mismatch: the representation fails to preserve the relation the decision requires. The first needs a patch, the second a schema and contract change, and the third a new instrument or decision design.

The smallest useful implementation is a transformation test beside every consequential field contract. Generate equivalent expressions, replay the same cases, and compare proposed actions. Store the transformation, co-transformed parameters and verdict as a decision receipt. This turns representation choice from an undocumented modelling preference into operating evidence.