When match and trust diverge

Scaled dot-product attention has a clean job. For query position i, it compares a query vector with each key, turns those scores into non-negative weights, and averages the associated values. The familiar expression is compact because it leaves many semantic questions to training.

Nothing in this equation requires a score to mean only semantic relevance. A key can encode source quality, recency, typography, position or a learned convention. That flexibility is a strength. It is also the reason a high attention weight cannot automatically be read as a calibrated statement of reliability, importance or causal responsibility. The empirical debate over attention as explanation reached different conclusions under different definitions and tests.[8][9] For this paper, the safe claim is narrower: a weight tells us how the configured layer mixed values on that pass.

Three questions hidden inside one weight

Consider three records that all mention the correct river station. The first is a recent but noisy sensor reading. The second is a stable reading from yesterday. The third is a clean message from a station technician who is not authorised to declare an evacuation. A single ranking can order them, but it cannot tell us why one outranks another.

Relevance, precision and authority answer different counterfactual questions. Relevance asks whether the content bears on the present query. Precision asks how much the observation would vary across admissible repetitions. Authority asks whether the source may be used for this purpose and whether any proposed action is permitted. A source can be relevant but imprecise, precise but stale, or precise and relevant but unauthorised.

This separation matters because attention weights are normalised mixing coefficients, not posterior probabilities that a source is true. If the query changes, relevance may change while sensor repeatability does not. If a calibration fault is injected, precision should change while semantic match does not. If a policy expires, authority should change even when both learned scores remain stable. These are three distinct interventions.

A model may compress all three into one representation and perform well on familiar data. The cost appears during diagnosis. When a weight moves, nobody can say whether the system discovered a better match, distrusted the source, or learned a policy shortcut. The proposed architecture does not solve authority. It simply reserves one testable channel for evidential reliability so that the cause of a movement can be challenged.

The replacement that should matter

This thought experiment reveals why “the model could learn it” is not yet an explanation. A sufficiently expressive network could learn almost any useful correlation. The research question is whether a declared mechanism reacts to a controlled cause. That requires a channel whose intended quantity can be held fixed, changed and measured.

Why existing alternatives do not answer the same question

Several useful attention variants alter concentration or geometry. Query-key normalisation controls vector scale and replaces the fixed square-root factor with a learned scale, reducing arbitrary softmax saturation in the reported setting.[2] Sparsemax and entmax can set low-scoring alternatives exactly to zero, changing support and gradient behaviour.[3][4] Elliptical Attention changes the metric used to define contextual neighbourhoods and reports robustness benefits.[14]

Each may improve a system. None, by its definition alone, says that two equally relevant values with different conditional variances should receive different influence. Sharpness, sparsity, geometric relevance and evidential precision are four different design variables. A model can use all four, but an experiment must not credit one for the work of another.

The strongest case for leaving softmax alone

Ordinary attention is not defective merely because its score lacks a fixed interpretation. On many tasks, values are complementary features rather than repeated measurements of one quantity. A syntactic relation, a named entity and a distant instruction may all need to be combined. There may be no meaningful variance target for any one value. In that case, forcing an inverse-variance story onto the layer would manufacture a probability model that the task does not possess.

There is also a simpler engineering argument. If reliability is perfectly predictable from the same key features that determine relevance, a separate head may add parameters without adding an identifiable cause. The right baseline is then a matched source-specific bias with the same capacity. A precision channel earns its complexity only when a reliability intervention changes its output in a way the matched scorer does not predict.

That criterion keeps the proposal narrow. Use standard attention when no repeatable error process can be defined, when the signals cannot be separated before observing the answer, or when a calibrated gate brings no decision benefit. The aim is not to Bayesianise every attention layer. It is to create a specialised mechanism for tasks where match and trust can genuinely diverge.

flowchart TD
  A["The silted gauge"] --> B["When match and trust diverge"]
  B --> C["Two dials, one update"]
  C --> D["Make precision earn its name"]
  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

Two dials, one update

