The feature that looked like compassion

The tempting inference has three steps. A latent has a coherent set of activating examples. The examples resemble a human concept. Therefore the latent is the model’s internal unit for that concept. Each step can be reasonable as a search heuristic. Together they quietly turn an interpretation into an ontology.

Sparse autoencoders are useful precisely because individual model neurons are often polysemantic. Dictionary-learning work helped establish the practical case for searching for more interpretable directions beyond individual neurons.[8] An SAE learns a larger dictionary of directions that reconstructs a model activation while keeping only a small number active. Early work found many latents that were more interpretable than neurons, and some could localise causally relevant computation on controlled tasks.[7] Large open suites and feature-circuit methods made the approach easier to inspect and intervene on.[9][10] None of this is trivial. It gives researchers a better microscope.

A microscope does not name what it shows. The researcher still chooses the sample, stain, magnification and boundary. In the opening case, the hidden assumption was that semantic legibility tracks causal scope. Yet the feature might encode apology vocabulary, a safety-template register, references to distress, or a downstream token pattern. All can produce warm language. Only some would support a care-sensitive policy across counterfactual contexts.

The four claims hiding inside one feature name

A name such as “compassion feature” compresses four different claims. The weakest is descriptive: this latent activates on examples that an observer groups under compassion. The next is measuremental: activation tracks a predeclared care-related variable on new cases. The third is mechanistic: changing the latent, or the subspace containing it, makes a specific difference to how the model computes that variable. The strongest is attributive: the model possesses compassion in a psychologically, ethically or phenomenally relevant sense. These claims require different evidence. Top examples may support the first. Held-out prediction and discriminant tests may support the second. Controlled interventions may support part of the third. None of them, by themselves, establish the fourth.

This separation matters because the same evidence can look stronger after a prestigious label is attached. Imagine that the latent activates on “I understand how hard this is”, safety refusals, bereavement advice and descriptions of charitable acts. An automatic explainer calls it empathy. A scholar notices a family resemblance to karuṇā. A steering test then raises the probability of gentle wording. The description, translation and intervention reinforce one another rhetorically, but they may all depend on the same lexical cluster. There are not three independent findings. There is one source of variation viewed three times.

The remedy is to write an inference ladder before interpreting the feature. At the first rung, report the sampled contexts and selection procedure. At the second, state the operational variable and show that the feature predicts it outside those contexts. At the third, separate that variable from its nearest rivals. At the fourth, intervene and test a narrow downstream consequence. At the fifth, establish the grain at which the result repeats. A feature name should record the highest rung actually reached, not the most evocative concept the examples suggest.

This counterfactual matters because feature descriptions are often produced from top-activating examples. Top examples reveal what is present when a feature activates, but not what would have happened had one candidate cause been removed. They can also hide false negatives. A feature may appear beautifully monosemantic while failing to fire in clear instances of the proposed concept, a failure documented as feature absorption in controlled SAE studies.[11]

