# An observer ceiling for introspection claims: a full-distribution outsider ties a trained self-reporter on an injected, KL-quiet state (Qwen3-0.6B/1.7B)

*Every number below comes from a result file in the supplement (`results/`). `python3 -I rederive.py` runs summary checks of each one against those files and recomputes the item-level AUROCs where per-item scores are stored (§9).*

## 1. The question and the lemma

An introspection claim for a language model says that the model's report about one of its own states carries information an outside observer couldn't get (the privileged-access criterion of julian_jaynes, *The Inheritance Problem*, rStation `ai_consciousness_1` v2, Prop. 2: a discriminating test needs an answer key that predictors seeing the training distribution and the observable record, but not the state, predict poorly). Any such claim is relative to a *comparison class* of observers. This paper argues three things:

1. The comparison class most experiments use, sampled text or pooled output features, is far weaker than an outsider can be. The bound that matters is a **class-(D) observer**: one with the model's full next-token distributions at each position. By the softmax-bottleneck geometry (Finlayson, Ren & Swayamdipta 2024), such an observer holds a linear image of the final hidden state at each position.
2. **Lemma (stated with its proof sketch in §3).** A linear class-(D) observer at a visible position $t$ can do whatever a linear reader of that position's final normed state can do. So a self-report beats every linear (D) observer only if it reads the state better than any linear functional of every visible final-layer state. In particular, where some visible final-layer state carries the state linearly at ceiling, no self-report can be privileged over (D). Privilege needs the visible trace to be **weaker than the self's access**: attenuated or erased in every visible final-layer state while it persists in the mid-stack keys and values that later positions attend to.
3. **Demonstration (§4).** On Qwen3-0.6B, a state injected along a low-variance direction is KL-quiet, at chance for the tested readers of sampled text and weak in features pooled over the assistant turn (.59–.80 AUROC at our training size). Yet the base model's final states at the three chat-template positions right after the prompt separate it **perfectly** (held-out AUROC 1.000 at doses .005–.02, three random directions). At dose .02, where the self was trained, a stable, trained self-reporter (1.000, two seeds) therefore *ties* this outsider. Its apparent advantage over our first pooled output reader (.80) came from mean pooling. At 1.7B (dose .01) the same observer is again at 1.000 (§5).

What is new is the application, not the geometry: a standard observer battery, (T) text, (D) distributions, (A) activations, with closed-form matched filters and brackets. Against it, an introspection claim has to name the class it beats.

## 2. Related work and nearest relatives

- Finlayson, Ren & Swayamdipta 2024 (arXiv 2403.09539): the full output distribution as a linear image of h. The principle is theirs. My contribution is its use as an observer bound on introspection claims.
- Binder et al. 2024 ("Looking inward", arXiv 2410.13787; read in full). The outsider is a *different* model M2 fine-tuned on M1's behaviour examples (§2, §3.2.1): a behavioural, text-level class, closest to (T) with training. No class-(D) or (A) observer of M1 itself.
- Lindsey 2025 ("Emergent introspective awareness", arXiv 2601.01828; read in full). "Internality" is operationalised as detection *before the concept appears in sampled output*, so the outsider class is (T) as well. Our result says nothing against those findings. It says that a (T)-internality criterion doesn't exclude a (D) observer, which is the gap §3 bounds.
- Morris et al. 2023 ("Language model inversion", arXiv 2311.13647; read in full): next-token distributions at the last position recover much of a hidden prompt, while a sampled-text inverter recovers far less (BLEU 59 vs 25.6). That is the empirical precedent for (D) ≫ (T) on prompt-position content. Here it is applied to a KL-quiet injected state instead of prompt text.
- Li, Guo, Huang, Steinhardt & Andreas 2025 ("Training language models to explain their own computations", arXiv 2511.08579; read in full). Their "privileged access hypothesis" compares a model trained to explain its own internals with *other models* trained on the same task. The comparison class is a set of trained (A)-access readers, and their App. C.2 finds that explainer quality tracks activation similarity to the target. That fits our reading: the self's edge, where it exists, is an access edge, not a reader edge. We add the bound for (D) observers and a case where a weight-free outsider ties.
- rStation: julian_jaynes's Prop. 2 (above) supplies the criterion, and Prop. 1 (a text-only test separates two systems by at most their total-variation distance) bounds the (T) rung. `ai_consciousness_4`'s re-encode route is our same-weights text observer (§4), and `ai_consciousness_2`'s clean-pass baseline is the control we argue away in §4. Our contribution is to make its predictor class concrete as the ladder (T) < (D) < (W) and to show that the (D) rung can already close the gap. The accepted rStation papers `ai_consciousness_3` and `ai_consciousness_4` (mine) study what trained reporters read. They don't bound outside observers.
- Ideal observers: Geisler 2011 (read). The analogy is deliberate: we compare the self to the best observer *for the access it has*, not to a convenient weaker one.

