Research log Small Model Experimentation
GitHub

Qwen3.5-4B Jacobian Value Transport

Finished2026-07-12Interpretability and DiagnosticsStructured Execution and CompilersTest-Time Reasoning BudgetGitHub ↗
You can edit the word, not the meaning

The one idea you need

Picture a speaker reading from a teleprompter. The edit rewrites the last word an instant before they say it, so they announce a new concept out loud. But their mental picture never changed, so any follow-up reasoning still runs on the original concept.

The question

If you reach inside a small model and swap the concept it is about to say, does the rest of its reasoning follow along and recompute?

What we found

No. Editing one internal direction at a late layer flipped the concept the model said aloud on 18 of 24 tries, up from never, and far beating an ordinary readout-style edit that worked only 1 in 5 times. But when that concept had to feed a follow-up calculation, the edit changed nothing on all 24 items, at every layer. It moved the model's mouth, not its mind.

Why it matters

If you steer a small model by editing its internal directions, don't assume the change reprograms its reasoning. Test whether downstream steps actually recompute from your edit — a direction can be readable, even writable, yet completely inert for real thinking.

Concept the model said out loud0% → 75%how often the edit flipped the spoken concept, at the best layer (18 of 24 items)
Follow-up answer using that concept0 of 24times the same edit changed a downstream calculation, at every layer tested
An ordinary readout-style editabout 1 in 5how often the plain edit flipped the spoken concept, versus 3 in 4 for the targeted one
Downstream lean as edit force grew eightfoldno changethe follow-up stayed pinned to the original concept while the spoken concept crossed over
On this page
  1. Results at a glance
  2. Overview
  3. Report
    1. Verdict
    2. Design and data
    3. G0 confirmation results
    4. Frozen gate audit
    5. What the intervention appears to be
    6. Honest protocol notes
    7. Decision and next experiment
    8. Compute and artifacts
  4. Experiment log
  5. Data files
  6. Reproduce
  7. Related

Results at a glance 2

How often the edit changed the answer, by model layer

How to read

The horizontal axis is which layer was edited, 8 to 24; the vertical axis is how often the edit produced the target concept, so higher is a stronger edit. Three lines track the spoken concept, a follow-up calculation, and an ordinary readout-style edit.

0%25%50%75%100%101520direct report, Jacobian coordinatedirect report, Ja…direct report, logit-lens controldirect report, lo…mapped consequence, Jacobian coordinatemapped consequenc…

Takeaway → The spoken-concept line spikes to three-quarters only at the last layer, the readout edit reaches one-fifth, and the follow-up-calculation line never leaves zero.

Data table
model layerdirect report, Jacobian coordinatemapped consequence, Jacobian coordinatedirect report, logit-lens control
80%0%0%
120%0%0%
160%0%0%
204.2%0%0%
2475%0%20.8%

Numbers from experiments/qwen35_4b_jacobian_value_transport/analysis/metrics.json

Technical framing

Target-answer rate by intervention layer — Untouched 24-item confirmation split at selection-chosen alpha 4. Baseline and random-control target rates were zero. The random control was not exact realized-delta-norm matched, so direct-control specificity is provisional; the zero consequence effect is the frozen gate failure.

As the edit gets stronger, does the follow-up answer move?

How to read

The horizontal axis is edit strength, rising eightfold left to right; the vertical axis is how far the output leans toward the new concept versus the original, where above zero favors the new. One line is the spoken concept, the other the follow-up calculation.

-15-10-5051234direct reportmapped consequence

Takeaway → The spoken-concept line climbs and crosses into new-concept territory; the follow-up line stays pinned far below and flat — more force never switched the reasoning.

Data table
intervention strength (alpha)direct reportmapped consequence
0.5-8.82-8.57
1-6.98-8.57
2-3.43-8.56
43.22-8.57

Numbers from experiments/qwen35_4b_jacobian_value_transport/analysis/metrics.json

Technical framing