The smallest useful meaning of precision comes from repeated measurement. Imagine several sources estimating the same scalar quantity. Each source is unbiased, and its noise is independent of the others. Under those assumptions, the minimum-variance linear estimate gives more influence to smaller variance.

Deriving the rule from a physical situation

Let each source observe the same hidden scalar level z. Source j returns x_j = z + ε_j, where the error has mean zero and variance σ_j². Assume the errors are independent. We seek a weighted estimate whose weights sum to one, so an unbiased set of observations remains unbiased. Minimising the variance of that estimate gives weights proportional to inverse variance.

For the two-source example, equal averaging has variance 0.25 × 0.04 + 0.25 × 1 = 0.26. Precision weighting has variance 1 ÷ 26, about 0.0385. Its standard deviation is therefore about 0.196 rather than 0.510. The clean source does not win because it is more semantically related. It wins because repeated readings cluster more tightly around the same quantity.

Change one assumption and the rule changes. If the errors are correlated, the optimal weights depend on the full covariance matrix and are proportional to Σ⁻¹1, not to a list of independent precisions. If a source has a stable bias, minimising variance can favour a repeatably wrong observation; mean-squared error must include that bias. If values carry different features rather than estimates of one latent quantity, the derivation no longer licenses inverse-variance averaging.

The architecture therefore borrows a rule from estimation only where the task supplies the corresponding observation model. Elsewhere, the same algebra may still be useful as a gate, but “precision” becomes a hypothesis to test rather than a meaning guaranteed by notation.

What the word precision commits us to

Precision is not attention entropy. A sharp distribution can be confidently wrong. Precision is not model confidence in the final class. Output calibration and source-level observation noise are related only through a specified model. Precision is not source prestige. A prestigious source can be irrelevant; a low-status sensor can be repeatable. In the minimal proposal, precision is the inverse conditional variance of the value contribution, given the evidence available before the target is known.

That definition targets heteroscedastic aleatoric uncertainty: noise changes across inputs. Epistemic uncertainty concerns what the precision estimator does not know and may require ensembles, approximate posteriors or other model-uncertainty methods. Kendall and Gal’s widely used distinction is helpful here, but it does not make every learned variance well calibrated.[6] Accuracy and calibration are separate properties.[7]

The minimal factorisation

Let the ordinary relevance logit remain r. Let a separate head predict log precision ℓ from reliability evidence. To keep extreme claims from overwhelming semantic match, clip this term within a declared bound b. The attention weight is then:

This algebra is not claimed as historically first. Heo and colleagues previously learned input-dependent uncertainty over attention and assessed calibration and abstention.[5] Recent preprints go further. The Bayesian Filtering Transformer reweights attention by relevance times precision and propagates precision through residual and feed-forward updates.[11] Robust Filter Attention derives weighting from a linear stochastic dynamical prior.[12] Kalman Linear Attention carries belief-state uncertainty through an efficient sequence mixer.[13]

Why log precision enters additively

Standard attention assigns unnormalised mass exp(r_j) to source j. If that mass expresses relevance and π_j expresses independently estimated reliability, the smallest factorisation multiplies them: exp(r_j)π_j. Normalising across sources is exactly the same as applying softmax to r_j + log π_j.

This form has three useful invariants. Multiplying every precision by the same positive constant changes no weight. Setting every precision equal recovers ordinary softmax exactly. Swapping two precisions while keeping relevance fixed swaps only the reliability contribution. By contrast, multiplying a raw relevance logit by precision can behave strangely when logits are negative, and a global temperature cannot distinguish tied sources.

The factorisation still needs restraints. A predicted log precision can dominate the semantic score, especially when the estimator extrapolates beyond training data. The minimal design therefore bounds the log-precision term, records when clipping occurs and calibrates the estimator on held-out corruption levels. Addition in log space is not a proof of Bayesian correctness; it is the simplest algebra that makes the two causes separately inspectable.

Make precision earn its name