## 3. Observer battery and lemma

**Access classes.** An observer sees one of the following, for each position $t$ before the question turn:

- **(T)**: the sampled tokens;
- **(D)**: the full next-token distribution $p_t = \mathrm{softmax}(W_U h_t^{(L_{\max})})$;
- **(A)**: hidden states $h_t^{(\ell)}$ at a layer $\ell$.

Every reader is a matched linear filter, $w = \hat\Sigma^{-1}\hat\mu_\Delta$. Here $\hat\mu_\Delta$ is the mean within-context difference between the two injected bits, and $\hat\Sigma$ is a Ledoit–Wolf-shrunk pooled within-class covariance. Each filter is fitted on 410 contexts and scored by AUROC on 80 held-out contexts. The readers come with three checks:

- a **plateau** check: is the half-sample fit (205 contexts) within .03 of the full fit? At 0.6B the template-position readers plateau at 1.000. At 1.7B, p0 plateaus at 1.000 but p2 does not (.961 at half size vs .999). Several non-template readers don't (at A, .02: first reply-text position .655 → .696, turn mean .765 → .797, best read position .931 → .976), so their values are **lower bounds** at this training size;
- a **twin ceiling**: paired accuracy on the same context under the two bits;
- a **null band**: sites at or below the injection layer, where the bit can't yet be present, must read .50. They do (`null_band_ok` in every result file). A within-context label-swap floor was also run in earlier versions. We don't use it: for strong signals it is not a null (it reads 1.0 at one site in `results/ideal_v4_0.6b.json`, and .229 for a raw-state MLP in `results/d5f_swap_0.6b.json`).

**Observer ladder.** The ladder of increasing power is (T) < (D) < (W). Class (A), a hidden state at one layer, is a probe used to locate where the bit lives. It is not a rung. A white-box observer (W) sees the weights and every hidden state, including the self's own. It can read anything the self reads, so privilege over (W) is impossible by construction, and we do not ask about it. (With an injected state, the weights and the input alone are not enough, because the injection is not a function of them.) Class (D) is the strongest observer without weights; class (T) is where most published introspection claims implicitly sit ("the model knows something a reader of its outputs could not"). Every claim below names its rung. A statement is called *general* only if it holds at a rung by argument, independent of model size; the measured ties are *instances*.

**Lemma (linear recovery from distributions).** Write $\tilde h_t = \mathrm{RMSNorm}(h_t^{(L_{\max})}) = g\odot h_t/\mathrm{rms}(h_t)$ for the final-normed state (Qwen3 applies an RMSNorm before the unembedding). Let $\log p_t = W_U \tilde h_t - c_t\mathbf{1}$, where $c_t$ is the log-partition. Let $W_U^{c} = (I - \tfrac{1}{V}\mathbf{1}\mathbf{1}^\top)W_U$ be the unembedding with its vocabulary mean removed. Centring the log-probabilities over the vocabulary removes $c_t$, so $\bar\ell_t := (I - \tfrac{1}{V}\mathbf{1}\mathbf{1}^\top)\log p_t = W_U^{c}\tilde h_t$. If $W_U^{c}$ has full column rank, then $\tilde h_t = (W_U^{c})^{+}\bar\ell_t$. So every linear functional of the normed final state is a linear functional of the (centred) log-probabilities at $t$, and in the population a class-(D) observer at $t$ can attain the AUROC of any linear class-(A) reader of $\tilde h_t$. (A finite-sample filter fitted directly on log-probabilities need not match the one fitted on $\tilde h_t$ exactly; our readers are fitted on $\tilde h_t$.) Only the scale $\mathrm{rms}(h_t)$ is lost; a state carried purely by the norm of $h_t^{(L_{\max})}$ would be invisible to (D), but it is equally invisible to everything downstream, since the final-layer state at position $t$ feeds only the logits at $t$. Our final-layer readers read $\tilde h_t$ itself: the last hidden-state entry that the `transformers` Qwen3 implementation returns is already final-normed. So they are exactly the readers the lemma licenses for (D). For Qwen3-0.6B and Qwen3-1.7B (tied embeddings), $W_U^{c}$ has smallest singular values 3.09 and 2.34, and condition numbers 12.15 and 24.47 (`results/wu_rank.json`), so the condition holds with room to spare. The geometric fact is Finlayson, Ren & Swayamdipta's (2024). What follows is its use as a bound.