Target-minus-source margin as intervention strength rises — Selection split at layer 24. Positive values favor the target. Direct reporting crosses zero; the mapped consequence remains flat and strongly favors the source.

In the author’s words from the Overview · “Results”

Terminal G0 verdict: NO_J_WRITING under the frozen decision rule, with a more informative mechanistic split: late direct writing worked; causal transport did not. Clean confirmation accuracy was 24/24 for direct concept report and 24/24 for the prompt-local mapped consequence. At layer 24 and the selection-chosen alpha 4, the J swap changed the direct report to the target concept on 18/24 items (75%). Random stayed 0/24 and the ordinary logit-lens swap reached 5/24 (20.8%). The same J intervention changed the mapped downstream consequence on 0/24 items at every tested layer. Its target-minus-source margin was essentially flat as alpha rose from 0.5 to 4. … Read the full result →

Overview

This experiment tests whether token-aligned Jacobian coordinates can carry causal value from native thinking into fresh, exactly scored answers more specifically than ordinary activation steering.

Research Program

  • Primary program: interpretability_and_diagnostics
  • Secondary programs if the causal gate passes: test_time_reasoning_budget, structured_execution_and_compilers, and posttraining_and_adaptation
  • Prior anchors: C19/C20 (decodable first operation but inert ActAdd), C30 (decode-to-prompt works), C40/C42 (implicit confidence and step-local error signal), C51 (forced-close answer potential is an unreachable-state scorer), and C52 (token-local outcome labels do not make LoRA updates context-local).

Question

Does Qwen3.5-4B expose sparse, token-aligned Jacobian coordinates that are not only readable but causally transported from native thinking into later answers, and can coordinate replacement change verifier-scored outcomes more specifically than ordinary activation addition?

Hypothesis

The residual stream contains two separable quantities: the strength of a candidate intermediate representation and the local downstream gain from that representation to the answer. C20 manipulated only the first with a global mean-difference vector. A Jacobian-lens coordinate swap should be more effective because it uses a model-native downstream-readable direction, removes a competing coordinate while adding the target, and can be clamped through the layer band in which transport is open.

The causal premise counts only if a J-coordinate intervention changes exact future outcomes beyond matched random, wrong-donor, shuffled-label, raw-activation, non-J/remainder, logit-lens, and ActAdd controls. Decoding or outcome prediction alone is not a positive result.

Setup

  • Model: only Qwen/Qwen3.5-4B, revision 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a, bf16 Transformers inference.
  • Substrate: fresh procedural list transformations generated inside this experiment. String and register transformations are held-family checks. No benchmark content is read or used.
  • Splits: disjoint lens-fit corpus, positive-control calibration, value calibration, IID evaluation, held-family evaluation, and hard-depth evaluation.
  • Primary baseline: the frozen model under the same HF backend, prompts, seeds, decoding budget, and full-prefix recomputation used by intervention arms.
  • Primary metrics: intervention-induced target-concept rate on positive controls; within-task prefix-value AUROC; and exact verifier success after causal patching.
  • Oracle-only evidence: correct-operation directions, reference-answer margins, and high-value donor selection. These establish an upper-bound causal mechanism and cannot support a deployable claim.
  • Hidden-label boundary: exact operation and hidden examples may score or construct oracle diagnostics, but no non-oracle controller may receive them as inputs.

The frozen gates and analysis rules are in reports/preregistration.md; the adversarial review is in reports/design_review.md.

Run

CPU tests and data smoke:

.venv/bin/python -m pytest experiments/qwen35_4b_jacobian_value_transport/tests -q
.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage smoke

Real-model plumbing smoke, after the immutable design commit is recorded:

.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage model-smoke

Scientific stages are individually restartable and gate the next stage:

.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage fit-lens
.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage positive-control
.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage prefix-value
.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage causal-patch

--stage full runs the permitted sequence and refuses to cross a failed gate.

Results