An unconstrained neural head can write any useful bias into ℓ. Calling that output “precision” would add vocabulary, not knowledge. The architecture therefore needs an information boundary and a test contract.

The precision-factorisation contract

The smallest useful implementation gives the relevance path and the precision path different inputs and different losses.

Train the precision head against a held-out residual target, repeated observations or known synthetic corruption. For Gaussian residuals, a heteroscedastic likelihood is one option, but it is not automatically safe. Seitzer and colleagues show that common likelihood training can settle on poor, stable variance estimates under certain optimisation conditions.[10] A practical implementation should compare loss choices, cap log precision, monitor calibration and refuse to infer causal reliability from training loss alone.

Six tests before the label is earned

These tests are deliberately redundant. A model can pass calibration while ignoring the channel during inference. It can pass the swap test with a badly calibrated estimator. It can improve task error while exploiting a leakage feature. The claim becomes credible only when predictive performance, calibration and causal response agree.

A synthetic benchmark that can return a null

Executable lab

Reading the benchmark without flattering the method

The synthetic run uses 40,000 trials and seed 203. When the noise ratio is 1, the oracle precision method and ordinary softmax have the same mean-squared error, about 0.031. This equality is not an inconvenience. It is the required null. A noisy estimate of precision is worse in the same regime, about 0.042, because an unnecessary uncertain channel perturbs a problem that needed no reweighting.

At a noise ratio of 8, softmax reaches about 0.958 error. The best global temperature on the declared grid improves that to about 0.759 by changing overall concentration. It still cannot favour one of two tied relevant sources. Calibrated precision reaches about 0.060 because it changes their relative influence. With noisy log precision, error rises to about 0.084. At log-precision error standard deviation 2, the calibration experiment deteriorates further to roughly 0.260.

These numbers do not predict a language-model gain. They expose the signature the architecture must reproduce: no advantage under equal noise, increasing advantage as heteroscedasticity grows, and graceful loss of advantage as precision calibration worsens. An empirical paper that reports only the favourable high-noise point would hide the very evidence needed to identify the mechanism.

#!/usr/bin/env python3
"""Synthetic intervention lab for precision-factorised attention.

The experiment holds semantic relevance fixed while changing source noise.
It compares standard softmax, the best global temperature on a small grid,
and precision-factorised attention (PFA):

    weight_j = softmax(relevance_logit_j + log(precision_j))

Only Python's standard library is required.
"""

from __future__ import annotations

import argparse
import csv
import math
import random
import sys
from dataclasses import dataclass
from typing import Iterable, Sequence


LOGITS = (2.0, 2.0, -1.5, -1.5)
TEMPERATURE_GRID = (0.20, 0.30, 0.45, 0.67, 1.0, 1.5, 2.2, 3.3, 5.0, 7.5)


@dataclass(frozen=True)
class Record:
    target: float
    values: tuple[float, float, float, float]
    variances: tuple[float, float, float, float]


def softmax(scores: Sequence[float]) -> tuple[float, ...]:
    maximum = max(scores)
    exps = [math.exp(score - maximum) for score in scores]
    total = sum(exps)
    return tuple(value / total for value in exps)


def weighted_sum(weights: Sequence[float], values: Sequence[float]) -> float:
    return sum(weight * value for weight, value in zip(weights, values, strict=True))


def make_records(*, trials: int, noise_ratio: float, seed: int) -> list[Record]:
    rng = random.Random(seed)
    clean_sigma = 0.25
    noisy_sigma = clean_sigma * noise_ratio
    sigmas = (clean_sigma, noisy_sigma, clean_sigma, noisy_sigma)
    variances = tuple(sigma * sigma for sigma in sigmas)
    records: list[Record] = []

    for _ in range(trials):
        target = rng.gauss(0.0, 1.0)
        distractor_target = rng.gauss(0.0, 1.0)
        values = (
            target + rng.gauss(0.0, sigmas[0]),
            target + rng.gauss(0.0, sigmas[1]),
            distractor_target + rng.gauss(0.0, sigmas[2]),
            distractor_target + rng.gauss(0.0, sigmas[3]),
        )
        records.append(Record(target, values, variances))
    return records