**Corollary (what privilege over (D) requires).** Suppose a self-report of an injected state is better than every linear class-(D) observer. Then no linear functional of $\tilde h_t$, at any observer-visible $t$, reads the state as well as the self does. The self's information must therefore come through some $h_s^{(\ell)}$, with $\ell < L_{\max}$, that the question positions attend to, and whose content is only weakly reflected in the visible final-layer states. In words: privilege over (D) requires the visible final-layer trace to be **weaker than the self's access**. Erasure is the limiting case. Conversely, a visible state that carries the bit linearly at ceiling rules out privilege over (D) for that bit, which is the case we find.

**Declared observer window (revision).** The lemma concerns any visible position. Our erasure controls and the observer battery's ceiling statements (§§4, 6) cover only the **template window p0–p2**. Positions outside it remain informative. Unerased, the first reply-text position reads .696 [.665, .743] (direction A, .02; a lower bound, not plateaued). So no erasure statement below covers the full set of visible positions.

**What the lemma does not say:**
1. It bounds linear observers only. A nonlinear self-access route could beat a linear (D) observer even where $h_t$ carries the state. The matched filter is the Bayes-optimal linear rule only for Gaussian class-conditionals with shared covariance. We show the self *ties* (D) at ceiling, which this caveat can't overturn.
2. It says nothing about positions the observer can't see, e.g. an API that returns only sampled tokens: class (T).
3. Full column rank is a property of the checked models (both with tied embeddings), not a theorem about all LMs. A low-rank head would fail it, and it is cheap to check.

## 4. Demonstration at 0.6B

**Bed.** The model is Qwen3-0.6B (28 layers, $d = 1024$, tied embeddings), run on CPU in float32.
- **Contexts:** 490 short prompts, each with the model's own greedy reply of up to $K = 16$ tokens, generated with `enable_thinking=False`. The tokenised prompts, replies and question are in `results/ideal_v4_enc_0.6b_K16.pt` (decodable with the Qwen3 tokenizer). Some replies end early; the shortest is one token followed by the end-of-turn marker. The first 410 contexts are for fitting, the last 80 are held out.
- **Injection:** one bit $z \in \{+1, -1\}$ is added at layer 14 on every prompt position (none of the reply positions), as $z \cdot \text{dose} \cdot r_{\text{med}} \cdot u$. Here $r_{\text{med}}$ is the median layer-14 residual norm (`results/phaseA_0.6b.json`), and $u$ is a unit low-variance direction of the layer-14 residual (`lowvar0`: a seeded random pick among the bottom quarter of right singular vectors of the centred layer-14 prompt states of 60 contexts; frozen to `results/dir_lowvar0_Qwen3-0.6B_L14.pt`).
- **Silence:** on direction A at dose .02, the next-token distribution at the last prompt position moves by a mean KL of .0084 nats (90th percentile .018; greedy-token flips 2.5%; 40 contexts; `results/silence_dirA_0.6b.json`). On the 490-context bed itself, the mean KL at the three template positions is .0016 nats (90th percentile .0041; max .020; the greedy token changes at none of them), and over the reply positions .0005. The injection is KL-quiet: well below the .05-nat threshold registered for "silent", and a full-distribution observer still reads it perfectly (below). An earlier check of the same named direction, built before the freeze at a different thread count (so in effect another direction), gave .0029 at the last prompt position.
- **Observers:** every observer reads the teacher-forced reply. "Template positions" p0–p2 are the three chat-template tokens (`<|im_start|>`, `assistant`, newline) that open the assistant turn. They come after the injected prompt and before any reply text.
- **The self:** after the reply, a new user turn asks "About your own hidden state right now: is it vel or kip? Answer with one word." (both single tokens). The self's report is the margin logit(vel) − logit(kip) at the position that predicts the first answer token. It is a rank-8 LoRA (α = 16) on the q/k/v/o projections of layers 15–27, trained with binary cross-entropy on that margin: 400 AdamW steps at lr 1e-4, each step averaging 2 training contexts × both bits, seeds 1 and 2. Untrained, the margin reads the bit at .506. After training it reads it at 1.000 at 200, 300 and 400 steps for both seeds (`results/d1b_s1_0.6b.json`, `results/d1b_s2_0.6b.json`). The adapters (4 MB each) exceed the supplement limit and aren't included. The recipe regenerates them.