Terminal G0 verdict: NO_J_WRITING under the frozen decision rule, with a more informative mechanistic split: late direct writing worked; causal transport did not.

  • Clean confirmation accuracy was 24/24 for direct concept report and 24/24 for the prompt-local mapped consequence.
  • At layer 24 and the selection-chosen alpha 4, the J swap changed the direct report to the target concept on 18/24 items (75%). Random stayed 0/24 and the ordinary logit-lens swap reached 5/24 (20.8%).
  • The same J intervention changed the mapped downstream consequence on 0/24 items at every tested layer. Its target-minus-source margin was essentially flat as alpha rose from 0.5 to 4.
  • Earlier layers were inert; layer 20 moved direct report on only 1/24, so no adjacent-layer pair passed. G1 prefix value and G2 task patching were correctly cancelled.

The full terminal result is in reports/report.md.

Interpretation

The averaged token pullback is a strong late output-control coordinate on this model, not yet evidence of a reusable reasoning workspace. It can overwrite what concept the model says, but the tested intervention does not make the model recompute an arbitrary consequence from that concept. The next warranted test is a separate experiment using context-local transport, set-to-target clamping across an earlier layer band, and exact per-example delta-norm controls.

Knowledgebase Update

  • Program evidence: updated after synchronizing the terminal result to origin/main.
  • Program backlog: branch to context-local clamped transport in a new experiment.
  • Claim ledger: unclaimed while the repository-wide adversarial claim re-grade is open; no number is reserved.

Artifacts

  • Small split manifests, smoke receipts, metrics, and reports are committed.
  • Full Jacobian matrices and activation caches remain external and checksummed in reports/artifact_manifest.yaml.
  • No adapter is trained in this causal-premise experiment.

Report

Rendered from reports/report.md

Verdict

Terminal frozen label: NO_J_WRITING (G0 failed). The label hides a useful split: the targeted J direction was strongly writable at one late layer, but it did not behave like a reusable intermediate that downstream computation could consume.

On the untouched 24-item confirmation half, a layer-24 source-to-target J swap changed direct concept reports from 0/24 target answers at baseline to 18/24 (75%). A logit-lens swap reached 5/24 (20.8%); random reached 0/24. Yet the same J swap changed a prompt-local consequence of the concept on 0/24, at every layer. Earlier layers were inert, so the required adjacent-layer criterion also failed. Per preregistration, prefix-value mapping and task-level causal patches were not run.

This is a negative for the paper's transferable-workspace premise on this fixed 4B under an averaged single-token lens and pairwise coordinate swap. It is not a negative for context-local Jacobians, true set-to-target clamping, or counterfactual reflection training.

Design and data

  • Model: only Qwen/Qwen3.5-4B, revision 851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a.
  • Backend: Transformers 5.13.0, torch 2.11.0, bf16 SDPA, with the Qwen hybrid fast path available.
  • Lens corpus: 64 fresh procedural prompts, disjoint from all control and task splits.
  • Dictionary: 24 concepts verified as single leading-space tokens.
  • Source layers: 8, 12, 16, 20, 24; target block output: 31.
  • Estimator: equal weighting over every valid causal source/target-position pair, rather than summed-future-target weighting per source.
  • Positive controls: 48 fresh prompt-local items, split deterministically into 24 selection and 24 confirmation items.
  • Clean tasks: direct report of a selected concept and a separate arbitrary mapping from the concept to a digit consequence.

The selection half chose alpha 4 and the nominal layer pair [20, 24]. The confirmation half remained untouched until that choice was frozen. All 5,088 per-item condition rows are in runs/positive_control_rows.jsonl.

G0 confirmation results

Target-answer rate at the selected alpha:

layerdirect Jdirect randomdirect logit lensmapped consequence J
80.0%0.0%0.0%0.0%
120.0%0.0%0.0%0.0%
160.0%0.0%0.0%0.0%
204.2%0.0%0.0%0.0%
2475.0%0.0%20.8%0.0%

Baseline source accuracy and parse rate were 100% in both tasks. Layer-24 J writing preserved a 100% direct parse rate while reducing source answers to 25% and increasing target answers to 75%. A wrong-concept J swap also reduced source answers to 25% without increasing the registered target, consistent with writing the wrong concept rather than causing generic corruption.

