diff --git a/RESEARCH_PLAN.md b/RESEARCH_PLAN.md index b02fecd..987d33e 100644 --- a/RESEARCH_PLAN.md +++ b/RESEARCH_PLAN.md @@ -5,9 +5,9 @@ **Project:** The Spoon Project ([README.md](README.md) holds the narrative charter; this file holds the protocol) **Repository:** `VirtualVagus` **Python package:** `virtual_interoception` -**Status:** Draft research charter v0.1 -**Authoring date:** 2026-08-02 -**Target machine:** MacBook Pro with 16 GB unified memory +**Status:** Draft research charter v0.2 +**Authoring date:** 2026-08-02; amended 2026-08-10 for the two-track structure ([issue #1](https://github.com/BioNanomics/VirtualVagus/issues/1)) +**Target machine:** MacBook Pro with 16 GB unified memory (local reference) plus the Purdue Gilbreth GPU cluster (Section 5.2) **Authoritative workflow:** command-line programs, versioned configurations, automated tests, and Git-tracked gate decisions. No notebook is an authoritative research artifact. --- @@ -33,6 +33,15 @@ A standard decoder-only transformer forward pass is a directed acyclic computati The strongest version of the hypothesis is not merely that bodily words influence later words. It is that the model contains a latent body-state mediator that can be causally inserted, removed, or rerouted even when no bodily words are present. +### 1.2 Two research tracks + +Amended 2026-08-10 ([issue #1](https://github.com/BioNanomics/VirtualVagus/issues/1)): the project runs two coordinated tracks. + +- **Track A — interoception ladder.** The original program, on the Pythia family (Section 5). Milestones 0–11 and gates G00–G11 are unchanged. +- **Track B — J-space connection.** Tests whether the interoceptive mediator lies inside or outside the verbalization-poised (J) subspace, on the Gemma family, where fitted Jacobian-lens artifacts and validated emotion-vector recipes provide external anchors. Milestones B1–B2, gates GB1–GB2. Method review and evidence floor: [docs/j-space-global-workspace.md](docs/j-space-global-workspace.md). + +Track B opens only after gate G02 closes, so the authorized `EXP-003-v2` repeat stays first. Passive J-lens readout is never gate-eligible evidence in either track (see `j_space` in [docs/glossary.md](docs/glossary.md)). + --- ## 2. Hypotheses and null hypotheses @@ -113,6 +122,9 @@ No result in this plan establishes subjective experience. - [ ] Large tensors and model files are content-addressed outside ordinary Git history; their manifests and hashes remain in Git. - [x] CPU float32 is the numerical reference path. - [x] MPS acceleration is used only after a parity test against the CPU reference. +- [ ] CUDA acceleration is used only after a parity test against the CPU reference; for models exceeding local memory, the CPU float32 reference run executes on cluster CPU nodes. +- [ ] Cluster runs execute inside a versioned Apptainer image whose digest is recorded in the run manifest. +- [ ] Slurm batch scripts are thin wrappers around the same versioned CLI commands used locally; no cluster-only experiment logic. - [x] Quantized models are not used as primary causal evidence. - [x] A failed gate can be repeated once for a documented technical or design defect. A second failure forces a pivot or stop decision. @@ -172,6 +184,9 @@ Every gate-eligible run must produce a machine-readable `run.json` containing at } ``` +Cluster (Gilbreth) runs must additionally record `gpu`, `cuda`, `driver`, `node_type`, +`slurm_job_id`, and `container_digest`. These fields are null for local runs. + ### 4.4 Storage policy Recommended: @@ -179,21 +194,39 @@ Recommended: - Git for code, configurations, protocols, compact data, summary results, figures, and decision records. - `artifacts/` for local activation tensors, excluded from ordinary Git. - DVC or an equivalent content-addressed store for large reproducible artifacts; its metadata remains in Git. +- Cluster scratch/Depot for fitted lenses, activation dumps, and other large Track B artifacts; only manifests and content hashes return to Git. - Hugging Face model cache outside the repository, with exact revisions recorded in the manifest. --- ## 5. Recommended model ladder +### Track A — interoception ladder (Pythia) + | Role | Model | Purpose | |---|---|---| | Unit-test fixture | TinyStories 1-layer 21M or Pythia-31M | Test hooks, tensor shapes, patching code, and CI without heavy compute | | Development | Pythia-70M | Rapid end-to-end experiments | | Primary discovery | Pythia-160M | Main small-model target with enough capacity for structured narrative relations | -| Replication | Pythia-410M | Test whether effects strengthen or reorganize with scale | +| Replication | Pythia-410M | Scale trend; folded into the `EXP-003-v2` behavioral repeat (G02 amendment below) | +| Conditional scale extension | Pythia-1B / Pythia-1.4B | Registered only if the 410M scale trend is promising; runs under Milestone 9 | | Training-dynamics replication | Selected Pythia checkpoints and seeds | Determine emergence and seed stability | -Pythia is preferred because the suite was designed for interpretability and exposes many training checkpoints. Use models sequentially, not simultaneously, to remain within 16 GB. +Pythia is preferred because the suite was designed for interpretability and exposes many training checkpoints. Use models sequentially, not simultaneously, to remain within 16 GB locally. + +### Track B — J-space connection (Gemma) + +| Role | Model | Purpose | +|---|---|---| +| Track B behavioral + extraction | Gemma 2 2B | Smallest model with a validated emotion-vector recipe (EmotionScope); behavioral battery partially Mac-runnable | +| Track B lens anchor | Gemma-4-12B | Published fitted J-lenses and preregistered reliability campaign (`solarkyle/jspace`); validates our lens machinery; cluster-only | + +No J-space study exists below ~2B parameters, and passive J-lens readouts are already +indistinguishable from shuffled-corpus controls at 2–4B +([docs/j-space-global-workspace.md](docs/j-space-global-workspace.md)). Track B therefore +does not run on the Pythia ladder; a Pythia lens fit may be registered only as a +negative-control curiosity, never as gate evidence. Track B revisions are pinned in +`configs/models/` when Milestone B1 opens. ### 5.1 Memory discipline @@ -205,6 +238,13 @@ Pythia is preferred because the suite was designed for interpretability and expo - [ ] Store analysis copies in float16 only after a float32 reference result exists. - [ ] Clear model and backend caches between model changes. +### 5.2 Compute environments + +| Environment | Role | Constraints | +|---|---|---| +| MacBook Pro, 16 GB unified memory | Development, CI fixtures, CPU float32 reference for Track A models, MPS parity runs | Models used sequentially; Section 5.1 discipline | +| Purdue [Gilbreth](https://www.rcac.purdue.edu/compute/gilbreth) (A100 80GB / H100, Slurm) | Confirmation-scale lens fits and control-lens suites, Gemma-4-12B work, Milestone 9 checkpoint × size × seed sweeps, CPU float32 reference for models exceeding 16 GB | CentOS 7: runs execute inside a versioned Apptainer image; `sbatch` scripts are thin wrappers around the local CLI (Section 4.1) | + --- ## 6. Proposed repository @@ -515,6 +555,13 @@ Initial preregistered continuation criteria: **STOP the loop pursuit in this model family when:** Pythia-410M also fails the behavioral prerequisite. Preserve the result as a useful negative finding or move to a different model family under a new charter. +**Amendment (2026-08-10, [issue #1](https://github.com/BioNanomics/VirtualVagus/issues/1)).** +The authorized `EXP-003-v2` repeat additionally runs Pythia-410M under the same +preregistered thresholds, converting the repeat into a three-point scale trend +(70M/160M/410M). The 410M thresholds must be committed before its held-out split is +scored. A Pythia-1B/1.4B scale extension is registered only if the 410M trend is +promising, as a new experiment version under Milestone 9. + --- ## Milestone 3 — Representation mapping without causal claims @@ -762,14 +809,15 @@ Determine whether the phenomenon is stable, scale-dependent, seed-specific, or d ### Checklist - [ ] Freeze the discovery protocol before replication. -- [ ] Repeat behavioral and strongest causal endpoints on Pythia-70M, 160M, and 410M. +- [ ] Repeat behavioral and strongest causal endpoints on Pythia-70M, 160M, and 410M; extend to Pythia-1B/1.4B only under the registered conditional scale extension (Milestone 2 amendment). - [ ] Repeat the primary endpoint across multiple Pythia random seeds where available. - [ ] Select training checkpoints before running them, for example initialization, early, middle, late, and final checkpoints. - [ ] Track when behavioral coupling first appears. - [ ] Track when separable `mobilization`/`body_state` and `action_appraisal` representations appear. - [ ] Track when causal mediation appears. - [ ] Compare layer locations using relative depth, not only absolute layer number. -- [ ] Test one unrelated small model family only after the Pythia replication is complete. +- [ ] Test one unrelated small model family only after the Pythia replication is complete. Track B (Milestones B1–B2) designates Gemma as that family; behavioral results from GB1 satisfy this item. +- [ ] Run checkpoint × size × seed sweeps as Slurm array jobs on Gilbreth (Section 5.2), one manifest per run. - [ ] Separate failure to replicate from failure due to different tokenization or weak task competence. ### Gate G09 — Does the phenomenon generalize? @@ -821,6 +869,67 @@ Determine whether sparse autoencoders expose interpretable features correspondin --- +## Milestone B1 — Track B behavioral prerequisite and lens-machinery validation + +### Objective + +Establish the behavioral phenomenon on the Track B family and validate the Jacobian-lens machinery against published artifacts before any J-space claim about interoception. Begins only after gate G02 closes. + +### Checklist + +- [ ] Pin Gemma 2 2B and Gemma-4-12B model and tokenizer revisions in `configs/models/`. +- [ ] Re-validate the stimulus corpus under the Gemma tokenizer: continuation tokenization normalization, banned-word coverage, and token-length balance. +- [ ] Register G02-equivalent thresholds for Gemma 2 2B in `configs/gates/` before scoring the held-out split. +- [ ] Run the behavioral battery on Gemma 2 2B (CUDA parity-gated or cluster CPU reference per Section 4.1). +- [ ] Reproduce one published `solarkyle/jspace` Gemma-4-12B result with our lens-application code against their fitted lens, within a registered tolerance. +- [ ] Fit a pilot J-lens (10–25 prompts × 128 tokens) and a token-shuffled-corpus control lens on Gemma 2 2B; record both as content-addressed artifacts with manifests. +- [ ] Record where the shuffled control matches the pilot lens; passive readout scores are recorded as diagnostics only. + +### Gate GB1 — Does Track B have a behavioral phenomenon and trustworthy machinery? + +**CONTINUE only when all are true:** + +- [ ] Gemma 2 2B passes the registered G02-equivalent criteria on the held-out split, including the keyword-free subset. +- [ ] The published-artifact reproduction matches within the registered tolerance. +- [ ] The pilot lens is distinguishable from the shuffled-corpus control on at least one registered causal (not passive) diagnostic. + +**PIVOT when:** Gemma 2 2B fails behaviorally but a registered Gemma-4-12B check passes; continue Track B at 12B only. + +**STOP Track B when:** both Gemma models fail the behavioral prerequisite, or the machinery cannot reproduce published artifacts after one authorized repeat. Track A is unaffected. + +--- + +## Milestone B2 — J-space decomposition of the interoceptive mediator + +### Objective + +Test whether the `mobilization`/`body_state` mediator lies inside or outside the verbalization-poised (J) subspace, and whether its influence on appraisal is J-mediated, using the automatic-versus-flexible design. Begins after GB1; does not depend on Track A gates because Track B extracts its own directions on the Gemma family. + +### Checklist + +- [ ] Extract candidate `mobilization`/`body_state` directions on Gemma 2 2B with an EmotionScope-style recipe (conditioned mean difference, neutral-PC removal), with embedding-only and bag-of-words baselines. +- [ ] Fit a confirmation-scale lens (500–1000 prompts × 128 tokens) plus shuffled-corpus, disjoint-corpus, and rotated-dictionary control lenses on Gilbreth. +- [ ] Sparse-decompose the candidate direction into J and non-J components using both the sparse-cone (gradient pursuit, registered $k \le 25$) and strict local-orthogonal decompositions. +- [ ] Run the norm-controlled intervention matrix: full direction, J component, non-J remainder, sign reversal, norm-matched random, shuffled-lens, and rotated-J controls; report equal-coefficient and equal-norm scalings separately. +- [ ] Run the automatic-versus-flexible battery: identical body-state evidence under (a) natural continuation, (b) explicit report of the feeling, (c) an arbitrary context-specified rule applied to the feeling. +- [ ] Track J-space entry of injected non-J components across layers and repeat interventions under downstream J-clamping. +- [ ] Escalate the strongest registered result to Gemma-4-12B using the published lens. + +### Gate GB2 — Is the interoceptive mediator inside or outside the J subspace? + +Either answer is a result. **CONTINUE only when all are true:** + +- [ ] J and non-J intervention effects are distinguishable from norm-matched random, shuffled-lens, and rotated-J controls. +- [ ] Any off-J (bypass) claim survives downstream J-clamping; any J-mediation claim shows clamp sensitivity. +- [ ] The automatic-versus-flexible contrast was registered before held-out scoring, and at least one predicted dissociation is observed or cleanly falsified. +- [ ] No conclusion rests on passive J-lens readout. + +**PIVOT when:** decomposition components are individually inert but the full direction is causal. Report a nonlinear or distributed interaction, not a J-space localization. + +**STOP the J-space connection when:** interventions cannot be distinguished from matched geometric controls at either model scale. + +--- + ## Milestone 11 — Clean-room reproduction and release ### Objective @@ -920,7 +1029,7 @@ These controls are mandatory before a loop claim. |---|---|---|---| | EXP-001 | End-to-end tooling smoke test | TinyStories 21M or Pythia-31M | G01 | | EXP-002 | Behavioral threat/body factorial | Pythia-70M | G02 | -| EXP-003 | Held-out behavioral replication | Pythia-160M | G02 | +| EXP-003 | Held-out behavioral replication (v2 adds the 410M scale point) | Pythia-160M + Pythia-410M | G02 | | EXP-004 | Layerwise latent-variable probes | Pythia-160M | G03 | | EXP-005 | Lexical and causal-attribution falsification | Pythia-160M | G03 | | EXP-006 | Event-to-body activation patching | Pythia-160M | G04 | @@ -934,6 +1043,12 @@ These controls are mandatory before a loop claim. | EXP-014 | Training-checkpoint emergence | Pythia-160M checkpoints | G09 | | EXP-015 | SAE factorization | Pythia-160M | G10 | | EXP-016 | Clean-room release reproduction | Primary model | G11 | +| EXP-017 | Conditional scale extension (only if the 410M trend is promising) | Pythia-1B / Pythia-1.4B | G09 | +| EXP-B01 | Gemma tokenizer validation and behavioral battery | Gemma 2 2B | GB1 | +| EXP-B02 | Published-lens machinery reproduction | Gemma-4-12B | GB1 | +| EXP-B03 | Pilot lens fit with shuffled-corpus control | Gemma 2 2B | GB1 | +| EXP-B04 | Mediator J-decomposition and intervention matrix | Gemma 2 2B | GB2 | +| EXP-B05 | Automatic-versus-flexible interoception battery | Gemma 2 2B → Gemma-4-12B | GB2 | --- @@ -1045,7 +1160,7 @@ Effects disappear under body-channel, causal-attribution, or keyword-free contro ### Outcome E — Small-model boundary -The effect is absent in 70M–410M Pythia models despite adequate task competence. This establishes a scale/model boundary and motivates a separately chartered larger-model study. +The effect is absent in 70M–410M Pythia models despite adequate task competence. This establishes a scale/model boundary; Track B (Milestones B1–B2) is the chartered larger-model continuation. --- @@ -1075,6 +1190,18 @@ The effect is absent in 70M–410M Pythia models despite adequate task competenc 8. uv project and lockfile documentation: https://docs.astral.sh/uv/ +9. Anthropic Jacobian-lens reference implementation: + https://github.com/anthropics/jacobian-lens + +10. `solarkyle/jspace` — Gemma-4-12B reliability campaign with published fitted lenses and traces: + https://github.com/solarkyle/jspace + +11. `amaljithkuttamath/jlens-replication` — shuffled-corpus and truncation controls at 2–4B scale: + https://github.com/amaljithkuttamath/jlens-replication + +12. Full J-space method review, evidence floor, and repository survey: + [docs/j-space-global-workspace.md](docs/j-space-global-workspace.md) + --- ## Final decision rule diff --git a/docs/Exploring J-Space and Tracing Computation Outside the Global Workspace in Transformer LLMs.pdf b/docs/Exploring J-Space and Tracing Computation Outside the Global Workspace in Transformer LLMs.pdf new file mode 100644 index 0000000..4d22a1d Binary files /dev/null and b/docs/Exploring J-Space and Tracing Computation Outside the Global Workspace in Transformer LLMs.pdf differ diff --git a/docs/glossary.md b/docs/glossary.md index 8c22715..2be0e41 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -225,6 +225,29 @@ recurrent wire inside a single forward pass. See [architecture-note.md](architec --- +### J-space (`j_space`) — Verbalization-poised subspace + +The set of sparse nonnegative combinations of Jacobian-lens dictionary directions at a +layer — a union of low-dimensional cones, not a linear subspace. In this repository +`j_space` means only: the region of activation space poised, on average across contexts, +to influence future verbalization, as defined operationally by a fitted lens and a +registered sparsity $k$. + +Requirements for use: + +- A J-space claim is causal or it is not made. Passive J-lens readout is never + gate-eligible evidence: token-shuffled-corpus control lenses match it at 2–4B scale. +- Any off-J ("bypass") claim requires survival under downstream J-clamping. +- Every fitted lens is a content-addressed artifact with a manifest, and every J-space + experiment fits or reuses shuffled-corpus and rotated-dictionary control lenses. + +"Global workspace" is **not** accepted vocabulary in this repository. It is the external +literature's hypothesis about broadcast geometry, not a validated construct here. See +[claim-boundaries.md](claim-boundaries.md) and +[j-space-global-workspace.md](j-space-global-workspace.md). + +--- + ## 3. Evidence terms ### Efferent / afferent diff --git a/docs/j-space-global-workspace.md b/docs/j-space-global-workspace.md new file mode 100644 index 0000000..fc6a4e6 --- /dev/null +++ b/docs/j-space-global-workspace.md @@ -0,0 +1,996 @@ +# Exploring J-Space and Tracing Computation Outside the Global Workspace in Transformer LLMs + +*Source: ChatGPT deep-research report (PDF), converted to Markdown. All references and URLs preserved as footnotes; figure images reconstructed as Mermaid diagrams.* + +## Executive summary + +The strongest current methodology for studying a putative transformer "global workspace" is **not a single interpretability technique**. It is a stack of complementary methods: + +$$\text{readout} \;\to\; \text{geometric decomposition} \;\to\; \text{causal intervention} \;\to\; \text{path localization}$$ + +The **Jacobian lens (J-lens)** is currently the most principled readout for the first step. For each layer, it averages the local linearized map from an intermediate residual-stream state to present and future final representations, + +$$J_\ell = \mathbb{E}_{x,t,t' \ge t}\left[\frac{\partial h_{L,t'}}{\partial h_{\ell,t}}\right],$$ + +then composes that map with the model's normal normalization and unembedding. The resulting token-indexed directions identify representations that are, on average across contexts, **poised to influence future verbalization**, rather than merely correlated with the model's eventual answer. Anthropic argues that sparse combinations of these directions define a **J-space**, and provides evidence that, in Claude models, this space exhibits reportability, deliberate modulation, flexible reuse, selective engagement, and causal involvement in internal reasoning.[^1] + +A critical mathematical point is that **J-space is not an ordinary low-dimensional linear subspace or "basis."** The J-lens dictionary contains one vector per vocabulary token and is generally overcomplete and full-rank. Anthropic therefore defines J-space using **sparse nonnegative combinations** of those vectors, typically with sparsity $k \lesssim 25$, making it a union of low-dimensional cones rather than a single subspace. Sparse gradient pursuit is used operationally to find the nearest J-space component of an activation or feature.[^2] + +For the specific problem of discovering **"paths off the workspace," J-lens alone is insufficient**. It identifies candidate variables, not the computational circuit connecting them. Anthropic itself notes that automatic computations can bypass J-space and that it has not yet characterized the mechanism by which information enters the workspace. The state-of-the-art experimental strategy should therefore pair J-space measurement with **activation patching, path patching, attention/MLP interventions, SAE/transcoder features, and attribution graphs**.[^3] + +The cleanest test of an off-workspace route is stronger than "the concept is absent from the J-lens." It is: + +$$\begin{gathered} +\text{signal is causally sufficient for behavior}\\ ++\\ +\text{signal remains outside J-space across propagation}\\ ++\\ +\text{behavior survives downstream J-space clamping}\\ ++\\ +\text{a non-J causal path can be localized} +\end{gathered}$$ + +That criterion matters because Anthropic found that a nominally non-J component can still alter behavior by **later writing back into J-space**. In concept and multihop experiments, much of the effect attributed to non-J residuals disappeared when the relevant J coordinates were clamped. Thus, observing an effect from $e_{\text{non-J}}$ does **not** establish an off-workspace mechanism; one must test mediation through J-space downstream.[^4] + +Open-weight evidence is promising but mixed. A frontier-scale replication on **DeepSeek-V4-Flash-0731** and **GLM-5.2** reports intermediate workspace bands, ordered unspoken intermediates, causal reasoning impairment under position-adaptive J-space ablation, and compressed J-space structure. However, the Claude result that J-space ablation leaves ordinary next-token prediction largely intact did **not** replicate: next-token agreement under the intervention fell to roughly 0.51 and 0.50 on the two open models.[^5] Conversely, a small-model replication on **Qwen2.5-3B** and **Gemma-4-E2B** found that a **token-shuffled-corpus J-lens matched or exceeded the coherent-corpus lens on every passive-readout evaluation**, substantially weakening passive J-lens scores as standalone workspace evidence at that scale.[^6] + +**My recommended research architecture is therefore:** + +```mermaid +flowchart LR + Signal["Candidate latent signal"] --> Readout["J-lens readout"] + Readout --> Decompose["Sparse J-space decomposition"] + Decompose --> JComp["J component"] + Decompose --> NonJ["Non-J remainder"] + JComp --> SteerJ["Causal steer / swap / ablate"] + NonJ --> SteerNonJ["Causal steer / swap / ablate"] + SteerNonJ --> Track["Track through layers and positions"] + Track --> EntryCheck{"Does it enter J-space?"} + EntryCheck -->|Yes| Upstream["Candidate upstream input to workspace"] + EntryCheck -->|No| Clamp["Clamp J-space downstream"] + Clamp --> SurviveCheck{"Behavior survives?"} + SurviveCheck -->|No| Mediated["J-space-mediated effect"] + SurviveCheck -->|Yes| Bypass["Candidate off-workspace route"] + Bypass --> Patching["Activation / path patching"] + Patching --> PathFound["Attention, MLP, SAE or transcoder path"] + PathFound --> Replication["Independent causal replication"] +``` + +For a junior developer, the best entry point is **not DeepSeek-V4 or GLM-5.2 fitting**. Start with a 2B–4B Gemma/Qwen model, load a pre-fitted J-lens or fit a 10–25-prompt pilot, reproduce a multihop intermediate, add shuffled-corpus and matched-random controls, reproduce EmotionScope on Gemma 2 2B, and only then implement the J-space-versus-orthogonal decomposition. A 16–24 GB GPU is enough for a productive first week; EmotionScope recommends 8 GB or more, while a public Gemma 4 E4B J-lens fitting recipe has been demonstrated on a 16 GB consumer GPU.[^7] + +## Methods and mathematical foundations + +The methods below answer subtly different questions. Conflating them is one of the main ways to overinterpret mechanistic results. + +| Method | Core question | Mathematical form | Typical settings | Cost | Strength | +|---|---|---|---|---|---| +| **Logit lens** | "What vocabulary direction does this intermediate state already resemble?" | $\mathrm{softmax}(W_U\,\mathrm{norm}(h_\ell))$ | Every layer; no fitting | Very low | Fast baseline; often useful in late/workspace layers | +| **Tuned lens** | "What final prediction can be decoded from this state?" | $\mathrm{softmax}(W_U\,\mathrm{norm}(A_\ell h_\ell + b_\ell))$ | One learned affine translator/layer | Moderate training cost | Excellent latent-output predictor | +| **Jacobian lens** | "What could perturbing this direction causally make the model verbalize across contexts?" | $J_\ell = \mathbb{E}[\partial h_L/\partial h_\ell]$; readout $W_U\,\mathrm{norm}(J_\ell h_\ell)$ | Default 1,000×128-token generic sequences; useful pilots at 10–100 | Expensive once; cheap after fitting | Causal local geometry; exposes hidden intermediates | +| **Hernandez relational Jacobian map** | "How does a subject representation locally map into a relation's object?" | $f(s) \approx f(s_0) + J_{s_0}(s - s_0) = Ws + b$ | Several exemplars/relation; authors find small sample averages can work | Moderate–high per relation | Direct local causal linearization of semantic relation | +| **Sparse J-space decomposition** | "How much of vector $x$ is sparsely expressible using J-lens directions?" | $\min_{a\ge 0,\, \lVert a\rVert_0 \le k} \lVert x - D_\ell a\rVert_2^2$ | $k \sim 16$–25 common | Moderate after lens fit | Separates verbalizable component from remainder | +| **Lens-coordinate swap** | "Does changing one latent concept into another causally redirect computation?" | $c = V^\dagger h;\quad h' = h + V[\sigma(c) - c]$ | Usually source/target pair, often $\alpha = 1$ | One intervened forward/run | Strong causal evidence with localized geometry | +| **Position-adaptive J ablation** | "Does the currently active workspace content matter?" | Remove top-$k$ active $v_i$ independently at each layer/position | $k = 10$ in Anthropic/open-frontier experiments | Forward intervention; potentially expensive over datasets | Avoids assuming same concepts active everywhere | +| **Activation/path patching** | "Which component/path transmits the causal signal?" | $h_i^{clean} \leftarrow h_i^{corrupt}$, or vice versa | Sweep layer/head/MLP/path | Potentially many forward passes | Converts variable-level result into circuit-level result | +| **Attribution graph / transcoder analysis** | "Which interpretable features causally influence which downstream features?" | Sparse feature graph with local effects along edges | Model requires suitable SAE/transcoder machinery | High preprocessing, efficient exploration afterward | Best candidate for tracing non-J routes | +| **Broadcast/connectivity analysis** | "Is this representation unusually easy for many downstream circuits to read?" | e.g. $\lVert W_{OV} v\rVert$, label-preservation ranks, weight composition | Compare J, rotated-J, SAE and random controls | Mostly weight-level linear algebra | Tests "global" aspect of workspace directly | + +*(A final column of this table — main weaknesses/risks — is truncated in the source PDF and is omitted here.)* + +The logit lens is the $J_\ell = I$ special case in Anthropic's formulation. Anthropic finds it often captures similar workspace content in later workspace layers but degrades earlier. The tuned lens instead learns affine maps by minimizing KL divergence to the model's final prediction; this makes it a strong output predictor, but Anthropic reports that on hidden-computation tasks it often predicts the eventual answer before surfacing the intermediate concepts.[^8] The original tuned-lens work introduced exactly this layer-specific affine-translation approach.[^9] + +**The Jacobian lens.** Let $h_{\ell,t} \in \mathbb{R}^d$ be the residual stream at source layer $\ell$, position $t$, and let $z_{t'}$ denote a late residual representation. Anthropic's default is approximately + +$$J_\ell = \mathbb{E}_{\text{prompt},t,t'\ge t}\left[\frac{\partial z_{t'}}{\partial h_{\ell,t}}\right].$$ + +For Claude Sonnet 4.5, their default uses the **penultimate transformer layer** as $z$, includes the current and all future positions, averages within prompts and then across prompts, and fits on **1,000 sequences of 128 tokens** drawn from a pretraining-like distribution. They report that performance already exceeds logit/tuned-lens baselines with roughly ten prompts, with more modest improvement thereafter.[^10] + +After fitting, + +$$\mathrm{JLens}_\ell(h) = \mathrm{softmax}\left[W_U\,\mathrm{norm}(J_\ell h)\right].$$ + +The rows of the composed map correspond to token-indexed J-lens directions. Because fitting is expensive but application is only a matrix multiplication plus the normal unembedding, one fitted lens can subsequently be applied cheaply over very large datasets.[^11] + +Anthropic tested several Jacobian estimators: final versus penultimate target layer; ordinary gradients versus freezing query/key gradients; current-and-future versus self-only versus future-only positions; mean versus median cross-prompt aggregation; and filters for anomalous activation or Jacobian norms. Results were broadly robust, with **mean aggregation at the penultimate layer modestly better for intermediate recovery**, while freezing Q/K gradients sometimes increased causal effects.[^10] For research aimed specifically at broadcast, the **future-only** + +$$J_\ell^{future} = \mathbb{E}_{t't}\left[\frac{\partial z_{t'}}{\partial h_{\ell,t}}\right]$$ + +and is especially informative because it removes the source position's self-effect and isolates what can be propagated to later token positions. Anthropic explicitly motivates future-only Jacobians this way.[^10] + +**Hernandez et al.'s Linear Relational Embedding / relational Jacobians.** Hernandez and colleagues showed that many transformer relations can be approximated by locally linear maps. For a subject representation $s$ and object-producing function $F_r$, + +$$F_r(s) \approx F_r(s_0) + \left.\frac{\partial F_r}{\partial s}\right|_{s_0}(s - s_0),$$ + +which can be rearranged into + +$$\mathrm{LRE}_r(s) = W_r s + b_r.$$ + +Averaging these relation-specific linear maps over a small set of examples can produce useful reusable maps for relations such as person → instrument. This is conceptually the closest direct predecessor to the J-lens: Hernandez et al. linearize a **specific semantic relation**, whereas J-lens averages the generic map from an intermediate representation toward eventual outputs.[^12] + +**J-space extraction.** Let + +$$D_\ell = [v_1, \ldots, v_{|V|}]$$ + +be the J-lens dictionary for layer $\ell$. The important correction to the phrase "J-space basis extraction" is that $D_\ell$ is **not a basis**: it is overcomplete and generally full rank. Anthropic defines + +$$\mathcal{J}_{\ell,k} = \bigcup_{|S| \le k} \mathrm{cone}\{v_i : i \in S\}.$$ + +The J-space component of $x$ is approximated by + +$$a^\star = \arg\min_{a \ge 0,\, \|a\|_0 \le k} \|x - D_\ell a\|_2^2,$$ + +$$x_J = D_\ell a^\star, \qquad x_{\neg J} = x - x_J.$$ + +Anthropic normally uses $k \le 25$, and reports that the reconstructed J component often accounts for less than 10% of overall activation variance even when it has a disproportionately large causal role.[^2] + +**Causal writing and swapping.** Steering uses + +$$h \leftarrow h + \alpha v.$$ + +Ablation can use negative steering or projection removal. For a two-concept swap, with $V = [v_s, v_t]$, + +$$c = V^\dagger h,$$ + +$$h' = h + V(\sigma(c) - c),$$ + +where $\sigma$ exchanges source and target coordinates. This changes the selected lens-coordinate content while preserving the component orthogonal to their span. Anthropic found J-lens directions more causally potent on intermediate-computation tasks than corresponding logit- or tuned-lens directions.[^13] + +**Position-adaptive ablation.** Rather than choose ten globally fixed directions, at each layer and token position compute the currently strongest J directions and remove those locally. Anthropic used $k = 10$, while excluding tokens present in the clean run's top-10 next-token predictions to avoid trivially destroying imminent output representations. Their Claude experiments sharply impaired multi-hop reasoning while preserving much routine text processing.[^14] The DeepSeek/GLM replication uses the same general position-adaptive logic and reports strong multi-hop impairment, but unlike Claude also observes major next-token degradation.[^5] + +**Multi-stream and MoE adaptations.** Ordinary MoE routing does not fundamentally change the J-lens definition as long as the source and target residual states have the same dimensionality; differentiation simply follows the routed computation. DeepSeek-V4-Flash is harder because its architecture maintains **four parallel residual streams**. The open-frontier implementation flattens these source streams, yielding a rectangular + +$$J_\ell \in \mathbb{R}^{4096 \times 16384}$$ + +instead of a square map. The same fork also adds custom FP8 autograd support for GLM-5.2, whose native FP8 kernels did not provide the gradient machinery needed for the fitting procedure.[^5] + +Anthropic's structural "broadcast" analysis is particularly relevant for tracing the workspace boundary. For an attention head they measure both gain, + +$$G_H(v) = \frac{\|W_{OV}^H v\|}{\mathbb{E}_{r\sim\text{isotropic}}\|W_{OV}^H r\|},$$ + +and **label preservation**, asking whether $W_{OV} v_i$ remains most similar to the same semantic direction $v_i$, rather than another $v_j$. J-space directions showed unusually strong and broad propagation, and the top 1% of heads selected by these criteria could be causally ablated to impair J-space transmission.[^15] + +## Practical reproduction pipeline + +A robust implementation should separate **lens fitting**, **workspace discovery**, and **causal experiments**. Mixing the fit corpus with the hypothesis-testing set makes almost every later inference harder to trust. + +```mermaid +flowchart TD + ChooseModel["Choose model and precision"] --> Freeze["Freeze model parameters"] + Freeze --> BuildCorpus["Build generic lens-fit corpus"] + BuildCorpus --> Coherent["Coherent fit corpus"] + BuildCorpus --> ShuffledCorpus["Token-shuffled control corpus"] + Coherent --> Estimate["Estimate per-prompt Jacobians"] + ShuffledCorpus --> FitShuffled["Fit shuffled control lens"] + Estimate --> AveragePositions["Average over positions"] + AveragePositions --> AggregatePrompts["Aggregate over prompts"] + AggregatePrompts --> StoreLens["Store J_l by layer"] + StoreLens --> ComposeUnembed["Compose normalization + unembedding"] + ComposeUnembed --> Validate["Validate known hidden intermediates"] + FitShuffled --> Validate + Validate --> FindBand["Find candidate workspace band"] + FindBand --> SparseDecomp["Sparse J-space decomposition"] + SparseDecomp --> Intervene["Read / steer / swap / ablate"] + Intervene --> RandomControls["Matched random controls"] + Intervene --> Truncation["Prompt truncation"] + Intervene --> PathTracing["Path patching / temporal tracing"] + RandomControls --> Conclusion["Causal conclusion"] + Truncation --> Conclusion + PathTracing --> Conclusion +``` + +**Data selection.** For a full-strength J-lens replication, the canonical recipe is 1,000 generic, pretraining-like sequences of 128 tokens. For development, 10 prompts is sufficient to verify that the machinery works, and roughly 100 is described by Anthropic's reference implementation as a usable fit. Keep the fitting corpus completely separate from controlled multihop, multilingual, arithmetic, typo, poetry, association, affect, and causal-intervention evaluations.[^16] + +A practical three-tier protocol is: + +| Stage | Lens corpus | Purpose | Recommendation | +|---|---|---|---| +| Smoke test | 5–10 × 128 tokens | Verify hooks, shapes, orientation and decoding | Do not publish | +| Development | 25–100 × 128 | Iterate on tasks/interventions | Always fit shuffled control | +| Confirmation | 500–1,000 × 128 | Stable geometry and cross-model comparison | Multiple corpus splits/seeds | + +The latter two rows are recommended research practice; the 1,000×128 canonical configuration and rapid early saturation come from Anthropic's sweeps.[^10] + +**Jacobian estimation.** Conceptually, for each prompt: + +1. Run a forward pass and cache source-layer residuals. +2. Choose a late residual target $z$, preferably penultimate initially. +3. For each target feature dimension $i$, inject cotangent $e_i$ at all selected target positions. +4. Backpropagate to every source layer. +5. Average the resulting gradients across source positions. +6. Accumulate across prompts. + +Anthropic's pseudocode describes "one backward pass per output dimension, in practice batched." This means fitting complexity scales approximately as + +$$O(N_{\text{prompt}}\, d_{\text{target}}\, C_{\text{backward}}(T))$$ + +rather than like ordinary inference. Dimension batching improves hardware utilization and wall-clock time but does not turn the exact Jacobian into a single ordinary backward pass.[^10] + +For a rough engineering estimate, a dense few-billion-parameter model with $d$ in the low thousands and 128-token inputs makes even a ten-prompt exact fit a $10^{16}$-ish FLOP class calculation, with 100 prompts moving toward $10^{17}$ arithmetic operations depending on architecture and implementation. Treat these as order-of-magnitude planning numbers, not benchmark results; the reliable planning unit is **prompt × target-dimension VJP work**, because architecture, checkpointing, dimension batching, attention implementation, and quantization radically alter realized throughput. This scaling follows directly from the official fitting algorithm.[^10] + +Empirical wall-clock measurements illustrate that variance. A public optimized Gemma-4-E4B workflow reported about **77 seconds per fitting prompt on a 16 GB RTX 5060 Ti**, whereas a small-model replication reports a 25-prompt shuffled-lens fit taking **234 minutes on a T4**. The discrepancy is a useful warning that implementation quality and memory paging dominate naïve runtime estimates.[^17] + +**Aggregation.** Store per-prompt statistics before reducing them. At minimum compare: + +$$J_\ell^{mean} = \frac{1}{N}\sum_n J_\ell^{(n)}$$ + +with elementwise median or a trimmed/outlier-filtered mean. Anthropic found heavy tails significant enough to test mean/median and Frobenius-norm filters; nevertheless, their default mean/penultimate recipe performed slightly better on intermediate recovery.[^10] + +For "off-workspace" work, additionally fit three variants: + +$$J^{self}: \quad t' = t,$$ + +$$J^{future}: \quad t' > t,$$ + +$$J^{all}: \quad t' \ge t.$$ + +The difference + +$$J^{future} - J^{self}$$ + +is not itself a formal causal decomposition, but comparing the geometries is a useful diagnostic of whether a candidate direction is primarily locally verbalizable or broadly propagated. + +**Normalization and unembedding.** Do not simply multiply by $W_U$ unless that is actually the model's final decoding path. Apply the model's corresponding final normalization to $J_\ell h$ before unembedding, matching + +$$W_U\,\mathrm{norm}(J_\ell h).$$ + +This is particularly important when comparing models with RMSNorm variants or unusual final residual handling. The official package wraps Hugging Face models so that this path can be reused consistently.[^11] + +**Finding the workspace band.** Do not copy Claude's approximately 38%–92% band onto another architecture. Re-estimate it. Anthropic uses several convergent diagnostics: + +| Diagnostic | Workspace prediction | +|---|---| +| J-space geometry/CKA across layers | Stable middle block | +| Excess kurtosis of J-lens readouts | Rises near workspace onset | +| Top-token autocorrelation across adjacent positions | Persistent concepts in middle layers | +| J-lens agreement with final next-token prediction | Low early; gradual middle rise; sharp late rise | +| Effective dimensionality of J-lens vectors | Characteristic transition near onset | +| Hidden-intermediate recovery | Improves inside band | + +Anthropic notes explicitly that the apparent lack of early-layer J content could be either a genuine architectural property or a limitation of the lens itself, so the inferred layer boundary must be treated as an empirical hypothesis rather than ground truth.[^18] + +DeepSeek-V4-Flash and GLM-5.2 show qualitatively similar intermediate bands in the open-frontier replication, but their intervention behavior differs enough from Claude that layer-normalized comparisons should not be interpreted as architectural identity.[^5] + +**Probe fitting.** Use three distinct notions of "probe," because they answer different questions: + +$$\text{J-token score}(x) = \langle v_w, x\rangle$$ + +tests one pre-defined J direction; + +$$p(y \mid x) = \sigma(w^\top x + b)$$ + +tests whether some linearly decodable feature exists; + +and sparse J decomposition tests whether the state can be reconstructed by a small number of verbalizable directions. Anthropic uses direct J-vector scores/cosines for specific concepts and gradient pursuit when a discrete inventory of active J concepts is needed.[^19] A learned classifier can detect information that J-lens misses, but because it is correlational, it must not be treated as evidence that the model itself reads the feature. + +**Intervention implementation.** Save the clean trajectory first. Every causal experiment should have: + +$$h_{\ell,t}^{clean}, \qquad \text{clean logits}, \qquad \text{clean J coordinates},$$ + +before modifying anything. This allows later **clamped interventions**, where selected coordinates are continually reset to their clean values while another direction is manipulated. That is the key technique for separating "outside the workspace now" from "causally bypasses the workspace." + +Activation tooling such as TransformerLens exposes caching and replacement hooks across many Hugging Face architectures, while NNsight supports reading, changing and differentiating intermediate values on local PyTorch models and remotely supported large models.[^20] + +## Failure modes, controls, and standards of evidence + +The strongest lesson from the first month of J-space replication work is that **passive readability is easy to overinterpret**. + +| Failure mode | Why it matters | Required control | +|---|---|---| +| Corpus-insensitive J-lens | A generic geometric prior can look semantic | Fit a token-shuffled-corpus lens | +| Prompt copying | Lens may echo visible semantic cues | Truncate/remove the causal referent | +| Next-token leakage | "Hidden thought" may just be imminent output | Evaluate intermediates not present in input or next-token top-$k$ | +| Fixed-answer probe confound | Classifier learns answer identity instead of correctness | Vary truth/answer labels within each evaluation slice | +| Semantic/style confounding in emotion vectors | "Emotion" vector may encode prose archetype | Matched human/cross-corpus controls; neutral-PC removal | +| Intervention magnitude | Destruction may result from generic OOD perturbation | Norm/variance/rank-matched random vectors and dose curves | +| Nonorthogonal J dictionary | Removing vectors sequentially can over-ablate | Pseudoinverse/QR projection and rank-matched controls | +| J-space re-entry | "Non-J" perturbation may later write into workspace | Clamp clean J coordinates downstream | +| Single-token vocabulary | Important multi-token concepts are invisible | Paraphrases, phrase-level vectors, independent probes/SAEs | +| Early-layer lens degeneration | "No J signal" need not mean "no information" | Compare independent probes and causal patches | +| Model/corpus specificity | One architecture can create misleading generalization | At least two model families and independent fit corpora | +| FP8/quantization autograd error | Incorrect gradients invalidate the lens | Tiny-model/full-precision numerical Jacobian checks | + +**Shuffled-corpus lens.** This should now be considered close to mandatory. A recent small open-weight replication fitted a second lens on the exact same Pile prompts after randomly permuting token positions. On Qwen2.5-3B and Gemma-4-E2B, the shuffled lens matched or beat the real lens on all six passive intermediate-readout evaluations. The authors therefore withdrew their earlier interpretation of those passive MRR results as workspace evidence.[^6] + +That result does **not** disprove J-space in those models. Their prompt-truncation test showed that detected intermediates disappeared when the relevant semantic context was removed, and Gemma displayed stronger causal effects than Qwen. But it shows that + +$$\text{high J-lens rank} \;\not\Rightarrow\; \text{workspace evidence}$$ + +without an appropriate lens-fit null.[^17] + +A stronger control suite would fit: + +$$J^{real}, \qquad J^{token\ shuffled}, \qquad J^{disjoint\ corpus}, \qquad J^{randomized\ labels},$$ + +then quantify whether the claimed signal exceeds the **between-fit noise floor** as well as the shuffled null. + +**Matched random ablations.** Random directions must be matched on more than dimensionality. At minimum match: + +$$\text{rank}, \qquad \text{layer range}, \qquad \|\Delta h\|_2,$$ + +and preferably also approximate removed activation variance or clean-logit perturbation. The frontier DeepSeek/GLM work uses matched-rank random controls and finds dramatic differences on multi-hop reasoning, but its authors also note limitations in how fully those controls match activation strength.[^5] + +A very strong design adds **randomly rotated J-space**. Rotation preserves much of the dictionary's gross spectrum/geometric structure while destroying token semantics. Anthropic used fixed random orthogonal rotations as controls in its broadcast analysis.[^15] + +**Prompt truncation and hard negatives.** Given + +> "The currency used in the country shaped like a boot is …" + +compare the full prompt against a version truncated before "boot" or before the relational cue. A genuine computed intermediate such as *Italy* should depend on the information required to infer Italy. The small replication found that its putative concepts disappeared under this truncation manipulation.[^17] + +Better still, use paired prompts with nearly identical surface form but different latent intermediates: + +$$x_A \approx x_B$$ + +while + +$$z_A \ne z_B.$$ + +This controls lexical association more directly. + +**Semantic confounds in emotion vectors.** EmotionScope explicitly notes that its initial 1,000 templates were generated by Claude rather than the model being probed, that several negative-emotion vectors remain strongly entangled, and that some apparent perfect validation metrics rely on very small samples. Its strongest validation is instead the monotonic response to a continuous danger variable such as Tylenol dose, where surface wording is mostly held constant.[^21] Anthropic likewise performed checks intended to distinguish semantic emotion content from low-level prompt characteristics.[^22] + +For emotion × J-space experiments, add an **embedding/bag-of-words null** and matched neutral stories wherever possible. An open Gemma emotion-vector artifact, for example, explicitly provides an embedding-level baseline to test whether similar directions can be produced without running the transformer at all.[^23] + +**Probe-answer confounds.** The `solarkyle/jspace` reliability campaign found a particularly important general warning: on evaluation slices where the correct answer is constant, an internal probe can achieve near-perfect AUROC by detecting which answer the model intends to output rather than whether that answer is wrong. Their fixed-truth slices reached approximately 0.99–1.00 AUC while varying-truth counterparts were much weaker.[^24] + +Therefore every "workspace predicts X" experiment should ask: + +$$I(\text{feature}; X \mid \text{intended output})$$ + +rather than merely + +$$I(\text{feature}; X).$$ + +In practice: balance outputs, stratify by answer identity, or evaluate within answer classes. + +**Single-token and bag-of-concepts limitations.** J-lens can only directly name concepts represented by vocabulary tokens, and a list of tokens does not reveal binding structure. "Spider, eight, legs" does not distinguish *a spider has eight legs* from another relationship among the same concepts. Anthropic identifies both limitations explicitly.[^25] Independent SAE features, relational probes, natural-language activation descriptions, or learned phrase-level readouts are therefore especially important when searching for paths the token-indexed J dictionary may miss. + +**Causal intervention versus causal tracing.** An intervention proves a variable matters; it does not identify the path. Activation patching is specifically designed to localize causal components by replacing activations between clean and corrupted runs. Best-practice work emphasizes that conclusions depend heavily on the corruption, restoration direction, and metric chosen, so use several patching metrics and report clean/corrupt baselines.[^26] Attribution graphs and transcoder-based circuit tracing go further by representing interactions between sparse interpretable features and logits.[^27] + +A useful evidence ladder is therefore: + +$$\text{correlation} < \text{readout} < \text{steering} < \text{specific swap} < \text{ablation + matched controls} < \text{mediation/clamping} < \text{path localization}$$ + +The ordering is a methodological recommendation rather than a formal statistical theorem. + +## Experiments to discover paths off the workspace + +This is the area where I think there is the most genuinely new research opportunity. + +### Emotion-vector decomposition + +Suppose EmotionScope or an Anthropic-style extraction gives an emotion vector $e_\ell$ at layer $\ell$. EmotionScope's basic extraction averages residual activations over emotion-conditioned material, subtracts an appropriate baseline/grand mean, removes dominant neutral PCA components, and normalizes the resulting direction; its validated Gemma 2 2B setup used layer 22, 20 emotions, 1,000 emotion templates, 100 neutral prompts and 19 removed neutral PCs.[^28] + +Fit J-lens dictionary $D_\ell$, then solve + +$$a^\star = \arg\min_{a\ge 0,\, \|a\|_0\le k}\|e_\ell - D_\ell a\|_2^2.$$ + +Define + +$$e_J = D_\ell a^\star, \qquad e_{\text{off}} = e_\ell - e_J.$$ + +The first experiment is a norm-controlled intervention matrix: + +| Condition | Intervention | +|---|---| +| Full emotion | $+\alpha e$ | +| J component | $+\alpha_J e_J$ | +| Non-J remainder | $+\alpha_O e_{\text{off}}$ | +| Sign reversal | $-\alpha e$ | +| Norm-matched random | $+\alpha r$ | +| Shuffled-lens J component | Project using $D^{shuffle}$ | +| Rotated-J control | Project using orthogonally rotated $D$ | + +Scale $\alpha_J, \alpha_O$ both by equal absolute coefficient and by **equal intervention norm** in separate analyses. Otherwise the much larger non-J variance can trivially dominate. + +There is a subtle geometric issue. Because global J-space is a union of cones rather than a fixed subspace, $e_{\text{off}}$ should not casually be called "the orthogonal complement of J-space." It is the residual relative to a particular sparse reconstruction. For a strict local orthogonal experiment, take the selected active dictionary $D_S$, compute + +$$Q = \mathrm{orth}(D_S),$$ + +then + +$$e_\parallel = QQ^\top e, \qquad e_\perp = (I - QQ^\top)e.$$ + +Run **both** decompositions. Agreement between sparse-cone and strict-local-orthogonal experiments makes the claim much stronger. Anthropic's own formalization emphasizes the union-of-cones structure and nearest sparse reconstruction rather than treating J-space as a globally fixed linear span.[^29] + +The central question is then not merely: + +> Does $e_{\text{off}}$ steer behavior? + +It is: + +> Does $e_{\text{off}}$ steer behavior **without subsequently entering J-space**? + +### Workspace mediation test + +Inject the non-J component at $(\ell, t)$: + +$$h'_{\ell,t} = h_{\ell,t} + \alpha e_{\text{off}}.$$ + +At every later layer $m > \ell$, measure + +$$\Delta h_m = h'_m - h_m.$$ + +Sparse-decompose $\Delta h_m$ into J and non-J components and define a workspace-entry statistic such as + +$$R_J(m) = \frac{\|(\Delta h_m)_J\|_2}{\|\Delta h_m\|_2 + \epsilon}.$$ + +Also track the actual emotion-associated J coordinates, not only the total J fraction. + +Now repeat the intervention while **clamping selected J coordinates to their clean values** at every later workspace layer: + +$$c_{J,m}^{intervened} \leftarrow c_{J,m}^{clean}.$$ + +The decisive pattern is: + +| Observation | Interpretation | +|---|---| +| $e_{\text{off}}$ changes behavior; later J coordinates change; J clamp removes behavior | Off-J input **feeds into** workspace | +| $e_{\text{off}}$ changes behavior; J coordinates remain near-clean; J clamp does not remove behavior | Strong candidate **workspace bypass** | +| $e_J$ changes behavior but $e_{\text{off}}$ does not | Emotion effect largely workspace mediated | +| Neither isolated component works but full $e$ works | Nonlinear interaction or decomposition failure | +| Shuffled/rotated controls work equally well | Geometry/OOD effect, not semantic mechanism | + +This directly extends Anthropic's own observation that apparently non-J components can exert effects by subsequently repopulating J-space.[^19] + +### Temporal propagation and crossing maps + +Repeat the experiment at many source layers and source positions. + +Define + +$$T_{\ell,t\to m,t'} = \frac{\partial h_{m,t'}}{\partial h_{\ell,t}}.$$ + +You do not need the complete tensor to test a candidate direction. Compute JVPs: + +$$\delta h_{m,t'} = T_{\ell,t\to m,t'}\, e_{\text{off}}.$$ + +Then measure both + +$$\|P_{J,m}\,\delta h_{m,t'}\|$$ + +and + +$$\|(I - P_{J,m})\,\delta h_{m,t'}\|.$$ + +Plot layer × future-position heatmaps. A path that propagates causally through attention while remaining weakly J-aligned is exactly the type of mechanism the "off-workspace" hypothesis predicts. + +The full experimental flow is: + +```mermaid +flowchart TD + Extract["Extract emotion or other latent vector e_l"] --> FitDict["Fit J dictionary D_l"] + FitDict --> Sparse["Sparse decompose"] + Sparse --> EJ["e_J"] + Sparse --> EOff["e_off"] + EOff --> Inject["Inject at layer l, position t"] + Inject --> Measure["Measure Δh at later layers"] + Measure --> DeltaDecomp["Decompose each Δh into J / non-J"] + DeltaDecomp --> EntryCheck{"J-space entry?"} + EntryCheck -->|Strong| Writer["Potential writer into workspace"] + EntryCheck -->|Weak| BypassCand["Candidate bypass"] + Writer --> ClampJ["Clamp J coordinates to clean"] + BypassCand --> ClampJ + ClampJ --> SurviveCheck{"Behavioral effect survives?"} + SurviveCheck -->|No| JMediated["J-mediated path"] + SurviveCheck -->|Yes| TraceNonJ["Trace non-J path"] + TraceNonJ --> PatchHeads["Patch attention heads"] + TraceNonJ --> PatchMLP["Patch MLP outputs"] + TraceNonJ --> AttributionGraph["SAE / transcoder attribution graph"] + PatchHeads --> MinimalPath["Minimal causal pathway"] + PatchMLP --> MinimalPath + AttributionGraph --> MinimalPath +``` + +### Read, write, and broadcast assays + +A global workspace theory should make separable predictions about **writing into**, **reading from**, and **broadcasting within** the workspace. + +For an upstream component $c$, define a write effect + +$$W(c \to J) = \|\Delta c_J\|$$ + +when that component is patched or ablated. + +For a downstream component $d$, test read dependence by removing a J-coordinate while measuring $d$'s output: + +$$R(J \to d) = \|d(h) - d(h - \Pi_J h)\|.$$ + +Then ask whether a non-J feature has a sparse set of specialized readers, in contrast with J-space's broad readers. One attractive prediction is: + +$$\text{workspace feature} \Rightarrow \text{many downstream readers},$$ + +whereas + +$$\text{off-workspace feature} \Rightarrow \text{few specialized readers}.$$ + +Anthropic's weight-level analyses already find unusually broad J connectivity and attention heads specialized for preserving J labels across positions, giving a direct benchmark for this comparison.[^15] + +### Automatic versus flexible processing + +Anthropic's line-wrapping experiment provides perhaps the cleanest existing template for finding computation outside J-space. The same underlying information, a running character count, was used automatically to preserve line length without appearing causally in J-space; when the model was asked to report the count or use it in a context-specified downstream operation, number representations appeared in J-space and became swap-sensitive.[^14] + +Generalize that design. Hold stimulus and required latent variable constant while changing only **what must be done with it**: + +$$\text{same information} + \begin{cases}\text{fixed practiced operation}\\ \text{explicit report}\\ \text{arbitrary context-specified operation}\end{cases}$$ + +Candidate domains include: + +| Latent variable | Automatic condition | Flexible condition | +|---|---|---| +| Character count | Preserve wrapping | Report parity or first letter of count | +| Language identity | Continue naturally | Apply arbitrary language-dependent rule | +| Sentiment/emotion | Continue matching tone | Map detected affect to arbitrary symbol | +| Syntax | Continue grammar | Report grammatical role | +| Entity type | Produce routine completion | Apply prompt-defined transformation | +| Numeric magnitude | Continue familiar pattern | Route magnitude to arbitrary downstream operation | + +The especially interesting emotion version is: + +> Does an affective representation alter token selection, risk preference, refusal tendency, or attention allocation automatically while remaining outside J-space, and only become J-aligned when the model is asked to **reflect on or manipulate the emotion explicitly**? + +That experiment connects EmotionScope and global-workspace work far more cleanly than simply correlating their vectors. + +### Path localization after a bypass candidate is found + +Once an $e_{\text{off}}$ intervention survives J-clamping, move to circuit tracing: + +1. Create clean and counterfactual emotional contexts. +2. Find attention-head and MLP-output differences. +3. Patch one component at a time. +4. Search for components whose patch restores/removes the behavioral effect. +5. Repeat while J coordinates are clamped. +6. Recursively path-patch upstream and downstream connections. +7. If suitable SAE/transcoder features exist, construct an attribution graph and classify nodes by J-alignment. +8. Search for a stimulus → outcome path whose intermediate nodes remain below a pre-registered J-alignment threshold. +9. Ablate the entire candidate path. +10. Verify that the original J-space-mediated route remains intact. + +TransformerLens provides activation caching/editing across a broad range of open models, NNsight directly supports activation and gradient intervention, and `circuit-tracer` constructs and intervenes on feature-level attribution graphs when appropriate transcoders are available.[^30] + +The strongest publishable claim would therefore be something like: + +$$\text{Stimulus} \to F_1 \to H_{17.6} \to F_2 \to \text{behavior}$$ + +with + +$$\max_m \mathrm{JAlign}(F_m) < \tau,$$ + +and the behavioral effect surviving J-space clamping while disappearing when this specific path is patched. + +That would be much stronger evidence of a genuine **"path off the global workspace"** than merely observing low J-lens scores. + +## Code, repositories, and practical tooling + +| Repository / library | What it implements | Models / status | Installation and useful entry point | +|---|---|---|---| +| **Anthropic `jacobian-lens`** | Reference J-lens fitting, application, visualization | Examples use Qwen; designed for adaptable HF decoder transformers | `pip install -e .`; `walkthrough.ipynb`; `jlens.fit()` | +| `xiangchensong/jacobian-lens-open-frontier` | Rectangular Jacobians, interventions, FP8 autograd, DeepSeek/GLM replications | DeepSeek-V4-Flash-0731/preview; GLM-5.2 | `pip install -e .`; `experiments/`; `intervene.py`; downloadable fitted lenses | +| `solarkyle/jspace` | J-space experiments, open lenses/traces, reliability probes, early Gemma/Qwen exploration | Gemma 4; Qwen work preserved; laptop-friendly published features | `python campaign/reproduce_mini.py` after LightGBM deps | +| `idhantgulati/j-lens` | Small readable J-lens/J-space implementation | Qwen3.5-4B | `jlens.py`, `interventions.py`, `evals.py`, `main.ipynb` | +| `amaljithkuttamath/jlens-replication` | Null-heavy independent replication | Qwen2.5-3B, Gemma-4-E2B | Useful specifically for shuffled-corpus/truncation controls | +| **EmotionScope** | Emotion-vector extraction, PCA denoising, probing, steering-oriented visualization | Validated Gemma 2 2B IT; HF model swapping supported | `uv sync`; `scripts/extract_all.py`; `validate_all.py` | +| **Tuned Lens** | Learned affine per-layer prediction lenses | Hugging Face transformer ecosystem | `pip install tuned-lens` | +| **TransformerLens** | Hooks, activation caches, patching and intervention infrastructure | Project reports 15,000+ models across 140+ architecture families through TransformerBridge | `pip install transformer_lens` | +| **NNsight** | Generic PyTorch activation/gradient tracing and interventions | Local PyTorch + supported NDIF remote models | `pip install nnsight` | +| **Circuit Tracer** | Transcoder feature attribution graphs and feature interventions | Requires compatible model/transcoder setup | Clone `decoderesearch/circuit-tracer`; best after basic patching skills | + +Anthropic's official repository is at: + + + +It is explicitly described as a **reference implementation that is not maintained and is not accepting contributions**. It includes the fitting library, official synthetic evaluation prompts and an end-to-end walkthrough.[^31] + +A minimal official-style installation is: + +```bash +git clone https://github.com/anthropics/jacobian-lens.git +cd jacobian-lens +pip install -e . +``` + +Fitting follows: + +```python +import jlens + +lens = jlens.fit( + model, + prompts=my_prompts, + checkpoint_path="out/ckpt.pt", +) +lens.save("out/jacobian_lens.pt") +``` + +and application follows the repository's pattern: + +```python +import transformers +import jlens + +hf = transformers.AutoModelForCausalLM.from_pretrained( + "org/model", +).cuda() + +tok = transformers.AutoTokenizer.from_pretrained("org/model") +model = jlens.from_hf(hf, tok) + +lens = jlens.JacobianLens.from_pretrained( + "org/lens-repo", + filename="model/lens.pt", +) + +lens_logits, model_logits, _ = lens.apply( + model, + "Fact: The currency used in the country shaped like a boot is", + positions=[-2], +) +``` + +Those APIs and example structure are provided by the official repository.[^31] + +The most important DeepSeek port is: + + + +It adds rectangular `d_source` / `d_target` Jacobians, intervention primitives, FP8 autograd support, experiment scripts, and fitted lenses. The DeepSeek-V4-Flash lens is $4096 \times 16384$; GLM-5.2 uses a conventional $6144 \times 6144$ lens.[^5] + +Pre-fitted artifacts include: + +- +- + +The repository's GLM example is essentially: + +```python +import transformers +import jlens + +name = "zai-org/GLM-5.2-FP8" + +hf = transformers.AutoModelForCausalLM.from_pretrained( + name, + dtype="auto", + device_map="auto", +) +tok = transformers.AutoTokenizer.from_pretrained(name) +model = jlens.from_hf(hf, tok) + +lens = jlens.JacobianLens.from_pretrained( + "xiangchensong/jacobian-lens-glm-5.2" +) + +lens_logits, _, _ = lens.apply( + model, + "calc: 3+4=7\ncalc: 10*2=20\ncalc: 8-3=5\ncalc: (4+17)*2+7=", + positions=[-1], +) +``` + +The authors report that this prompt exposes the intermediate `21` before the final `49`.[^5] For native FP8 fitting, their fork requires registering `jlens.fp8_autograd` before constructing the model.[^5] + +For a junior developer, the simpler implementation + + + +is valuable because the code is concentrated into `jlens.py`, `interventions.py`, `evals.py`, and one notebook, on **Qwen3.5-4B**.[^32] + +```bash +git clone https://github.com/idhantgulati/j-lens.git +cd j-lens +pip install torch transformers datasets huggingface_hub matplotlib +``` + +For reliability and publicly downloadable traces: + + + +The current repository contains a preregistered 25,340-prompt Gemma-4-12B reliability campaign, fitted lenses and traces on Hugging Face, and documentation of an important answer-identity confound. It also preserves earlier exploratory Gemma/Qwen workspace experiments.[^33] Its lightweight reproduction is: + +```bash +pip install lightgbm numpy huggingface_hub +git clone https://github.com/solarkyle/jspace +cd jspace +python campaign/reproduce_mini.py +``` + +The repository says this reproduces its committed Stage-2 scoring experiment on CPU in roughly 90 seconds.[^24] + +The particularly useful skeptical replication is: + + + +It is worth cloning even if you do not reproduce its headline experiments because its **shuffled-corpus J-lens and prompt-truncation controls** should be folded into new projects by default.[^6] + +EmotionScope: + + + +The documented Gemma 2 2B workflow is:[^21] + +```bash +git clone https://github.com/AidanZach/EmotionScope.git +cd EmotionScope +uv sync +cd frontend && npm install && cd .. + +uv run python scripts/extract_all.py \ + --model google/gemma-2-2b-it \ + --sweep-layers + +uv run python scripts/validate_all.py \ + --vectors results/vectors/google_gemma-2-2b-it.pt +``` + +A different Hugging Face model can be attempted with: + +```bash +uv run python scripts/extract_all.py \ + --model meta-llama/Llama-3-8b-instruct \ + --sweep-layers \ + --use-4bit +``` + +EmotionScope recommends Python 3.11+, Node 18+ for its frontend, and an NVIDIA GPU with at least 8 GB VRAM.[^21] + +The original tuned-lens implementation is: + + + +```bash +pip install tuned-lens +``` + +Its translators are trained to minimize KL divergence between intermediate-layer predictions and the original model's final output distribution.[^34] + +For general intervention work, use current TransformerLens: + + + +```bash +pip install transformer_lens +``` + +```python +from transformer_lens.model_bridge import TransformerBridge + +bridge = TransformerBridge.boot_transformers("gpt2", device="cuda") +logits, cache = bridge.run_with_cache("The Eiffel Tower is in") +``` + +The current project recommends `TransformerBridge` for Hugging Face parity and reports support for over 15,000 model checkpoints across more than 140 architecture families.[^35] + +NNsight: + + + +```bash +pip install nnsight +``` + +is particularly attractive when a model does not fit cleanly into TransformerLens abstractions. It exposes intermediate activations, interventions, gradients and batched multi-input experiments, and can use NDIF for supported models that are too large to execute locally.[^36] + +For feature-level circuit tracing: + + + +The library constructs attribution graphs between active transcoder features, errors, input tokens and output logits, visualizes them and permits feature-level intervention. That is the most directly relevant existing framework once an off-J candidate has been identified and you need to convert "there is another channel" into "this is the circuit carrying it."[^27] + +## Hands-on onboarding plan + +A good junior-developer plan is **ten working days**, with the first week reproducing known effects and controls and the second week implementing one genuinely novel off-workspace test. + +The default hardware target should be **one 16–24 GB NVIDIA GPU**. EmotionScope's baseline requires only about 8 GB, and public J-lens work demonstrates consumer-scale Gemma fitting on 16 GB.[^21] Do **not** begin by fitting DeepSeek-V4 or GLM-5.2: those are frontier-cluster experiments. The open-frontier models have 304B and 753B total parameters respectively, and the GLM work required special FP8 gradient infrastructure precisely because ordinary higher-precision execution was impractical.[^5] + +| Day | Task | Model/data | Compute | Expected wall time | Checkpoint | +|---|---|---|---|---|---| +| Mon A | Read logit/J-lens concepts; install TransformerLens + jlens | GPT-2 or Qwen/Gemma ≤4B | CPU/8–16 GB GPU | 2–4 h | Can cache residuals and manually apply logit lens | +| Tue A | Load pre-fitted or minimal J-lens; inspect layer×position readouts | Qwen3.5-4B or compatible model | 16 GB | 2–4 h | Hidden intermediate visible | +| Wed A | Reproduce multihop/arith probe and compare logit vs J-lens | Official synthetic eval prompts | 16 GB | 3–6 h | Quantitative rank curves | +| Thu A | Fit own small lens, $n = 10$ then $n = 25$ | Generic 128-token text | 16–24 GB | ~30 min–4 h/run depending GPU/implementation | Own saved $J_\ell$ | +| Fri A | Fit shuffled control; prompt truncation; random ablations | Same tokens, shuffled order | 16–24 GB | Half to full day | **Go/no-go:** real lens beats nulls | +| Mon B | Install EmotionScope; reproduce vector extraction/probe | Gemma 2 2B IT | 8–16 GB | 2–5 h | `afraid`, `calm`, etc. reproducibly score | +| Tue B | Compute emotion × J-space sparse decompositions | Same model/layers | 16 GB | 2–4 h | $e_J, e_{\text{off}}$ stored with reconstruction stats | +| Wed B | Run full/J/off/random intervention dose curves | 50–200 held-out prompts | 16–24 GB | 4–8 h | Causal component comparison | +| Thu B | Implement downstream J-entry tracking and J-coordinate clamping | Same prompts | 16–24 GB | 4–8 h | First workspace mediation result | +| Fri B | Path-patch strongest candidate; replicate second seed/model if possible | Gemma + Qwen second family | 24 GB useful | Full day | Reproducible causal bypass or falsification | + +The very wide lens-fitting runtime range is intentional. The exact-J computation is unusually implementation-sensitive: Anthropic describes the reference code as unoptimized, an optimized public Gemma-4 workflow reports roughly 77 s/prompt on a 16 GB consumer GPU, while the null-heavy T4 replication reports 234 minutes for a 25-prompt shuffled fit.[^37] + +A junior developer should use these datasets: + +| Dataset | Purpose | +|---|---| +| Anthropic `jacobian-lens/data/evaluations` | Known multihop, multilingual, arithmetic and other hidden intermediates | +| Generic WikiText/Pile-like 128-token samples | Lens fitting only | +| Token-shuffled copy of fitting set | Null lens | +| EmotionScope `data/templates` | Initial emotion-vector reproduction | +| EmotionScope `data/neutral` | Neutral PCA nuisance removal | +| Held-out implicit emotion/dose prompts | Semantic generalization | +| Paired automatic/flexible prompts | Off-workspace selectivity | +| Independently authored held-out prompts | Confirmation | + +Anthropic's repository explicitly releases its synthetic evaluation prompts but does not bundle the generic text corpora or model weights; those retain their own licensing requirements.[^31] EmotionScope ships its template, neutral and validation datasets in its repository.[^21] + +The essential checkpoints are: + +**End of the first three days:** the developer can distinguish *prediction decoding* from *causal intermediate readout*. A multihop prompt should show an intermediate in J-lens before the answer, and the developer should be able to inspect the corresponding logit lens. + +**End of the first week:** no claim survives unless the coherent-corpus J-lens has been compared with a shuffled fit, the hidden concept disappears or changes appropriately under semantic prompt manipulation, and interventions outperform rank/norm-matched random controls. + +**Mid-second week:** the developer has measured, for an emotion vector, + +$$\frac{\|e_J\|^2}{\|e\|^2}, \qquad \frac{\|e_{\text{off}}\|^2}{\|e\|^2},$$ + +along with behavioral dose-response curves for both pieces. + +**End of the project:** the main result is **not** "emotion lies mostly outside J-space." Variance alone is uninteresting because Anthropic already finds J-space represents a small fraction of total activation variance.[^19] The meaningful endpoint is one of two conclusions: + +$$e_{\text{off}} \to J \to \text{behavior}$$ + +or + +$$e_{\text{off}} \to \text{localized non-J circuit} \to \text{behavior}, \quad \text{even with } J \text{ clamped}.$$ + +The first would establish that affective information exists outside the workspace but is **written into it before flexible use**. The second would be substantially more novel evidence of a genuine automatic or "sub-workspace" communication pathway. + +The onboarding timeline visually: + +```mermaid +gantt + title J-space and off-workspace research onboarding + dateFormat YYYY-MM-DD + excludes weekends + section Foundations + Tooling + residual hooks :2026-08-10, 1d + Logit and J-lens readout :2026-08-11, 1d + section Lens validation + Hidden-intermediate eval :2026-08-12, 1d + Small-corpus J-lens fit :2026-08-13, 1d + Shuffled/truncation controls :crit, 2026-08-14, 1d + section Emotion vectors + EmotionScope reproduction :2026-08-17, 1d + J vs non-J decomposition :2026-08-18, 1d + section Off-workspace tracing + Causal intervention sweeps :2026-08-19, 1d + Temporal tracking + J clamp :crit, 2026-08-20, 1d + Path patch + replication :crit, 2026-08-21, 1d +``` + +For someone constrained to one week, stop after the initial emotion decomposition and implement only one carefully controlled J-clamping experiment. That is more scientifically useful than rapidly adding many weak probes. + +## Prioritized reading list + +**Anthropic, "Verbalizable Representations Form a Global Workspace in Language Models" (Gurnee et al., 2026).** + + +This is the primary paper. Read the Methods, "J-space acts as a Global Workspace," structural/broadcast section, methodological ablations and limitations. The most important ideas for new work are not the spectacular qualitative readouts but the sparse-frame formalization, intervention protocols, automatic-versus-flexible task comparison, broadcast-head analysis, and explicit admission that automatic pathways and mechanisms of workspace entry remain unresolved.[^38] + +**Anthropic reference implementation, `anthropics/jacobian-lens`.** + + +Read `walkthrough.ipynb` and the fitting module before implementing the Jacobian yourself. The exact averaging convention over target/source positions is easy to get subtly wrong.[^31] + +**Hernandez et al., "Linearity of Relation Decoding in Transformer Language Models."** + + +This is the best conceptual precursor for understanding *why* a Jacobian can serve as a reusable semantic map instead of merely as a conventional gradient attribution. It is especially useful if the eventual off-workspace project involves relational or structured latent variables.[^39] + +**Belrose et al., "Eliciting Latent Predictions from Transformers with the Tuned Lens."** + + +Repository: + + +Read this alongside J-lens rather than as obsolete background. It makes the causal-versus-correlational distinction vivid: tuned lens is optimized for predicting the eventual model output; J-lens linearizes actual downstream sensitivity.[^40] + +**nostalgebraist, "Interpreting GPT: the Logit Lens."** + + +The original 2020 exposition is still worth reading because logit lens remains the correct trivial baseline. If a J-lens result cannot outperform or qualitatively improve upon the logit lens for the phenomenon being claimed, the expensive machinery is not earning its keep. Anthropic likewise reports that the logit lens remains surprisingly useful once inside the later workspace.[^41] + +**Heimersheim & Nanda, "How to Use and Interpret Activation Patching."** + + +Essential for the transition from **"what variable is present?"** to **"where does its causal influence travel?"** Read before attempting an off-J path claim. The paper emphasizes how corruption design, intervention direction and evaluation metric influence activation-patching conclusions.[^26] + +**Anthropic / Decode Research circuit tracing and attribution graphs.** +Methods: +Code: + +This is the most natural downstream technology after identifying a J-space bypass candidate: turn a residual-level result into a sparse network of feature-to-feature effects, then intervene on the candidate graph.[^27] + +**Anthropic, "Emotion Concepts and their Function in a Large Language Model."** + + +This is the primary methodological basis for the proposed emotion × J-space experiment. It establishes internal emotion-associated directions and causal behavioral steering while deliberately avoiding claims that those mechanisms imply subjective emotion.[^42] + +**EmotionScope.** + + +Best practical open-weight starting point for a junior developer because the pipeline includes extraction, nuisance-PC removal, validation, model hooks and a ready-made 2B model target. Its README is unusually explicit about its own small-$n$, cross-model-corpus and entanglement limitations.[^21] + +**Song & Feng, "The Jacobian Lens at Frontier Scale."** +Repository: +Write-up: + +This is currently the most important open-weight architecture-generalization study because it tackles a nonstandard four-stream DeepSeek architecture and a huge FP8 MoE rather than merely applying the lens to another conventional small decoder. The particularly important result is the **failure** of Claude's clean reasoning-versus-routine-prediction dissociation to replicate.[^5] + +**Neel Nanda, review of Anthropic's global-workspace paper.** + + +This is useful expert commentary rather than primary evidence. Nanda and collaborators explored the method on Qwen3.6-27B and argue that J-lens is promising as a **hypothesis-generation tool**, while emphasizing false positives and the fact that it exposes variables rather than fully tracing the model's algorithms. That distinction is exactly why an off-workspace project should add circuit localization.[^43] + +**Null-heavy small-model replication.** + + +Read this before publishing any passive J-lens benchmark. Its shuffled-corpus result is one of the most useful early falsification checks to emerge from open replication work.[^6] + +**`solarkyle/jspace`.** + + +The most useful lesson here is methodological rather than philosophical: preregistration, held-out transfer and explicit auditing for answer-identity confounds substantially change what can be claimed from workspace-derived probes.[^33] + +Taken together, these sources suggest a productive division of labor: + +| Tool | Question it answers | +|---|---| +| J-lens | What is globally verbalizable? | +| Sparse J decomposition | Which part of this feature lies there? | +| Swap/ablate/clamp | Does that representation causally matter? | +| Temporal JVPs | Where does the perturbation propagate? | +| Activation/path patching | Which components carry it? | +| SAE/transcoder graph | What interpretable circuit implements the route? | + +For the proposed emotion/global-workspace research program, the highest-value experiment is therefore not another correlation between emotion vectors and J-lens scores. It is a **causal mediation experiment** that decomposes an affective direction, injects its non-J remainder, continuously measures workspace entry, clamps J-space to its clean trajectory, and then path-patches whatever behavioral effect survives. That design directly tests the open question Anthropic leaves unresolved: **what computations genuinely remain beneath the globally verbalizable workspace, and through what physical paths in the transformer do they influence behavior?**[^44] + +## References + +[^1]: Verbalizable Representations Form a Global Workspace in Language Models — +[^2]: Verbalizable Representations Form a Global Workspace in Language Models — +[^3]: Verbalizable Representations Form a Global Workspace in Language Models — +[^4]: Verbalizable Representations Form a Global Workspace in Language Models — +[^5]: xiangchensong/jacobian-lens-open-frontier: The Jacobian lens on open frontier-scale models: replicating Anthropic's global-workspace results on DeepSeek-V4-Flash (4-stream hyper-connections) and GLM-5.2 (753B/40B-active) — +[^6]: J-lens on small open-weight models — a null-heavy replication — +[^7]: AidanZach/EmotionScope: Replicates and extends Anthropic's April 2026 paper "Emotion Concepts and their Function in a Large Language Model" on open-weight models — +[^8]: Verbalizable Representations Form a Global Workspace in Language Models — +[^9]: [2303.08112] Eliciting Latent Predictions from Transformers with the Tuned Lens — +[^10]: Verbalizable Representations Form a Global Workspace in Language Models — +[^11]: Verbalizable Representations Form a Global Workspace in Language Models — +[^12]: [2308.09124] Linearity of Relation Decoding in Transformer Language Models — +[^13]: Verbalizable Representations Form a Global Workspace in Language Models — +[^14]: Verbalizable Representations Form a Global Workspace in Language Models — +[^15]: Verbalizable Representations Form a Global Workspace in Language Models — +[^16]: Verbalizable Representations Form a Global Workspace in Language Models — +[^17]: jlens-replication/RESULTS.md at main — +[^18]: Verbalizable Representations Form a Global Workspace in Language Models — +[^19]: Verbalizable Representations Form a Global Workspace in Language Models — +[^20]: TransformerLensOrg/TransformerLens: A library for mechanistic interpretability of GPT-style language models — +[^21]: AidanZach/EmotionScope — +[^22]: Emotion Concepts and their Function in a Large Language Model — +[^23]: adamhollowell/gemma-emotion-vectors — +[^24]: solarkyle/jspace: Preregistered Jacobian-lens reliability research on Gemma 4: 25k prompts, frozen probes, public traces, a prospective transfer miss, and an answer-identity confound — +[^25]: Verbalizable Representations Form a Global Workspace in Language Models — +[^26]: [2404.15255] How to use and interpret activation patching — +[^27]: decoderesearch/circuit-tracer — +[^28]: AidanZach/EmotionScope — +[^29]: Verbalizable Representations Form a Global Workspace in Language Models — +[^30]: TransformerLensOrg/TransformerLens — +[^31]: anthropics/jacobian-lens: Companion code for the global workspace interpretability paper — +[^32]: idhantgulati/j-lens: minimal J-lens / J-space implementation and visualization (Gurnee et al., 2026) on qwen3.5-4B — +[^33]: solarkyle/jspace: Preregistered Jacobian-lens reliability research on Gemma 4 — +[^34]: AlignmentResearch/tuned-lens: Tools for understanding how transformer predictions are built layer-by-layer — +[^35]: TransformerLensOrg/TransformerLens — +[^36]: ndif-team/nnsight: The nnsight package enables interpreting and manipulating the internals of deep learned models — +[^37]: anthropics/jacobian-lens: Companion code for the global workspace interpretability paper — +[^38]: Verbalizable Representations Form a Global Workspace in Language Models — +[^39]: [2308.09124] Linearity of Relation Decoding in Transformer Language Models — +[^40]: [2303.08112] Eliciting Latent Predictions from Transformers with the Tuned Lens — +[^41]: interpreting GPT: the logit lens — +[^42]: Emotion Concepts and their Function in a Large Language Model — +[^43]: A review of Anthropic's global-workspace paper (LessWrong) — +[^44]: Verbalizable Representations Form a Global Workspace in Language Models —