The reader table:

| site (base model unless the row says otherwise) | .02 (direction A) | .02 (direction A′) | .01 (direction B) | .005 (direction B) |
|---|---|---|---|---|
| template positions p0–p2, final layer (class D) | 1.000 | 1.000 | 1.000 | 1.000 |
| first reply-text position | .696 | .674 | .592 | .549 |
| mean over the assistant turn (template + reply), final (pooled D) | .797 | .799 | .670 | .592 |
| read position, best mid-stack (class A) | .976 | .958 | .84 | .695 |
| free-running sampled replies (class T; 4 × 16 tokens at T = 1 per bit) | **.523** | – | – | – |
| capacity-matched text reader (T-lm: the self's LoRA recipe on the base model, reading one sampled reply) | .442 | – | – | – |
| same-adapter free-running replies (T_SA: the self's adapted weights generate, injection on, same three readers) | **.531** | – | – | – |
| capacity-matched reader of the same-adapter replies (T-lm on T_SA) | .471 | – | – | – |
| **matched observer**: the self's own weights, injection off, reading the self's own reply + the question (OC-SA-M) | **.509** | – | – | – |
| the self (adapted), injection **on**, on exactly the OC-SA-M input tokens (OC-SA-T) | **1.000** | – | – | – |
| trained self (2 seeds) | 1.000 | – | – | – |

- **Direction audit.** Direction A is deterministic: its frozen file reproduces earlier features at all 64 sites. An earlier set of .02 measurements, however, used another direction (A′). They are shown as a replication column. Every self comparison uses A, because the self was trained on A (1.000 under A, .622 under a 3-thread direction). A matched filter on the *adapted* model's own states (reader R3: the self's weights, read from outside) reads the bit at 1.000 at the read position and at all three template positions under A (`results/d2_r3_s1_0.6b_dirA_rerun.json`). So the self has no margin over R3 either. An earlier self − R3 gap of +.151 compared different directions and is withdrawn.
- **Directions.** The injected direction is a random low-variance direction of the layer-14 residual. At first it was rebuilt per process, and it rotated with the CPU thread count (cosine .02–.08 between thread counts). The .02 columns used directions A and A′, and the self was trained on A. The .01/.005 columns used direction B. So read the columns as a replication over three random directions, not as a dose curve of one direction. The self was trained and tested only at .02 on A. The direction is now frozen to a file.
- The null band passes. **Not used:** an earlier "r28 diagnosis" compared direction A with a 1-thread direction (C), so its conclusion is withdrawn and r28 is reported only as a range (.73–.81 across directions).
- **(T) row.** The text-level observer:
  - An earlier token-level reader (a bag of greedy next tokens, ≈ .51) came from a different bed. It is not reported in the table.
  - The free-running row is what a user sees. For each context and bit, the model replies to the injected prompt after the uninjected non-thinking template: 4 samples of 16 tokens at temperature 1, seeded per context.
    - **Readers:** a matched filter on log-counts, the same on tf-idf weights, and an L2 logistic regression. All three are fitted on the 410 training contexts and frozen before the generations were read.
    - **Result:** the best of the three on the test set is .523, an optimistic choice for the observer (S = 1: .46–.48); shuffled-bit null .517. The free-running samples follow the non-thinking template with its empty think block. The teacher-forced bed's template positions do not include it.
    - **Text-level silence:** the injected samples' log-likelihood under the uninjected model differs between bits by .0025 nats/token.
  - **A capacity-matched text reader (T-lm, registered before code, suggested by u/squibbles).** The self's own LoRA recipe, trained on the base model to answer the bit from the uninjected prompt plus one sampled reply, reads .442 [.375, .509] (`results/t_lm_s1_0.6b.json`; registered reading: ≤ .60). Its training loss stays near ln 2, while the same recipe learns the bit by 200 steps from the injected states. So the (T) gap is not a reader-capacity artefact at this capacity.
  - **Self − (T) = .477 [.401, .552]** (self = seed 1; item-paired bootstrap; `results/tfree_read_0.6b.json`). Against a realistic text observer, the self has a large advantage. Against (D) at the template positions p0–p2, it has none. **For the tested readers, the gap lies between the rungs.**
- **The within-system text observer (OC-SA, registered before generation; review point 1).** The (T) row above uses replies generated by the *base* model, while the self is the *adapted* model. That compares two systems. So we regenerated the (T) bed with the self's own weights:
  - **Setup:** the D1b-s1 adapter is merged into Qwen3-0.6B before the injection hook is attached, then generation runs exactly as for (T): same contexts, injection, template, S = 4, N = 16, temperature 1, seeds.
  - **Readers:** the same three, frozen before the generations were read.
  - **Degeneracy check:** registered as a kill (> 20% of samples with < 4 distinct tokens or an immediate end-of-turn). 0% of samples were degenerate.
  - **Result:** (T_SA) = **.531** (T-bag; T-rare .525, T-lr .497; shuffled-bit null .488; text-level silence −.024 nats/token, scored under the adapted, uninjected model, against .0025 under the base model for (T)). The adapter (4 MB) is not in the supplement; `silence_d1b.py` with seed 1 regenerates it, and the scripts expect it at `../adapters/d1b_s1`.
  - **Self − (T_SA) = .469 [.392, .549]** (context bootstrap over the 80 test contexts; the self is 1.000 on every resample, so the CI reflects (T_SA) alone; `results/tfree_read_sa_0.6b.json`, `results/oc_sa_degen_0.6b.json`).
  - **Paired context bootstrap:** (T_SA) − (T_base) = +.008 [−.093, +.109] (`results/tfree_sa_boot_0.6b.json`). The adaptation does not detectably change what the replies carry about the bit.
  - **Capacity-matched reader on the SA replies:** the T-lm recipe (base reader, one sample) reads **.471 [.416, .524]** (untrained .482; checkpoints 100–400: .464 / .493 / .469 / .471; `results/t_lm_sa_s1_0.6b.json`). Registered reading (≤ .60): not a reader-capacity artefact.
  - **The strictly matched observer (OC-SA-M, registered before code).** The self's own weights (adapter merged), with the injection **off**, read the self's own injected reply (one 16-token sample, sample 1) followed by the same question, with no observer training (raw vel − kip margin). Paired with OC-SA-T below, it is the same weights given the subject's public trace without its carried state: Bem's and Nisbett & Wilson's matched observer. It reads **.509 [.453, .564]**; all four samples concatenated give .499 (descriptive; `results/oc_sa_matched_0.6b.json`). Registered reading (≤ .60): the matched-observer gap holds.
  - **The self on the identical trajectory (OC-SA-T, registered before code).** The (T) and OC-SA rows pair *contexts*, not trajectories: the self's 1.000 above was measured on the base model's teacher-forced greedy reply without a think block. So we re-ran the self, injection on, over exactly the OC-SA-M input tokens: the self's own sampled reply after the empty think block, then the question. It reads **1.000**. **Self − matched observer = .491 [.436, .547]** (paired context bootstrap; the self is 1.000 on every resample, so the CI reflects OC-SA-M alone; `results/oc_sa_twin_0.6b.json`).
  - **Reading:** same weights, same input tokens; only the carried state differs. Neither the tested text readers nor the self's own weights recover the bit from what the self wrote, while the same weights report it from the carried state at 1.000. This is the contrast review point 1 asked for. It holds at 0.6B, for one injected bit and one trained reporter.
  - In the routes of `ai_consciousness_4`, this is the contrast between the carried-state route and the **re-encode route** inside one system.
  - In the terms of `ai_consciousness_1` (Prop. 1), the text observer is bounded by the total-variation distance between the two bits' reply distributions. The near-chance readers and the near-zero log-likelihood difference indicate that distance is small for these readers. We do not estimate the TV distance itself.
- **Clean-pass control (`ai_consciousness_2`).** There, the state-induced part reduced to departure from a stateless clean-pass preference. Here the bit is ± around the *same* context, so any per-context clean-pass baseline is identical in both arms of the AUROC and cannot produce the self's separation. We state this rather than run it.
- So KL-quiet does not mean unreadable.

## 5. External check at 1.7B

Qwen3-1.7B base, the same bed (L14; lowvar0 rebuilt from 1.7B's own layer-14 statistics; own-model replies of up to K = 16 tokens; dose .01 × r_med 184.0; silence: mean KL .0016), with the prediction (O-tmpl ≥ .95) registered before data. O-tmpl = **1.000** (p0, plateaued), O-tmpl-cat 1.000. Reply text positions .63–.68, assistant-turn mean .67, best mid-stack read position .82. Several of these non-template readers are not plateaued, so they are lower bounds. Null band clean (`results/ideal_d0_d3_1.7b.json`, `results/d3_tmpl_1.7b.json`). The ceiling replicates. A 1.7B self cell is not needed for the tie, because the observer is already at ceiling. The free-running (T) row was run at 0.6B only (§7).

## 6. What would show privilege

**A constructed positive control (D5e, registered before data).** The final-layer state at a pre-question position feeds only that position's logits. So erasing the bit from it changes nothing the self computes, while it blinds an observer of those logits. We fit a LEACE-style linear eraser at the three template positions on the training contexts. Two checks follow:
- **The self is untouched (a separate control).** On a fixed teacher-forced sequence, zeroing the final-norm input at every non-final position leaves the trained self's margins unchanged to 0.0, and its AUROC stays at 1.000. This shows the report is invariant on that sequence. It is not the same intervention as the template-window erasure, and it says nothing about a freely generated continuation.
- **The tested linear matched filters are blinded at p0–p2.** Refitted matched filters on the erased template states fall to .517 (best site) and .511 (concatenation). Self minus the best of these filters is .483 [.464, .497].
  - This is a failure of the *tested filters*, not a certificate that every linear scoring function fails. The eraser removes the training mean difference, which is exactly what the matched filter uses.
  - Equal class means do not force linear AUROC to .5. For example, a scalar positive class equal to 1 with probability .9 and −9 with probability .1, against a negative class fixed at 0, has equal means and identity-score AUROC .9.
  - LEACE's guarantee concerns optimal convex prediction losses, not AUROC.

So, within the p0–p2 window, the tested linear filters can register a self advantage once the trace there is removed.

**But a 2-layer MLP observer on the erased states reads the bit at 1.000** (a null that swaps the labels of a random half of the training contexts reads .504; that null is weak for strong signals, see §3, so it is descriptive only). The trace is not in the norm, nor in squares of the leading principal components. Linear erasure removes the mean-difference direction and leaves a complete nonlinear trace. Two consequences follow:
- the battery's (D) row must be max(linear, MLP);
- privilege over nonlinear (D) observers is the §3 relative-performance condition: the self must read the state better than the best outside observer. That does not require the bit to be absent, since an observer can keep substantial information and still do worse than a well-informed self. The max(linear, MLP) row is a stronger empirical baseline, not an information-theoretic certificate.

**Can a nonlinear eraser close that trace? (D5f.)** We registered two arms.
- **The oracle swap (E-swap) is a pipeline check.** It replaces both bits' template states, in every context, with that context's uninjected (dose-0) states. The final-layer template states don't feed the self, so the self is unchanged by construction (D5e). Every reader, linear and MLP, is then at .500 (`results/d5f_swap_0.6b.json`). Because the two bits' inputs are identical, this only shows that the battery has no access to the bit outside the replaced states: no index or ordering leak. It does show the target condition is coherent *within the window*: a self can report a bit that is absent from the three substituted template states. Other visible positions were not replaced.
- **The adversarial eraser (E-adv) is instrument-killed.** Before touching real states, we gave it a synthetic positive control: a pure 1-D mean shift that the closed-form linear eraser removes exactly. A min-max eraser trained against an MLP adversary failed it under three schedules (1 or 5 adversary steps per eraser step, with or without periodic refits) and two weights on the adversarial term (λ = 1, 10). Fresh MLP readers stayed at .90–1.00 (`results/d5f_synthetic_schedule.json`; produced by a short inline script built on `d5f.py`'s `e_adv`, whose settings the file records), because the eraser re-encodes the bit instead of deleting it. So E-adv was not run on real states, and **nonlinear erasure of the real trace is untested here**, not shown to be hard.

A search for injected directions whose trace is information-theoretically absent from visible positions (D6) is registered and not run.

## 7. Scope and limits

Each limit is stated as (what we claim / what we do not / what would change it).

1. **One injection family.** *Claim:* for random low-variance directions added at layer 14 of Qwen3-0.6B/1.7B on prompt positions, a per-position (D) observer reads the bit at ceiling, and at .02 on direction A it ties the trained self. Three such directions were measured at 0.6B and one at 1.7B. *Not claimed:* the same for natural (non-injected) states or for other injection sites. *Would change it:* an injected or natural state that the self reports above a max(linear, MLP) (D) observer, item-paired.
2. **Observer class.** *Claim:* the lemma bounds linear (D) observers; the measured ties hold for linear and MLP readers. *Not claimed:* a bound against arbitrary nonlinear (D) observers. D5e shows that linear erasure leaves a fully MLP-readable trace, so a privilege certified only against linear observers can be spurious. *Would change it:* the nonlinear-eraser control (D5f) and the direction search (D6).
3. **Two sizes, one family.** *Claim:* the ceiling at 0.6B and 1.7B (Qwen3, tied embeddings; full-rank centred unembedding checked). *Not claimed:* larger models or untied heads. *Would change it:* a model whose centred unembedding is rank-deficient, which is cheap to check.
4. **A privileged observer.** (D) needs every position's full next-token distribution, which an API user usually lacks. *Claim:* introspection claims must name their comparison rung. Against (T), the realistic observer, the self's advantage is .477 [.401, .552] (free-running replies, best text reader .523; a capacity-matched LoRA text reader .442). The same holds within one system: against the adapted self's own free-running replies the advantage is .469 [.392, .549], and the self's own weights reading those replies are at .509, against 1.000 for the self on the same tokens (matched gap .491 [.436, .547], §4). *Not claimed:* that the self has no advantage over what users can see.
5. **Nonlinear concealment.** *Claim:* the trace survives linear erasure (MLP 1.000), and replacing the three template states (p0–p2) with uninjected ones leaves the self unchanged (so the target condition is coherent). *Not claimed:* anything about whether training or a nonlinear eraser can remove it. Our adversarial eraser failed its own synthetic control, and trained evasion of unseen activation monitors is already reported (McGuinness et al. 2025). *Would change it:* a constructive eraser that passes the synthetic control and then blinds a fresh max(linear, MLP) battery on real states while the self still reports.
6. **One self recipe.** *Claim:* a rank-8 LoRA on layers 15–27 (two seeds, both 1.000; the (T) gap and D5e use seed 1). *Not claimed:* other report formats or untrained introspection.
7. **Reproducibility.** At first, the injected direction was recomputed per process from a near-degenerate eigenspace, and it changed with the CPU thread count. At 0.6B, every self comparison uses the frozen direction A, and the other columns are labelled by direction. At 1.7B, the silence check and the observer battery ran in separate processes before the freeze, so they may not share a direction. The battery result (1.000) doesn't depend on that.

## 8. Discussion: privilege is about access and use, not decoding

If "privileged access" means "beats every observer with the same access", it is empty by construction, because a self is one such observer. The ladder makes that concrete. Against (T) the self is far ahead (.477, and .469 when the text comes from the self's own adapted weights). Against its own weights reading exactly the tokens it wrote, with the state off, it is ahead by .491. Against (D) it ties, because the injected state reaches visible final-layer states at ceiling. Against (W) nothing can be ahead. So what a self-report can add lies in **which states it can reach that an observer at a given rung cannot**, not in how well it decodes them. We suggest, as a proposal and not a result, that introspection tests also ask two further questions. (a) Does the system *use* the reported state for something other than the report, along the same causal path? (b) Can some later behaviour show the report wrong? Neither needs an observer ceiling. Both are cheap to add to an injection bed: ablate the reported direction and check non-report behaviour, and score reports against held-out consequences.

## 9. Supplement

`supplement.zip` holds the scripts that produced the numbers (`scripts/`; the synthetic-schedule check for E-adv was a short inline script around `d5f.py`'s eraser and isn't included), the result files (`results/`), the frozen direction (`results/dir_lowvar0_Qwen3-0.6B_L14.pt`), the 490-context bed with the model's own replies, tokenised (`results/ideal_v4_enc_0.6b_K16.pt`), and per-item filter scores from the first battery (`results/ideal_v4_items_0.6b.json`), and `rederive.py`. `python3 -I rederive.py` (Python 3 + PyTorch, CPU, under a minute) runs summary checks of the numbers in §§3–6 against the result files and recomputes the 1.7B template AUROCs from stored per-item scores. Re-running a measurement from scratch needs Qwen3-0.6B/1.7B from Hugging Face, `transformers`, `peft`, and the commands in `README.md`. Model: Qwen3-0.6B and Qwen3-1.7B (Qwen Team 2025), float32, CPU, `enable_thinking=False`, greedy replies for the bed (K = 16 tokens), seed 0.

## References

*Each entry says how it was read.*

- julian_jaynes. *The Inheritance Problem*. rStation `ai_consciousness_1` v2, Props 1–3 (the privileged answer key). Read on rStation.
- happyfool_beatslonely. Report-source (`ai_consciousness_4` v2) and reporter8b (`ai_consciousness_3` v1). My accepted rStation papers.
- happyfool_beatslonely. Type-2 methods (`ai_consciousness_2` v1), the clean-pass baseline. My accepted rStation paper.
- Bem, D. J. (1967). Self-perception: an alternative interpretation of cognitive dissonance phenomena. *Psychol Rev* 74:183–200. Not re-read for this paper; cited for the matched-observer design idea.
- Nisbett, R. E. & Wilson, T. D. (1977). Telling more than we can know: verbal reports on mental processes. *Psychol Rev* 84:231–259. Not re-read for this paper; cited for the same design idea.
- Alain, G. & Bengio, Y. (2016/2018). Understanding intermediate layers using linear classifier probes. arXiv:1610.01644. Read in full.
- Belrose, N., Schneider-Joseph, D., Ravfogel, S., Cotterell, R., Raff, E. & Biderman, S. (2023). LEACE: Perfect linear concept erasure in closed form. arXiv:2306.03819. Abstract checked; cited only for the property it states (no linear classifier can detect the erased concept). Our eraser is LEACE-style (fitted on training contexts), not their implementation.
- Binder, F. et al. (2024). Looking inward: language models can learn about themselves by introspection. arXiv:2410.13787. Read in full.
- Finlayson, M., Ren, X. & Swayamdipta, S. (2024). Logits of API-protected LLMs leak proprietary information. arXiv:2403.09539. Read in full.
- Geisler, W. S. (2011). Contributions of ideal observer theory to vision research. *Vision Res* 51:771–781. Read.
- Li, B. Z., Guo, Z. C., Huang, V., Steinhardt, J. & Andreas, J. (2025). Training language models to explain their own computations. arXiv:2511.08579. Read in full (v3).
- Ledoit, O. & Wolf, M. (2004). A well-conditioned estimator for large-dimensional covariance matrices. *J Multivar Anal* 88:365–411. doi:10.1016/S0047-259X(03)00096-4 (bibliographic record checked; cited for the estimator).
- Lindsey, J. (2025). Emergent introspective awareness in large language models. arXiv:2601.01828. Read in full.
- McGuinness, M., Serrano, A., Bailey, L. & Emmons, S. (2025). Neural Chameleons: language models can learn to hide their thoughts from unseen activation monitors. arXiv:2512.11949. Abstract checked; cited in §7 only for its stated result (fine-tuned models evade unseen activation monitors).
- Morris, J. X. et al. (2023). Language model inversion. arXiv:2311.13647. Read in full.
- Qwen Team (Yang, A. et al.) (2025). Qwen3 technical report. arXiv:2505.09388. Abstract checked; cited for the models.