def mse(records: Iterable[Record], weights_for) -> float:
    squared_error = 0.0
    count = 0
    for record in records:
        prediction = weighted_sum(weights_for(record), record.values)
        squared_error += (prediction - record.target) ** 2
        count += 1
    if count == 0:
        raise ValueError("At least one record is required")
    return squared_error / count


def standard_weights(_: Record) -> tuple[float, ...]:
    return softmax(LOGITS)


def temperature_weights(temperature: float):
    if temperature <= 0:
        raise ValueError("temperature must be positive")
    weights = softmax(tuple(logit / temperature for logit in LOGITS))
    return lambda _: weights


def pfa_weights(*, calibration_log_sd: float, seed: int):
    """Create a deterministic stochastic precision estimator.

    calibration_log_sd=0 uses oracle inverse variances. Larger values apply
    multiplicative log-normal error to precision estimates. Log precision is
    clipped to [-4, 4], modelling the bounded precision bias proposed in the paper.
    """

    rng = random.Random(seed)

    def weights(record: Record) -> tuple[float, ...]:
        scores: list[float] = []
        for logit, variance in zip(LOGITS, record.variances, strict=True):
            log_precision = -math.log(variance)
            if calibration_log_sd:
                log_precision += rng.gauss(0.0, calibration_log_sd)
            log_precision = min(4.0, max(-4.0, log_precision))
            scores.append(logit + log_precision)
        return softmax(scores)

    return weights


def benchmark(*, trials: int, seed: int) -> list[dict[str, float]]:
    rows: list[dict[str, float]] = []
    for index, ratio in enumerate((1.0, 2.0, 4.0, 8.0, 12.0)):
        records = make_records(trials=trials, noise_ratio=ratio, seed=seed + index)
        baseline = mse(records, standard_weights)
        best_temperature = min(
            mse(records, temperature_weights(temperature))
            for temperature in TEMPERATURE_GRID
        )
        oracle = mse(records, pfa_weights(calibration_log_sd=0.0, seed=seed + 100 + index))
        noisy = mse(records, pfa_weights(calibration_log_sd=1.0, seed=seed + 200 + index))
        rows.append(
            {
                "noise_ratio": ratio,
                "softmax_mse": baseline,
                "best_temperature_mse": best_temperature,
                "oracle_pfa_mse": oracle,
                "noisy_pfa_mse": noisy,
            }
        )
    return rows


def calibration_stress(*, trials: int, seed: int) -> list[dict[str, float]]:
    records = make_records(trials=trials, noise_ratio=8.0, seed=seed)
    rows = []
    for index, log_sd in enumerate((0.0, 0.5, 1.0, 1.5, 2.0)):
        rows.append(
            {
                "precision_log_sd": log_sd,
                "pfa_mse": mse(records, pfa_weights(calibration_log_sd=log_sd, seed=seed + 300 + index)),
            }
        )
    return rows


def intervention_checks() -> None:
    base = softmax((2.0, 2.0))
    uniform_precision = softmax((2.0 + math.log(3.0), 2.0 + math.log(3.0)))
    if max(abs(a - b) for a, b in zip(base, uniform_precision, strict=True)) > 1e-12:
        raise AssertionError("Uniform precision must reduce exactly to standard attention")

    high_low = softmax((2.0 + math.log(25.0), 2.0 + math.log(1.0)))
    low_high = softmax((2.0 + math.log(1.0), 2.0 + math.log(25.0)))
    if not (high_low[0] > 0.95 and low_high[1] > 0.95):
        raise AssertionError("Swapping precision should swap influence under tied relevance")

    for temperature in (0.25, 1.0, 4.0):
        tie = softmax((2.0 / temperature, 2.0 / temperature))
        if abs(tie[0] - 0.5) > 1e-12:
            raise AssertionError("A global temperature cannot break a relevance tie")