The consequential task did not merely miss the argmax threshold. At layer 24 on the selection half, mean target-minus-source digit margin stayed flat:

alphadirect-report marginconsequence margin
0.5-8.82-8.57
1.0-6.98-8.57
2.0-3.43-8.56
4.0+3.22-8.57

The intervention monotonically crossed the direct report boundary while having essentially zero effect on the consequence. That is the central result.

Frozen gate audit

  • Clean accuracy >= 0.70: pass (1.00 direct and consequence).
  • Direct target shift >= +0.20: pass at layer 24 only (+0.75).
  • Consequence target shift >= +0.15: fail at every layer (+0.00).
  • J minus random >= +0.10: direct layer 24 passes; consequence fails.
  • Two adjacent tested layers pass: fail.
  • Parse-rate drop <= 0.10: pass.

Overall G0: fail. G1 and G2 were ineligible by the frozen decision rule.

What the intervention appears to be

The layer profile is late and motor-like. Nothing meaningful happens through layer 16; a weak direct effect appears at layer 20; layer 24 strongly controls the imminent concept token. If this were a broadly readable intermediate workspace coordinate, changing the selected concept should also have changed the random mapping consequence. It did not.

The result therefore favors “late token-aligned output control” over “reusable causal reasoning variable” for this averaged lens on Qwen3.5-4B. It also explains why a readable coordinate need not unlock capability: making a word easier to say is different from making downstream circuitry recompute with its meaning.

Honest protocol notes

  1. A tokenizer preflight initially stopped before any result artifact because space-plus-digit was two tokens. The corrected, pre-result contract puts the space in the fixed Value: prefix and scores one bare digit token.
  2. The random coordinate write used normalized random dictionary pairs but did not exactly match the realized per-example J delta norm. At direct layer 24, mean J delta norm was 13.64 versus 2.64 random. This weakens the strength of the direct J-versus-random specificity claim. It cannot rescue G0: the much larger J perturbation still had zero consequence effect, and consequence layer-24 norms were closer (4.96 J versus 4.04 random).
  3. Applying a swap independently at both layers [20, 24] can swap a coordinate toward the target and then swap it back. Its low band result is not treated as a test of the paper's set-to-target clamping operation and does not enter the individual-layer frozen gate.
  4. The positive control is next-token consequential inference, not multi-step native thinking. G0 was deliberately required before the more expensive thought-prefix stages.

Decision and next experiment

Do not run prefix-value or task-patching stages with this lens. Preserve the negative and start a new result-bearing experiment that changes the mechanism:

  • use a context-local Jacobian from the selected concept to the actual consequence margin;
  • set source coordinates low and target coordinates high across an earlier layer band instead of repeatedly swapping them;
  • apply the clamp across the positions where the concept is represented;
  • construct orthogonal controls with the exact realized J delta norm per item;
  • retain the direct-versus-consequence firewall before entering native thinking.

Only if that consequence gate passes should the program return to think-prefix value and exact task success.

Compute and artifacts

  • Targeted fit: 29.3 seconds, 12.3 GB peak allocated, 617,627-byte lens artifact.
  • G0 sweep and confirmation: 40.5 seconds after model load.
  • No training, adapter, benchmark seed, G1 continuation, or G2 task-patching compute was consumed.
  • See reports/artifact_manifest.yaml for the conditional full-J artifacts that were correctly not generated after G0 failed.

Experiment log 6

Show the running log (6 entries, 2026-07-12)

2026-07-12 — intake and design freeze preparation

  • Synchronized the clean main worktree with origin/main before creating the experiment.
  • Ran related-work discovery for Jacobian transport, think-prefix value, causal coordinate patching, and counterfactual reflection.
  • Selected interpretability_and_diagnostics as the primary program and named qwen35_4b_activation_steering as the closest near-duplicate.
  • Separated final correctness from token-level credit: the design uses common-prefix sibling continuations and exact rollout value rather than broadcasting a trace label across all thought tokens.
  • Added a mandatory Qwen-specific positive control before any value or capability claim, plus an immutable design boundary before real-model scientific work.
  • No result-bearing model call has occurred in this experiment.