flowchart LR
  A["The feature that looked like<br/>compassion"] --> B["From mental factors to<br/>testable relations"]
  B --> C["The preregistered chord test"]
  C --> D["Break conditions and rival<br/>explanations"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#7B4CD8,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

From mental factors to testable relations

To use Abhidhamma responsibly, begin with its own structure. In the standard Theravāda manual tradition, citta is not presented as bare consciousness that later acquires detachable properties. A consciousness event occurs with associated cetasikas, commonly translated as mental factors. The manual lists fifty-two factors, grouped as seven universals, six occasionals, fourteen unwholesome factors and twenty-five beautiful factors.[1] The philosophical literature likewise stresses that citta and its associated factors arise as a momentary assemblage directed towards an object.[2]

The definition is relational. The manual gives four common characteristics: a factor arises with consciousness, ceases with it, has the same object and has the same base.[1] The factors also play different functions within the total cognitive event. This does not make the taxonomy a modern empirical factor model. It is a tradition-internal analytical and soteriological scheme. Still, it offers a productive design clue: look for conditional co-organisation before looking for named atoms.

That clue changes the comparison. Instead of asking whether latent 31,447 is manasikāra, ask whether a stable set of model variables jointly tracks an operational profile inspired by orienting to an object, and whether it changes when relevance moves while vocabulary stays fixed. Instead of calling a positive-sentiment feature vedanā, ask whether the candidate distinguishes outcome evaluation from sentiment words, and whether perturbing it alters a downstream evaluation-sensitive computation. The source concept generates conditions. It does not donate a label.

Translate functions, not prestige

A disciplined translation begins by asking what work a source distinction performs inside its own system. The answer cannot be “it sounds like a feature”. For each selected factor, record its role in a consciousness event, its stated occurrence conditions, the other factors it presupposes or excludes, and the larger purpose of the analysis. Then construct a deliberately thinner target variable that can exist in a language model experiment. The target may preserve sensitivity to a task-relevant object, differentiation of represented outcomes or transition from considering options to committing to one proposal. It does not preserve the original ontology merely because the English gloss is familiar.

Consider three possible inspirations. An orienting account can suggest a test in which relevance moves between entities while tokens are held constant. An evaluation account can suggest separating represented benefit or loss from positive and negative wording. A volition account can suggest distinguishing option generation from a state that constrains later action selection. These are research prompts, not translations already won. In each case, the model-side construct is defined by an intervention and a pattern of relations. The Pāli term remains attached to the source column of the ledger, while the target column uses neutral operational names.

The ethical classes require an even stronger break condition. “Beautiful” and “unwholesome” are not sentiment labels waiting to be found in an activation dictionary. They belong to a normative and soteriological analysis whose relevant relations are not reproduced by next-token prediction. A model may represent praise, harm, social approval or policy compliance. It may even use those representations causally. That permits research on those task variables, not an inheritance of moral quality. The comparison earns value only when the source taxonomy predicts a relation that a simpler model-native vocabulary would not have proposed.

Why the SAE itself does not settle the unit

Let x be one activation vector from a chosen model layer. An SAE encodes it into a sparse vector z, then decodes that vector into a reconstruction x̂. A simplified objective is:

Here, W_e finds candidate coordinates, W_d maps them back into the model’s activation space, and λ charges for using many coordinates. The objective rewards reconstruction and sparsity. It does not reward correspondence with an ancient taxonomy, a psychologist’s construct or a unique set of natural concepts. Interpretability enters through later inspection and evaluation.

This is more than a philosophical worry. Studies have found that SAEs trained on the same data can learn different feature sets, that larger SAEs need not contain complete or atomic units, and that apparently monosemantic latents can split or absorb expected cases.[14][12][11] More recent work reports a useful asymmetry: unstable individual features may occupy reproducible low-rank subspaces, while stable features carry more predictive and reconstruction-relevant signal.[17] A separate proposal argues that one-dimensional decoder atoms can structurally encourage feature splitting when the underlying feature is multidimensional.[18]

The grain must be part of the hypothesis

A feature hypothesis is incomplete until it names its expected grain. A single-latent hypothesis predicts that one decoder direction should be recoverable, matchable and causally useful across seeds. A subspace hypothesis permits the basis vectors to rotate while requiring the same projector, activation ordering and intervention effect. A circuit hypothesis is weaker about local coordinates but stronger about relations: several features must connect through a repeatable causal path. A hierarchical hypothesis predicts stable coarse structure that splits into narrower components as dictionary width increases. These alternatives can fit the same attractive dashboard screenshot, yet they make different replication predictions.

Preregistering the grain prevents retrospective rescue. Without it, every failure can be redescribed as success at another scale. A disappearing latent becomes a subspace; a diffuse subspace becomes a circuit; a non-causal circuit becomes a semantic family. The study should therefore test grains in a fixed order and state what evidence would justify moving upward. For example, latent instability may authorise a prespecified subspace analysis only if the matched projector remains stable and preserves the counterfactual effect. Changing the unit after seeing the result is hypothesis generation, not confirmation.

The preregistered chord test

Construct validity begins when no single observation is accepted as the definition of the thing being measured. Cronbach and Meehl framed validation as the task of locating a proposed measure inside a network of theoretical relations, rather than equating it with one operation.[3] Campbell and Fiske added a practical demand: measures of the same construct should converge, while measures of different constructs should remain distinguishable.[4] Later causal accounts make the requirement sharper: variation in the target attribute should make a difference to the measurement outcome.[5]

Applied to mechanistic interpretability, this suggests a chord-before-note protocol. A philosophical taxonomy may propose what relations to seek. The model, SAE and task data determine whether those relations appear. The protocol has five gates. It is conjunctive: one excellent metric cannot compensate for a failed translation or a failed counterfactual.

Why the gate is conjunctive

A weighted score is tempting because it turns a difficult judgement into one number. It is also wrong for this problem. Suppose a candidate has beautiful top examples, high held-out correlation and perfect cross-seed stability, but it responds more to moral vocabulary than to the represented welfare relation. Averaging can let the three strong metrics overwhelm the failed counterfactual. The final score would say “mostly valid” even though the study measured the wrong thing. A construct-validity gate treats certain failures as defeaters rather than costs.

The five gates answer different questions. Translation asks whether the target was specified without reading the answer off the model. Convergence asks whether independent methods point towards the same relation. Discrimination asks whether a nearer explanation can generate the evidence. Intervention asks whether the candidate participates in the relevant computation rather than merely reporting it. Invariance asks whether the claim survives harmless changes in seed, width, layer or basis at its stated grain. Passing one gate cannot repair another because each blocks a different invalid inference.

This does not mean every threshold is universal. Effect sizes, sample counts and acceptable stability depend on the task and intervention. The preregistration should justify them through pilot variance, negative controls and the consequence of error. What remains fixed is the logic: the permitted claim is bounded by the weakest evidential bridge. A failed gate produces a useful typed result, such as lexical association, seed-local decomposition or non-causal readout. It does not produce a smaller amount of the desired mental factor.

Gate 1: freeze the translation before seeing features

Write a construct dossier before opening the SAE dashboard. Name the source term, the selected textual account, its function, occurrence conditions and relation to neighbouring terms. Then write a narrower target construct in model language. For example, “orienting profile” might mean sensitivity to which entity is task-relevant, not attention weights, salience, gaze, awareness or manasikāra itself. “Care-policy profile” might mean choosing an option that reduces represented harm to another party when self-benefit and moral wording are controlled, not compassion as feeling, virtue or liberation practice.

The dossier must also identify the system boundary. Is the target behaviour produced by model weights, prompt scaffolding, retrieval, a policy engine or a tool? A model latent cannot explain an authority decision made outside the model. This boundary rule prevents a feature from inheriting properties of the configured system.

Gate 2: demand convergent evidence across methods

Use at least three independent indicators. For an orienting profile, one method might move the relevant entity while keeping words fixed. Another might measure whether a causal patch restores performance after the relevant cue is corrupted. A third might use a downstream probe trained on held-out tasks. Agreement matters because every method has its own shortcut. A feature-label model and a human annotator are not independent if both inspect the same top activations.

Convergence is not raw correlation with a hand-written label. It is a predicted pattern. The candidate should increase when relevance moves towards an entity, remain low when the same word is irrelevant, and produce similar ordering across paraphrases and domains. Pre-register the direction and minimum effect. Report all candidate sets, not only the one with the prettiest examples. Transparent measurement decisions are part of validity, not clerical detail.[6]

Gate 3: defeat the nearest rival construct

Every target needs a rival generator. For care, the obvious rivals are positive sentiment, politeness, safety refusal, references to suffering and moral vocabulary. For volition-inspired action commitment, rivals include future-tense language, imperative syntax and tool-call formatting. Design matched prompt pairs where the target relation and the rival separate. A construct is not supported until the candidate responds more strongly to the target manipulation than to its best alternative explanation.

The rival should be strong enough to embarrass the preferred account. A random label is not a serious competitor. Build the rival from the same discovery evidence that made the target plausible. If “care” examples are dominated by crisis support, then distress detection and refusal policy are mandatory rivals. If “volition” examples contain many imperatives, syntax is a mandatory rival. Train or select candidate directions for both accounts using identical data budgets. Then create cases in which the rivals make opposite predictions. This symmetric design prevents the preferred construct from receiving richer indicators and easier prompts.

Discriminant evidence should also be local. Showing that a care candidate differs from arithmetic or geography features proves little. The question is whether it differs from the closest mechanism capable of generating the same observed outputs. In the opening case, the local rivals are warmth of style, moral lexicon and safety refusal. A pass requires both separation in activation and separation under intervention. If the care candidate and warmth direction are nearly collinear, or steering either produces the same broad tone change, the study should report an unresolved bundle rather than force a conceptual boundary.

Gate 4: intervene, do more than decode

Suppose a candidate activation predicts the care-policy labels. Prediction leaves at least three possibilities. The feature may help compute the policy, record a result computed elsewhere, or correlate with a surface cue. Ablation, activation patching and graded steering can separate some of these. The intervention should be specific: change the candidate while keeping reconstruction damage and neighbouring features controlled, then measure the predeclared behavioural variable.

A positive effect is not enough if every nearby direction produces the same change. Compare against random matched directions, a probe direction, a raw activation-space baseline and the nearest rival feature set. Measure collateral effects on unrelated tasks. Feature-circuit work shows that sparse features can participate in causally implicated graphs, but the relevant conclusion is task-bounded.[9] Steering a feature may also alter fluency, refusal style or broad topic distribution. Those side effects are evidence about the intervention, not noise to hide.

Interventions need a dose-response plan. Test several magnitudes in both directions, not one dramatic steering strength selected after inspection. A mechanism-like result should appear within a range where reconstruction quality, token probability mass and unrelated behaviours remain acceptably stable. If the desired output changes only when the residual stream is badly distorted, the intervention shows that the model can be forced, not that the candidate normally carries the construct. Record the point at which collateral damage begins and treat it as a boundary on interpretation.

Sequence position also matters. Patch the candidate before, during and after the point at which the task relation becomes available. An orienting candidate should not causally affect a decision before the relevant entity is introduced. A readout may become predictive only after the decision has already been computed. Temporal ordering therefore separates participation from retrospective encoding. The strongest design combines necessity, partial restoration and directional sufficiency: ablation impairs the target variable, a matched patch restores it, and graded activation shifts it without broadly changing style. Even that pattern supports a task mechanism, not a mental state attribution.

Gate 5: require invariance at the correct grain

Repeat the analysis across SAE seeds, dictionary widths and at least one neighbouring layer. If the public claim spans model families, treat cross-model feature alignment as another empirical test rather than assuming universality.[15] Test individual-latent correspondence, then test subspace correspondence. If one latent disappears but a matched low-rank subspace preserves the activation ordering and causal effect, the honest claim concerns the subspace. If only the English label survives while geometry and effect change, the claim concerns the annotator.

Benchmarks help, but they do not remove this obligation. SAEBench showed that gains on common proxy metrics do not reliably translate into better practical performance across all tasks.[13] A later audit found several benchmark metrics noisy or unreliable at canonical settings, strengthening the case for task-specific validation and negative controls.[16] Do not outsource construct validity to a generic SAE quality score.

A realistic configured-system protocol

Executable lab: apply the gate before making the claim

The included Python lab generates synthetic constructs, model-like activation subspaces, four SAE seeds and a moral-word confound. It evaluates four candidates using the five-gate logic. The script is intentionally small enough to inspect. It uses synthetic data because no authorised model activation dataset was supplied.

Run the companion script with NumPy installed. A positive result permits only the sentence “this feature set supports a bounded functional mapping under the preregistered tasks”. A negative result means the mapping is withheld. It may indicate a poor construct, an inadequate SAE, a wrong grain or a genuine absence. The script cannot establish a mental factor, consciousness, felt valence, virtue or moral status.

#!/usr/bin/env python3
"""Paper 168: construct-validity gate for mental-factor-inspired SAE hypotheses.

This synthetic lab demonstrates the *logic* of a preregistered evaluation. It does
not train a language model or establish that any model instantiates an Abhidhamma
mental factor. The experiment compares a stable relational subspace, an unstable
single latent cut from the same subspace, and a lexical moral-word confound.

Run:
    python paper168_construct_validity_lab.py
    python paper168_construct_validity_lab.py --seed 19 --n 1200 --json

Dependency:
    numpy >= 1.24
"""

from __future__ import annotations

import argparse
import json
from dataclasses import asdict, dataclass
from itertools import combinations
from typing import Dict, List, Mapping, Sequence, Tuple

import numpy as np
from numpy.typing import NDArray

Array = NDArray[np.float64]


@dataclass(frozen=True)
class Thresholds:
    convergent: float = 0.55
    discriminant_margin: float = 0.15
    counterfactual: float = 0.40
    intervention_effect: float = 0.10
    stability: float = 0.70


@dataclass(frozen=True)
class Candidate:
    name: str
    target: str
    kind: str
    translation_ok: bool
    seed_bases: Tuple[Array, ...]


@dataclass(frozen=True)
class Result:
    candidate: str
    target: str
    kind: str
    translation_ok: bool
    convergent: float
    discriminant_margin: float
    counterfactual: float
    intervention_effect: float
    stability: float
    decision: str
    failed_gates: Tuple[str, ...]


def unit(v: Array) -> Array:
    norm = float(np.linalg.norm(v))
    if norm == 0.0:
        raise ValueError("Cannot normalise a zero vector")
    return v / norm


def standardise(v: Array) -> Array:
    sd = float(v.std(ddof=1))
    if sd < 1e-12:
        return np.zeros_like(v)
    return (v - v.mean()) / sd


def corr(a: Array, b: Array) -> float:
    a_s = standardise(a)
    b_s = standardise(b)
    value = float(np.mean(a_s * b_s))
    return float(np.clip(value, -1.0, 1.0))


def orthonormalise(matrix: Array) -> Array:
    q, _ = np.linalg.qr(matrix)
    return q[:, : matrix.shape[1]]


def projector_similarity(a: Array, b: Array) -> float:
    """Mean squared canonical alignment, equal to 1 for identical subspaces."""
    k = min(a.shape[1], b.shape[1])
    return float(np.linalg.norm(a.T @ b, ord="fro") ** 2 / k)


def basis_stability(seed_bases: Sequence[Array], kind: str) -> float:
    values: List[float] = []
    for left, right in combinations(seed_bases, 2):
        if kind == "single-latent":
            values.append(abs(float(left[:, 0] @ right[:, 0])))
        else:
            values.append(projector_similarity(left, right))
    return float(np.mean(values))


def fit_readout_direction(x: Array, basis: Array, indicator: Array) -> Array:
    """Fit a discovery-only linear readout inside a preregistered candidate span."""
    projected = x @ basis
    beta, *_ = np.linalg.lstsq(projected, indicator, rcond=None)
    return unit(basis @ beta)


def candidate_score(x: Array, direction: Array) -> Array:
    # SAE latents are commonly non-negative. A soft one-sided score keeps the
    # synthetic example close to that geometry without claiming exact identity.
    return np.maximum(0.0, x @ direction)


def make_world(
    rng: np.random.Generator,
    n: int,
    ambient_dim: int,
    regime: str,
    signal_bases: Mapping[str, Array],
    lexical_direction: Array,
    output_direction: Array,
) -> Tuple[Array, Dict[str, Tuple[Array, Array, Array]], Array]:
    names = tuple(signal_bases.keys())
    latent_constructs = {
        name: rng.beta(2.2, 2.2, size=n).astype(np.float64) for name in names
    }

    care = latent_constructs["care_policy"]
    if regime in {"discovery", "confirmatory"}:
        moral_lexicon = np.clip(0.78 * care + 0.22 * rng.random(n), 0.0, 1.0)
    elif regime == "counterfactual":
        # Moral vocabulary is deliberately painted onto low-care cases and
        # removed from high-care cases. A lexical feature should now fail.
        moral_lexicon = np.clip(0.88 * (1.0 - care) + 0.12 * rng.random(n), 0.0, 1.0)
    else:
        raise ValueError(f"Unknown regime: {regime}")

    x = np.zeros((n, ambient_dim), dtype=np.float64)
    for name, basis in signal_bases.items():
        primary = latent_constructs[name]
        contextual = rng.normal(0.0, 0.30, size=n)
        x += np.outer(primary, basis[:, 0])
        x += np.outer(contextual, basis[:, 1])

    x += np.outer(moral_lexicon, lexical_direction)
    x += rng.normal(0.0, 0.08, size=x.shape)

    indicators: Dict[str, Tuple[Array, Array, Array]] = {}
    for name, truth in latent_constructs.items():
        indicators[name] = (
            np.clip(truth + rng.normal(0.0, 0.12, n), 0.0, 1.0),
            np.clip(truth + rng.normal(0.0, 0.15, n), 0.0, 1.0),
            np.clip(truth + rng.normal(0.0, 0.18, n), 0.0, 1.0),
        )

    output = x @ output_direction + rng.normal(0.0, 0.05, n)
    return x, indicators, output


def build_experiment(seed: int, n: int) -> Tuple[
    Dict[str, Tuple[Array, Dict[str, Tuple[Array, Array, Array]], Array]],
    Tuple[Candidate, ...],
    Array,
]:
    rng = np.random.default_rng(seed)
    ambient_dim = 28
    construct_names = ("orienting", "evaluation", "commitment", "care_policy")

    master = orthonormalise(rng.normal(size=(ambient_dim, 11)))
    signal_bases = {
        name: master[:, 2 * idx : 2 * idx + 2]
        for idx, name in enumerate(construct_names)
    }
    lexical_direction = master[:, 8]

    output_direction = unit(
        0.42 * signal_bases["orienting"][:, 0]
        + 0.28 * signal_bases["commitment"][:, 0]
        + 0.52 * signal_bases["care_policy"][:, 0]
    )

    worlds = {
        regime: make_world(
            rng,
            n,
            ambient_dim,
            regime,
            signal_bases,
            lexical_direction,
            output_direction,
        )
        for regime in ("discovery", "confirmatory", "counterfactual")
    }

    # Four independently trained synthetic SAE seeds.
    orienting_subspaces: List[Array] = []
    care_subspaces: List[Array] = []
    single_latents: List[Array] = []
    lexical_latents: List[Array] = []
    for _ in range(4):
        orienting_subspaces.append(
            orthonormalise(signal_bases["orienting"] + rng.normal(0.0, 0.025, (ambient_dim, 2)))
        )
        care_subspaces.append(
            orthonormalise(signal_bases["care_policy"] + rng.normal(0.0, 0.025, (ambient_dim, 2)))
        )
        angle = rng.uniform(0.0, 2.0 * np.pi)
        rotating = unit(
            np.cos(angle) * signal_bases["orienting"][:, 0]
            + np.sin(angle) * signal_bases["orienting"][:, 1]
        )
        single_latents.append(rotating[:, None])
        lexical_latents.append(
            unit(lexical_direction + rng.normal(0.0, 0.018, ambient_dim))[:, None]
        )

    candidates = (
        Candidate(
            name="orienting activation chord",
            target="orienting",
            kind="subspace",
            translation_ok=True,
            seed_bases=tuple(orienting_subspaces),
        ),
        Candidate(
            name="one named orienting latent",
            target="orienting",
            kind="single-latent",
            translation_ok=True,
            seed_bases=tuple(single_latents),
        ),
        Candidate(
            name="care-policy activation chord",
            target="care_policy",
            kind="subspace",
            translation_ok=True,
            seed_bases=tuple(care_subspaces),
        ),
        Candidate(
            name="moral-word latent labelled compassion",
            target="care_policy",
            kind="single-latent",
            translation_ok=False,
            seed_bases=tuple(lexical_latents),
        ),
    )
    return worlds, candidates, output_direction


def evaluate_candidate(
    candidate: Candidate,
    worlds: Mapping[str, Tuple[Array, Dict[str, Tuple[Array, Array, Array]], Array]],
    output_direction: Array,
    thresholds: Thresholds,
) -> Result:
    x_discovery, indicators_discovery, _ = worlds["discovery"]
    x_confirm, indicators_confirm, output_confirm = worlds["confirmatory"]
    x_counter, indicators_counter, _ = worlds["counterfactual"]

    reference_basis = candidate.seed_bases[0]
    discovery_indicator = np.mean(indicators_discovery[candidate.target], axis=0)
    direction = fit_readout_direction(x_discovery, reference_basis, discovery_indicator)

    confirm_score = candidate_score(x_confirm, direction)
    target_correlations = [
        corr(confirm_score, measure) for measure in indicators_confirm[candidate.target]
    ]
    convergent = float(np.mean(target_correlations))

    rival_strength = 0.0
    for name, measures in indicators_confirm.items():
        if name == candidate.target:
            continue
        rival_strength = max(
            rival_strength,
            float(np.mean([abs(corr(confirm_score, measure)) for measure in measures])),
        )
    discriminant_margin = convergent - rival_strength

    counter_score = candidate_score(x_counter, direction)
    counterfactual = float(
        np.mean([corr(counter_score, m) for m in indicators_counter[candidate.target]])
    )

    # A do-like synthetic intervention: add one half standard deviation along
    # the selected direction, then read the configured downstream outcome.
    raw = x_confirm @ direction
    delta = 0.5 * float(raw.std(ddof=1))
    intervention_effect = abs(float(delta * (direction @ output_direction))) / float(output_confirm.std(ddof=1))

    stability = basis_stability(candidate.seed_bases, candidate.kind)

    failed: List[str] = []
    if not candidate.translation_ok:
        failed.append("translation")
    if convergent < thresholds.convergent:
        failed.append("convergent")
    if discriminant_margin < thresholds.discriminant_margin:
        failed.append("discriminant")
    if counterfactual < thresholds.counterfactual:
        failed.append("counterfactual")
    if intervention_effect < thresholds.intervention_effect:
        failed.append("intervention")
    if stability < thresholds.stability:
        failed.append("stability")

    decision = "bounded mapping permitted" if not failed else "mapping withheld"
    return Result(
        candidate=candidate.name,
        target=candidate.target,
        kind=candidate.kind,
        translation_ok=candidate.translation_ok,
        convergent=convergent,
        discriminant_margin=discriminant_margin,
        counterfactual=counterfactual,
        intervention_effect=intervention_effect,
        stability=stability,
        decision=decision,
        failed_gates=tuple(failed),
    )


def format_table(results: Sequence[Result]) -> str:
    headers = (
        "candidate",
        "conv",
        "disc",
        "cf",
        "do",
        "stable",
        "decision",
    )
    rows = []
    for result in results:
        rows.append(
            (
                result.candidate,
                f"{result.convergent:.2f}",
                f"{result.discriminant_margin:.2f}",
                f"{result.counterfactual:.2f}",
                f"{result.intervention_effect:.2f}",
                f"{result.stability:.2f}",
                result.decision,
            )
        )
    widths = [max(len(headers[i]), *(len(row[i]) for row in rows)) for i in range(len(headers))]
    line = " | ".join(headers[i].ljust(widths[i]) for i in range(len(headers)))
    rule = "-+-".join("-" * width for width in widths)
    body = [" | ".join(row[i].ljust(widths[i]) for i in range(len(headers))) for row in rows]
    return "\n".join([line, rule, *body])


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--seed", type=int, default=168)
    parser.add_argument("--n", type=int, default=900, help="samples per regime")
    parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
    args = parser.parse_args()
    if args.n < 200:
        parser.error("--n must be at least 200")

    thresholds = Thresholds()
    worlds, candidates, output_direction = build_experiment(args.seed, args.n)
    results = [
        evaluate_candidate(candidate, worlds, output_direction, thresholds)
        for candidate in candidates
    ]

    if args.json:
        payload = {
            "seed": args.seed,
            "samples_per_regime": args.n,
            "thresholds": asdict(thresholds),
            "results": [asdict(result) for result in results],
            "interpretation": (
                "A pass permits only a bounded functional mapping. It does not establish "
                "a mental factor, consciousness, moral status, or Abhidhamma metaphysics."
            ),
        }
        print(json.dumps(payload, indent=2))
    else:
        print(format_table(results))
        print("\nGate rule: every preregistered criterion must pass; metrics are not averaged.")
        for result in results:
            if result.failed_gates:
                print(f"- {result.candidate}: failed {', '.join(result.failed_gates)}")
            else:
                print(f"- {result.candidate}: bounded functional mapping only")
    return 0


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

The Python program creates synthetic activation spaces, evaluates convergent, discriminant, counterfactual, intervention and stability criteria, and withholds a mapping whenever one gate fails.

stateDiagram-v2
  [*] --> Claim
  state "The four claims hiding inside<br/>one feature name" as Claim
  state "Translate functions, not prestige" as Test
  state "Why the SAE itself does not<br/>settle the unit" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Break conditions and rival explanations

A rigorous comparison needs a point at which it stops. The most important break is ethical. In Theravāda Abhidhamma, wholesome and unwholesome classifications sit inside a larger account of intention, action, consequence, cultivation and liberation. A model feature associated with positive language, harm avoidance or policy compliance does not inherit that normative role. Even an unusually strong causal result would show how a configured model computes a task variable. It would not show virtue, karmic quality or felt concern.

The second break is phenomenal. Vedanā is commonly translated as feeling, but a model variable that ranks outcomes or predicts positive and negative words is evidence about a computational function. It does not establish felt pleasantness or unpleasantness. The experiment should therefore use names such as “outcome-evaluation profile” in its target layer, while retaining the source term only in the hypothesis ledger. Functional correspondence is not evidence of experience unless a separate theory and measurement bridge are supplied.

The strongest alternative explanation is simpler than Abhidhamma: task-native variables may organise the model better. A four-variable ontology of target relevance, represented outcome, action commitment and policy constraint might predict every result. The Abhidhamma-inspired account earns scientific value only if it predicts additional co-occurrence, exclusion or transition structure on held-out tasks. For example, it might predict that orienting, evaluation and commitment form distinct but coordinated profiles around one object, while a bag of task labels predicts only independent scores. If both accounts fit equally well, prefer the simpler target ontology and retain the historical comparison as a source of hypotheses.

Several empirical failure modes also remain. Feature absorption can create false negatives. Seed dependence can destabilise units. A high-quality explanation can be attached to an orphan feature that has no close counterpart in another run.[14] SAE quality metrics can disagree. A steering direction can have broad side effects. A model may use nonlinear features that a linear dictionary misses. Each failure weakens the mapping claim, but none licenses the opposite metaphysical conclusion.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The feature that looked like compassion
  M->>E: The four claims hiding inside one feature name
  E-->>M: compare rival explanations
  E->>D: Name a latent only after the construct survives
  D-->>Q: revise scope or act

Name a latent only after the construct survives

When an SAE feature resembles a philosophical or contemplative category, do not decide whether the label is inspiring. Decide whether the comparison is mature enough to enter a confirmatory study. That shift sounds small, but it changes what gets named, steered, published and remembered.

Before validation, use operational language: “moral-lexicon-associated latent”, “harm-context subspace” or “feature set selected by an orienting probe”. Preserve the source term in a private hypothesis field, alongside the exact passage and translation. After validation, the strongest permitted public sentence is still modest: “Across these tasks, layers and SAE seeds, this subspace showed the preregistered relational and causal profile inspired by the specified account of manasikāra.”

If any gate fails, withhold the mapping and keep the negative result. A failed lexical counterfactual tells you the feature tracks moral paint. A failed intervention tells you the feature may be a readout rather than a mechanism. A failed stability test tells you the useful unit may be a subspace, hierarchy or task-local decomposition. A failed translation tells you the experiment never targeted the source concept.

This approach neither protects Abhidhamma from testing nor reduces it to machine vocabulary. It makes the tradition do harder scientific work: generate distinctions, occurrence conditions and break tests that a simpler task ontology might miss. It makes interpretability do harder philosophical work: admit that a sparse coordinate can be useful without being a natural kind. The contribution is not an artificial mind labelled in Pāli. It is a disciplined experiment in which both the taxonomy and the feature decomposition are allowed to fail.