def write_csv(rows: Sequence[dict[str, float]], stream) -> None:
    writer = csv.DictWriter(stream, fieldnames=list(rows[0].keys()))
    writer.writeheader()
    writer.writerows(rows)


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--trials", type=int, default=40_000, help="Monte Carlo trials per condition")
    parser.add_argument("--seed", type=int, default=203, help="Random seed")
    parser.add_argument(
        "--mode",
        choices=("benchmark", "calibration", "checks"),
        default="benchmark",
        help="Experiment to run",
    )
    args = parser.parse_args()

    if args.trials < 1:
        parser.error("--trials must be at least 1")

    intervention_checks()
    if args.mode == "checks":
        print("PASS: uniform-precision, precision-swap and temperature-tie invariants")
        return 0
    if args.mode == "calibration":
        write_csv(calibration_stress(trials=args.trials, seed=args.seed), sys.stdout)
        return 0

    write_csv(benchmark(trials=args.trials, seed=args.seed), sys.stdout)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

A configured RAG system

From reweighting to operating evidence

A deployed system needs to preserve the facts that justified each precision value. For a sensor, that may include calibration record, operating range and recent residual history. For retrieval, it may include document lineage, effective time, extraction method and duplicate cluster. Store those inputs beside the model version, the bounded log precision, the relevance logit and the resulting contribution.

This record supports a different-path review. A downstream verifier can inspect the authoritative source or read back the world state without reusing the same attention calculation. It also prevents the word precision from laundering an unverifiable model score into fact. The attention layer may propose how evidence is mixed; it does not authorise the evidence, grant permission or prove the resulting action succeeded.

stateDiagram-v2
  [*] --> Claim
  state "Figure 1. A precision field<br/>bends equally relevant<br/>currents differently" as Claim
  state "Three questions hidden inside<br/>one weight" as Test
  state "The replacement that should matter" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Evidence before architecture

The strongest rival explanation is simple: an extra head gives the network extra capacity. The model improves, but the output called precision is merely a useful second score. A credible experiment must make that rival work hard.

A matched experiment with rival generators

Train four models with matched width, optimiser, data and parameter count: standard attention; temperature or entropy-controlled attention; an unconstrained auxiliary bias head; and precision-factorised attention. The auxiliary bias head may see the same number of features and add a source-specific term to the logits, but receives no variance target and carries no precision semantics. Add sparsemax or entmax if support is a plausible cause of the gain.

Then create paired examples from the same underlying source. Preserve content and labels. Change only known corruption severity. Record task error, calibration of predicted variance, relevance invariance, precision monotonicity, output movement under a precision swap, and the homoscedastic null. Performance without mechanism confirmation counts as an architecture result, not evidence for precision.

What would strengthen or weaken the proposal

The strongest boundary: witnesses are rarely independent

Other boundaries that should stop deployment

First, many attention values are not noisy estimates of one common latent quantity. They may carry complementary features that should be composed, not averaged. The inverse-variance derivation then becomes an analogy rather than a justification. The architecture can still be tested empirically, but the word precision needs a task-specific target.

Second, a biased source can be repeatable. Its variance is low while its mean is wrong. Precision weighting can make the bias more influential. The experiment therefore needs bias shifts as well as zero-mean noise. Third, a precision head trained on the same distribution may be overconfident under shift. Epistemic uncertainty, out-of-distribution detection and abstention remain separate controls.

Fourth, source reliability can be adversarially presented. In a RAG system, a document can claim authority or mimic a trusted format. Reliability evidence should come from verified provenance and operating history, not untrusted content alone. Fifth, correlation can invalidate diagonal variance propagation. Recent filtering architectures make different conditional-independence, linearity or covariance approximations; their reported gains do not dissolve those assumptions.[11][12][13]

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The silted gauge
  M->>E: Figure 1. A precision field bends equally relevant currents differently
  E-->>M: compare rival explanations
  E->>D: Keep precision only if reliability can be intervened on
  D-->>Q: revise scope or act