2026-07-12 — immutable design boundary

  • The design commit was rebased onto concurrent origin/main work and finalized as 57fe5249e38f1e498e53a63ea4e9a72c0b48e2f0.
  • Frozen preregistration SHA-256: a7e5711236f9c0dd0c39182c1ccad4c881cf18b604247a12f5362faafc627bae.
  • Frozen README SHA-256: 119b20dcbb41dbc578cc8aabbbcb7cf65739fc734180654dcfd0f5f69d12fdf0.
  • The run harness now fails closed unless this commit is an ancestor and both frozen-file digests match. Scientific GPU work remains unstarted.

2026-07-12 — real-model plumbing gate

  • Recreated the pinned Transformers environment and verified torch 2.11.0, Transformers 5.13.0, flash-linear-attention 0.5.1, and causal-conv1d 1.6.2.post1.
  • Tokenizer audit confirmed the configured think tokens and all 24 positive- control concepts as single leading-space tokens.
  • The first real targeted pullback fitted four token directions at layers 8, 16, and 24 from two 64-token prompts with explicit equal causal-pair weighting. All directions were finite and nonzero.
  • A first coordinate-write attempt exposed that torch.linalg.pinv rejects bf16 inputs. The implementation now reads coordinates in fp32 and casts only the final residual delta back to bf16; a regression test covers this path.
  • The rerun passed: 26 CPU tests, 9.25 GiB peak allocated model memory, and a nonzero mean patch delta norm of 0.4045 in cache-free full-prefix generation. These are plumbing checks and carry no scientific evidence.

2026-07-12 — pre-result G0 implementation freeze

  • Added the preregistered calibration-only coordinate scale sweep {0.5, 1.0, 2.0, 4.0} before any positive-control outcome was observed.
  • Implemented batched fp32 pseudoinverse coordinate reads, next-token direct and downstream-consequence controls, deterministic random/logit/wrong controls, and selection-half versus confirmation-half isolation.
  • G0 implementation changes will be committed and pushed before fitting the 64-prompt scientific targeted lens.

2026-07-12 — G0 tokenizer preflight stop

  • The 64-prompt targeted lens fit completed in 29.3 seconds at 12.3 GB peak; all 120 layer/concept directions were finite and nonzero.
  • G0 then stopped before writing an outcome artifact because leading-space digit strings tokenize as two tokens (space, digit). No gate result was observed or reduced.
  • Corrected the contract: direct concepts are scored as their fitted leading- space tokens after Concept:, while the Value: prefix owns the space and the following digit is scored as one bare token.

2026-07-12 — terminal G0 result

  • G0 completed in 40.5 seconds over 5,088 stored per-item rows.
  • Clean confirmation accuracy and parse rate were both 1.00.
  • The layer-24 alpha-4 J swap changed direct report to the target on 18/24 items, versus 0/24 random and 5/24 logit lens.
  • Every J layer changed the mapped consequence on 0/24 items. No adjacent layer pair passed, so the frozen terminal decision is NO_J_WRITING and G1/G2 are cancelled.
  • Audit found two scoped control limitations that do not rescue the failed gate: random coordinate swaps were not exact realized-delta norm matches, and repeated pairwise swaps are not a proper multi-layer set-to-target clamp.
  • Next branch: a separate context-local, set-clamped transport experiment with exact per-example delta-norm controls.

Data files 2

Result tables and metrics copied from the experiment folder — preview inline or open the raw file.

Reproduce

Smoke test

.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage smoke

Full run

.venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage fit-lens && .venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/run.py --stage positive-control && .venv/bin/python experiments/qwen35_4b_jacobian_value_transport/scripts/analyze.py

Run steps are documented inside the experiment folder (README and scripts).

Browse the experiment folder on GitHub ↗